app_rpt.c

Go to the documentation of this file.

#define  NEW_ASTERISK
/* #define OLD_ASTERISK */
/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2002-2008, Jim Dixon, WB6NIL
 *
 * Jim Dixon, WB6NIL <jim@lambdatel.com>
 * Serious contributions by Steve RoDgers, WA6ZFT <hwstar@rodgers.sdcoxmail.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 Radio Repeater / Remote Base program 
 *  version 0.115 5/12/08 2055 EDT
 * 
 * \author Jim Dixon, WB6NIL <jim@lambdatel.com>
 *
 * \note Serious contributions by Steve RoDgers, WA6ZFT <hwstar@rodgers.sdcoxmail.com>
 * \note Steven Henke, W9SH, <w9sh@arrl.net> added a few features here and there.
 *
 * See http://www.zapatatelephony.org/app_rpt.html
 *
 *
 * Repeater / Remote Functions:
 * "Simple" Mode:  * - autopatch access, # - autopatch hangup
 * Normal mode:
 * See the function list in rpt.conf (autopatchup, autopatchdn)
 * autopatchup can optionally take comma delimited setting=value pairs:
 *  
 *
 * context=string    :  Override default context with "string"
 * dialtime=ms       :  Specify the max number of milliseconds between phone number digits (1000 milliseconds = 1 second)
 * farenddisconnect=1      :  Automatically disconnect when called party hangs up
 * noct=1         :  Don't send repeater courtesy tone during autopatch calls
 * quiet=1        :  Don't send dial tone, or connect messages. Do not send patch down message when called party hangs up
 *
 *
 * Example: 123=autopatchup,dialtime=20000,noct=1,farenddisconnect=1
 *
 *  To send an asterisk (*) while dialing or talking on phone,
 *  use the autopatch acess code.
 *
 *
 * status cmds:
 *
 *  1 - Force ID (global)
 *  2 - Give Time of Day (global)
 *  3 - Give software Version (global)
 *  11 - Force ID (local only)
 *  12 - Give Time of Day (local only)
 *
 * cop (control operator) cmds:
 *
 *  1 - System warm boot
 *  2 - System enable
 *  3 - System disable
 *  4 - Test Tone On/Off
 *  5 - Dump System Variables on Console (debug)
 *  6 - PTT (phone mode only)
 *  7 - Time out timer enable
 *  8 - Time out timer disable
 *  9 - Autopatch enable
 *  10 - Autopatch disable
 *  11 - Link enable
 *  12 - Link disable
 *  13 - Query System State
 *  14 - Change System State
 *  15 - Scheduler Enable
 *  16 - Scheduler Disable
 *  17 - User functions (time, id, etc) enable
 *  18 - User functions (time, id, etc) disable
 *  19 - Select alternate hang timer
 *  20 - Select standard hang timer 
 *  21 - Enable Parrot Mode
 *  22 - Disable Parrot Mode
 *  23 - Birdbath (Current Parrot Cleanup/Flush)
 *  24 - Flush all telemetry
 *  25 - Query last node un-keyed
 *  26 - Query all nodes keyed/unkeyed
 *  30 - Recall Memory Setting in Attached Xcvr
 *  31 - Channel Selector for Parallel Programmed Xcvr
 *  32 - Touchtone pad test: command + Digit string + # to playback all digits pressed
 *
 * ilink cmds:
 *
 *  1 - Disconnect specified link
 *  2 - Connect specified link -- monitor only
 *  3 - Connect specified link -- tranceive
 *  4 - Enter command mode on specified link
 *  5 - System status
 *  6 - Disconnect all links
 *  11 - Disconnect a previously permanently connected link
 *  12 - Permanently connect specified link -- monitor only
 *  13 - Permanently connect specified link -- tranceive
 *  15 - Full system status (all nodes)
 *  16 - Reconnect links disconnected with "disconnect all links"
 *  200 thru 215 - (Send DTMF 0-9,*,#,A-D) (200=0, 201=1, 210=*, etc)
 *
 * remote cmds:
 *
 *  1 - Recall Memory MM  (*000-*099) (Gets memory from rpt.conf)
 *  2 - Set VFO MMMMM*KKK*O   (Mhz digits, Khz digits, Offset)
 *  3 - Set Rx PL Tone HHH*D*
 *  4 - Set Tx PL Tone HHH*D* (Not currently implemented with DHE RBI-1)
 *  5 - Link Status (long)
 *  6 - Set operating mode M (FM, USB, LSB, AM, etc)
 *  100 - RX PL off (Default)
 *  101 - RX PL On
 *  102 - TX PL Off (Default)
 *  103 - TX PL On
 *  104 - Low Power
 *  105 - Med Power
 *  106 - Hi Power
 *  107 - Bump Down 20 Hz
 *  108 - Bump Down 100 Hz
 *  109 - Bump Down 500 Hz
 *  110 - Bump Up 20 Hz
 *  111 - Bump Up 100 Hz
 *  112 - Bump Up 500 Hz
 *  113 - Scan Down Slow
 *  114 - Scan Down Medium
 *  115 - Scan Down Fast
 *  116 - Scan Up Slow
 *  117 - Scan Up Medium
 *  118 - Scan Up Fast
 *  119 - Transmit allowing auto-tune
 *  140 - Link Status (brief)
 *  200 thru 215 - (Send DTMF 0-9,*,#,A-D) (200=0, 201=1, 210=*, etc)
 *
 * playback cmds:
 *  specify the name of the file to be played (for example, 25=rpt/foo)
 *
 *
 * 'duplex' modes:  (defaults to duplex=2)
 *
 * 0 - Only remote links key Tx and no main repeat audio.
 * 1 - Everything other then main Rx keys Tx, no main repeat audio.
 * 2 - Normal mode
 * 3 - Normal except no main repeat audio.
 * 4 - Normal except no main repeat audio during autopatch only
 *
*/

/*** MODULEINFO
   <depend>dahdi</depend>
   <depend>tonezone</depend>
   <defaultenabled>no</defaultenabled>
 ***/

/* Un-comment the following to include support for MDC-1200 digital tone
   signalling protocol (using KA6SQG's GPL'ed implementation) */
/* #include "mdc_decode.c" */

/* Un-comment the following to include support for notch filters in the
   rx audio stream (using Tony Fisher's mknotch (mkfilter) implementation) */
/* #include "rpt_notch.c" */

/* maximum digits in DTMF buffer, and seconds after * for DTMF command timeout */

#ifdef OLD_ASTERISK
#define ast_free free
#define ast_malloc malloc
#define ast_strdup strdup
#endif


#define  MAXDTMF 32
#define  MAXMACRO 2048
#define  MAXLINKLIST 512
#define  LINKLISTTIME 10000
#define  LINKLISTSHORTTIME 200
#define  LINKPOSTTIME 30000
#define  LINKPOSTSHORTTIME 200
#define  KEYPOSTTIME 30000
#define  KEYPOSTSHORTTIME 200
#define  MACROTIME 100
#define  MACROPTIME 500
#define  DTMF_TIMEOUT 3
#define  KENWOOD_RETRIES 5
#define  TOPKEYN 32
#define  TOPKEYWAIT 3
#define  TOPKEYMAXSTR 30

#define  AUTHTELLTIME 7000
#define  AUTHTXTIME 1000
#define  AUTHLOGOUTTIME 25000

#ifdef   __RPT_NOTCH
#define  MAXFILTERS 10
#endif

#define  DISC_TIME 10000  /* report disc after 10 seconds of no connect */
#define  MAX_RETRIES 5
#define  MAX_RETRIES_PERM 1000000000

#define  REDUNDANT_TX_TIME 2000

#define  RETRY_TIMER_MS 5000

#define  PATCH_DIALPLAN_TIMEOUT 1500

#ifdef OLD_ASTERISK
#define  START_DELAY 10
#else
#define  START_DELAY 2
#endif

#define  RPT_LOCKOUT_SECS 10

#define MAXPEERSTR 31
#define  MAXREMSTR 15

#define  DELIMCHR ','
#define  QUOTECHR 34

#define  MONITOR_DISK_BLOCKS_PER_MINUTE 38

#define  DEFAULT_MONITOR_MIN_DISK_BLOCKS 10000
#define  DEFAULT_REMOTE_INACT_TIMEOUT (15 * 60)
#define  DEFAULT_REMOTE_TIMEOUT (60 * 60)
#define  DEFAULT_REMOTE_TIMEOUT_WARNING (3 * 60)
#define  DEFAULT_REMOTE_TIMEOUT_WARNING_FREQ 30

#define  NODES "nodes"
#define  EXTNODES "extnodes"
#define MEMORY "memory"
#define MACRO "macro"
#define  FUNCTIONS "functions"
#define TELEMETRY "telemetry"
#define MORSE "morse"
#define  TONEMACRO "tonemacro"
#define  FUNCCHAR '*'
#define  ENDCHAR '#'
#define  EXTNODEFILE "/var/lib/asterisk/rpt_extnodes"
#define  NODENAMES "rpt/nodenames"
#define  PARROTFILE "/tmp/parrot_%s_%u"

#define  PARROTTIME 1000

#define  DEFAULT_IOBASE 0x378

#define  DEFAULT_CIV_ADDR 0x58

#define  MAXCONNECTTIME 5000

#define MAXNODESTR 300

#define MAXNODELEN 16

#define MAXIDENTLEN 32

#define MAXPATCHCONTEXT 100

#define ACTIONSIZE 32

#define TELEPARAMSIZE 256

#define REM_SCANTIME 100

#define  DTMF_LOCAL_TIME 250
#define  DTMF_LOCAL_STARTTIME 500

#define  IC706_PL_MEMORY_OFFSET 50

#define  VOX_ON_DEBOUNCE_COUNT 3
#define  VOX_OFF_DEBOUNCE_COUNT 20
#define  VOX_MAX_THRESHOLD 10000.0
#define  VOX_MIN_THRESHOLD 3000.0
#define  VOX_TIMEOUT_MS 5000
#define  VOX_RECOVER_MS 500
#define  SIMPLEX_PATCH_DELAY 25
#define  SIMPLEX_PHONE_DELAY 25

#define  STATPOST_PROGRAM "/usr/bin/wget,-q,--output-document=/dev/null,--no-check-certificate"

#define  ALLOW_LOCAL_CHANNELS

enum {REM_OFF,REM_MONITOR,REM_TX};

enum{ID,PROC,TERM,COMPLETE,UNKEY,REMDISC,REMALREADY,REMNOTFOUND,REMGO,
   CONNECTED,CONNFAIL,STATUS,TIMEOUT,ID1, STATS_TIME, PLAYBACK,
   STATS_VERSION, IDTALKOVER, ARB_ALPHA, TEST_TONE, REV_PATCH,
   TAILMSG, MACRO_NOTFOUND, MACRO_BUSY, LASTNODEKEY, FULLSTATUS,
   MEMNOTFOUND, INVFREQ, REMMODE, REMLOGIN, REMXXX, REMSHORTSTATUS,
   REMLONGSTATUS, LOGINREQ, SCAN, SCANSTAT, TUNE, SETREMOTE, TOPKEY,
   TIMEOUT_WARNING, ACT_TIMEOUT_WARNING, LINKUNKEY, UNAUTHTX, PARROT,
   STATS_TIME_LOCAL};


enum {REM_SIMPLEX,REM_MINUS,REM_PLUS};

enum {REM_LOWPWR,REM_MEDPWR,REM_HIPWR};

enum {DC_INDETERMINATE, DC_REQ_FLUSH, DC_ERROR, DC_COMPLETE, DC_COMPLETEQUIET, DC_DOKEY};

enum {SOURCE_RPT, SOURCE_LNK, SOURCE_RMT, SOURCE_PHONE, SOURCE_DPHONE, SOURCE_ALT};

enum {DLY_TELEM, DLY_ID, DLY_UNKEY, DLY_CALLTERM, DLY_COMP, DLY_LINKUNKEY, DLY_PARROT};

enum {REM_MODE_FM,REM_MODE_USB,REM_MODE_LSB,REM_MODE_AM};

enum {HF_SCAN_OFF,HF_SCAN_DOWN_SLOW,HF_SCAN_DOWN_QUICK,
      HF_SCAN_DOWN_FAST,HF_SCAN_UP_SLOW,HF_SCAN_UP_QUICK,HF_SCAN_UP_FAST};

#include "asterisk.h"

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

#include <signal.h>
#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <search.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <dirent.h>
#include <ctype.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#ifdef HAVE_SYS_IO_H
#include <sys/io.h>
#endif
#include <sys/vfs.h>
#include <math.h>
#include <dahdi/user.h>
#include <dahdi/tonezone.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "asterisk/utils.h"
#include "asterisk/lock.h"
#include "asterisk/file.h"
#include "asterisk/logger.h"
#include "asterisk/channel.h"
#include "asterisk/callerid.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/translate.h"
#include "asterisk/features.h"
#include "asterisk/options.h"
#include "asterisk/cli.h"
#include "asterisk/config.h"
#include "asterisk/say.h"
#include "asterisk/localtime.h"
#include "asterisk/cdr.h"
#include "asterisk/options.h"
#include "asterisk/manager.h"
#include "asterisk/app.h"

#include <termios.h>

#ifdef   NEW_ASTERISK
struct ast_flags config_flags = { CONFIG_FLAG_WITHCOMMENTS };
#endif


/* Start a tone-list going */
int ast_playtones_start(struct ast_channel *chan, int vol, const char* tonelist, int interruptible);
/*! Stop the tones from playing */
void ast_playtones_stop(struct ast_channel *chan);

static  char *tdesc = "Radio Repeater / Remote Base  version 0.115  5/12/2008";

static char *app = "Rpt";

static char *synopsis = "Radio Repeater/Remote Base Control System";

static char *descrip = 
"  Rpt(nodename[|options][|M][|*]):  \n"
"    Radio Remote Link or Remote Base Link Endpoint Process.\n"
"\n"
"    Not specifying an option puts it in normal endpoint mode (where source\n"
"    IP and nodename are verified).\n"
"\n"
"    Options are as follows:\n"
"\n"
"        X - Normal endpoint mode WITHOUT security check. Only specify\n"
"            this if you have checked security already (like with an IAX2\n"
"            user/password or something).\n"
"\n"
"        Rannounce-string[|timeout[|timeout-destination]] - Amateur Radio\n"
"            Reverse Autopatch. Caller is put on hold, and announcement (as\n"
"            specified by the 'announce-string') is played on radio system.\n"
"            Users of radio system can access autopatch, dial specified\n"
"            code, and pick up call. Announce-string is list of names of\n"
"            recordings, or \"PARKED\" to substitute code for un-parking,\n"
"            or \"NODE\" to substitute node number.\n"
"\n"
"        P - Phone Control mode. This allows a regular phone user to have\n"
"            full control and audio access to the radio system. For the\n"
"            user to have DTMF control, the 'phone_functions' parameter\n"
"            must be specified for the node in 'rpt.conf'. An additional\n"
"            function (cop,6) must be listed so that PTT control is available.\n"
"\n"
"        D - Dumb Phone Control mode. This allows a regular phone user to\n"
"            have full control and audio access to the radio system. In this\n"
"            mode, the PTT is activated for the entire length of the call.\n"
"            For the user to have DTMF control (not generally recomended in\n"
"            this mode), the 'dphone_functions' parameter must be specified\n"
"            for the node in 'rpt.conf'. Otherwise no DTMF control will be\n"
"            available to the phone user.\n"
"\n"
"        S - Simplex Dumb Phone Control mode. This allows a regular phone user\n"
"            audio-only access to the radio system. In this mode, the\n"
"            transmitter is toggled on and off when the phone user presses the\n"
"            funcchar (*) key on the telephone set. In addition, the transmitter\n"
"            will turn off if the endchar (#) key is pressed. When a user first\n"
"            calls in, the transmitter will be off, and the user can listen for\n"
"            radio traffic. When the user wants to transmit, they press the *\n" 
"            key, start talking, then press the * key again or the # key to turn\n"
"            the transmitter off.  No other functions can be executed by the\n"
"            user on the phone when this mode is selected. Note: If your\n"
"            radio system is full-duplex, we recommend using either P or D\n"
"            modes as they provide more flexibility.\n"
"\n"
"        q - Query Status. Sets channel variables and returns + 101 in plan.\n"
"\n"
"        M - Memory Channel Steer as MXX where XX is the memory channel number.\n"
"\n"
"        * - Alt Macro to execute (e.g. *7 for status)\n"
"\n";
;

static int debug = 0;  /* Set this >0 for extra debug output */
static int nrpts = 0;

static char remdtmfstr[] = "0123456789*#ABCD";

enum {TOP_TOP,TOP_WON,WON_BEFREAD,BEFREAD_AFTERREAD};

int max_chan_stat [] = {22000,1000,22000,100,22000,2000,22000};

#define NRPTSTAT 7

struct rpt_chan_stat
{
   struct timeval last;
   long long total;
   unsigned long count;
   unsigned long largest;
   struct timeval largest_time;
};

char *discstr = "!!DISCONNECT!!";
char *newkeystr = "!NEWKEY!";
static char *remote_rig_ft897="ft897";
static char *remote_rig_rbi="rbi";
static char *remote_rig_kenwood="kenwood";
static char *remote_rig_tm271="tm271";
static char *remote_rig_ic706="ic706";
static char *remote_rig_rtx150="rtx150";
static char *remote_rig_rtx450="rtx450";
static char *remote_rig_ppp16="ppp16";       // parallel port programmable 16 channels

#define ISRIG_RTX(x) ((!strcmp(x,remote_rig_rtx150)) || (!strcmp(x,remote_rig_rtx450)))
#define  IS_XPMR(x) (!strncasecmp(x->rxchanname,"rad",3))

#ifdef   OLD_ASTERISK
STANDARD_LOCAL_USER;
LOCAL_USER_DECL;
#endif

#define  MSWAIT 200
#define  HANGTIME 5000
#define  TOTIME 180000
#define  IDTIME 300000
#define  MAXRPTS 20
#define MAX_STAT_LINKS 32
#define POLITEID 30000
#define FUNCTDELAY 1500

#define  MAXXLAT 20
#define  MAXXLATTIME 3

#define MAX_SYSSTATES 10

struct vox {
   float speech_energy;
   float noise_energy;
   int   enacount;
   char  voxena;
   char  lastvox;
   int   offdebcnt;
   int   ondebcnt;
} ;

#define  mymax(x,y) ((x > y) ? x : y)
#define  mymin(x,y) ((x < y) ? x : y)

struct rpt_topkey
{
char  node[TOPKEYMAXSTR];
int   timesince;
int   keyed;
} ;

struct rpt_xlat
{
char  funccharseq[MAXXLAT];
char  endcharseq[MAXXLAT];
char  passchars[MAXXLAT];
int   funcindex;
int   endindex;
time_t   lastone;
} ;

static time_t  starttime = 0;

static  pthread_t rpt_master_thread;

struct rpt;

struct rpt_link
{
   struct rpt_link *next;
   struct rpt_link *prev;
   char  mode;       /* 1 if in tx mode */
   char  isremote;
   char  phonemode;
   char  phonevox;      /* vox the phone */
   char  name[MAXNODESTR]; /* identifier (routing) string */
   char  lasttx;
   char  lasttx1;
   char  lastrx;
   char  lastrealrx;
   char  lastrx1;
   char  connected;
   char  hasconnected;
   char  perma;
   char  thisconnected;
   char  outbound;
   char  disced;
   char  killme;
   long  elaptime;
   long  disctime;
   long  retrytimer;
   long  retxtimer;
   long  rerxtimer;
   int   retries;
   int   max_retries;
   int   reconnects;
   long long connecttime;
   struct ast_channel *chan;  
   struct ast_channel *pchan; 
   char  linklist[MAXLINKLIST];
   time_t   linklistreceived;
   long  linklisttimer;
   int   dtmfed;
   int linkunkeytocttimer;
   struct timeval lastlinktv;
   struct   ast_frame *lastf1,*lastf2;
   struct   rpt_chan_stat chan_stat[NRPTSTAT];
   struct vox vox;
   char wasvox;
   int voxtotimer;
   char voxtostate;
   char newkey;
#ifdef OLD_ASTERISK
        AST_LIST_HEAD(, ast_frame) rxq;
#else
   AST_LIST_HEAD_NOLOCK(, ast_frame) rxq;
#endif
} ;

struct rpt_lstat
{
   struct   rpt_lstat *next;
   struct   rpt_lstat *prev;
   char  peer[MAXPEERSTR];
   char  name[MAXNODESTR];
   char  mode;
   char  outbound;
   char  reconnects;
   char  thisconnected;
   long long   connecttime;
   struct   rpt_chan_stat chan_stat[NRPTSTAT];
} ;

struct rpt_tele
{
   struct rpt_tele *next;
   struct rpt_tele *prev;
   struct rpt *rpt;
   struct ast_channel *chan;
   int   mode;
   struct rpt_link mylink;
   char param[TELEPARAMSIZE];
   intptr_t submode;
   uintptr_t  parrot;
   pthread_t threadid;
} ;

struct function_table_tag
{
   char action[ACTIONSIZE];
   int (*function)(struct rpt *myrpt, char *param, char *digitbuf, 
      int command_source, struct rpt_link *mylink);
} ;

/* Used to store the morse code patterns */

struct morse_bits
{       
   int len;
   int ddcomb;
} ;

struct telem_defaults
{
   char name[20];
   char value[80];
} ;


struct sysstate
{
   char txdisable;
   char totdisable;
   char linkfundisable;
   char autopatchdisable;
   char schedulerdisable;
   char userfundisable;
   char alternatetail;
};

/* rpt cmd support */
#define CMD_DEPTH 1
#define CMD_STATE_IDLE 0
#define CMD_STATE_BUSY 1
#define CMD_STATE_READY 2
#define CMD_STATE_EXECUTING 3

struct rpt_cmd_struct
{
    int state;
    int functionNumber;
    char param[MAXDTMF];
    char digits[MAXDTMF];
    int command_source;
};

static struct rpt
{
   ast_mutex_t lock;
   ast_mutex_t remlock;
   ast_mutex_t statpost_lock;
   struct ast_config *cfg;
   char reload;
   char xlink;                         // cross link state of a share repeater/remote radio
   unsigned int statpost_seqno;

   char *name;
   char *rxchanname;
   char *txchanname;
   char remote;
   char *remoterig;
   struct   rpt_chan_stat chan_stat[NRPTSTAT];
   unsigned int scram;

   struct {
      char *ourcontext;
      char *ourcallerid;
      char *acctcode;
      char *ident;
      char *tonezone;
      char simple;
      char *functions;
      char *link_functions;
      char *phone_functions;
      char *dphone_functions;
      char *alt_functions;
      char *nodes;
      char *extnodes;
      char *extnodefile;
      int hangtime;
      int althangtime;
      int totime;
      int idtime;
      int tailmessagetime;
      int tailsquashedtime;
      int duplex;
      int politeid;
      char *tailmessages[500];
      int tailmessagemax;
      char  *memory;
      char  *macro;
      char  *tonemacro;
      char  *startupmacro;
      int iobase;
      char *ioport;
      char funcchar;
      char endchar;
      char nobusyout;
      char notelemtx;
      char propagate_dtmf;
      char propagate_phonedtmf;
      char linktolink;
      unsigned char civaddr;
      struct rpt_xlat inxlat;
      struct rpt_xlat outxlat;
      char *archivedir;
      int authlevel;
      char *csstanzaname;
      char *skedstanzaname;
      char *txlimitsstanzaname;
      long monminblocks;
      int remoteinacttimeout;
      int remotetimeout;
      int remotetimeoutwarning;
      int remotetimeoutwarningfreq;
      int sysstate_cur;
      struct sysstate s[MAX_SYSSTATES];
      char parrotmode;
      int parrottime;
      char *rptnode;
      char remote_mars;
      int voxtimeout_ms;
      int voxrecover_ms;
      int simplexpatchdelay;
      int simplexphonedelay;
      char *statpost_program;
      char *statpost_url;
   } p;
   struct rpt_link links;
   int unkeytocttimer;
   time_t lastkeyedtime;
   time_t lasttxkeyedtime;
   char keyed;
   char txkeyed;
   char exttx;
   char localtx;
   char remoterx;
   char remotetx;
   char remoteon;
   char remtxfreqok;
   char tounkeyed;
   char tonotify;
   char dtmfbuf[MAXDTMF];
   char macrobuf[MAXMACRO];
   char rem_dtmfbuf[MAXDTMF];
   char lastdtmfcommand[MAXDTMF];
   char cmdnode[50];
   char nowchan;                 // channel now
   char waschan;                 // channel selected initially or by command
   char bargechan;                  // barge in channel
   char macropatch;              // autopatch via tonemacro state
   char parrotstate;
   int  parrottimer;
   unsigned int parrotcnt;
   struct ast_channel *rxchannel,*txchannel, *monchannel, *parrotchannel;
   struct ast_channel *pchannel,*txpchannel, *dahdirxchannel, *dahditxchannel;
   struct ast_channel *voxchannel;
   struct ast_frame *lastf1,*lastf2;
   struct rpt_tele tele;
   struct timeval lasttv,curtv;
   pthread_t rpt_call_thread,rpt_thread;
   time_t dtmf_time,rem_dtmf_time,dtmf_time_rem;
   int calldigittimer;
   int tailtimer,totimer,idtimer,txconf,conf,callmode,cidx,scantimer,tmsgtimer,skedtimer;
   int mustid,tailid;
   int tailevent;
   int telemrefcount;
   int dtmfidx,rem_dtmfidx;
   int dailytxtime,dailykerchunks,totalkerchunks,dailykeyups,totalkeyups,timeouts;
   int totalexecdcommands, dailyexecdcommands;
   long  retxtimer;
   long  rerxtimer;
   long long totaltxtime;
   char mydtmf;
   char exten[AST_MAX_EXTENSION];
   char freq[MAXREMSTR],rxpl[MAXREMSTR],txpl[MAXREMSTR];
   char offset;
   char powerlevel;
   char txplon;
   char rxplon;
   char remmode;
   char tunerequest;
   char hfscanmode;
   int hfscanstatus;
   char hfscanstop;
   char lastlinknode[MAXNODESTR];
   char savednodes[MAXNODESTR];
   int stopgen;
   char patchfarenddisconnect;
   char patchnoct;
   char patchquiet;
   char patchcontext[MAXPATCHCONTEXT];
   int patchdialtime;
   int macro_longest;
   int phone_longestfunc;
   int alt_longestfunc;
   int dphone_longestfunc;
   int link_longestfunc;
   int longestfunc;
   int longestnode;
   int threadrestarts;     
   int tailmessagen;
   time_t disgorgetime;
   time_t lastthreadrestarttime;
   long  macrotimer;
   char  lastnodewhichkeyedusup[MAXNODESTR];
   int   dtmf_local_timer;
   char  dtmf_local_str[100];
   struct ast_filestream *monstream,*parrotstream;
   char  loginuser[50];
   char  loginlevel[10];
   long  authtelltimer;
   long  authtimer;
   int iofd;
   time_t start_time,last_activity_time;
   char  lasttone[32];
   struct rpt_tele *active_telem;
   struct   rpt_topkey topkey[TOPKEYN];
   int topkeystate;
   time_t topkeytime;
   int topkeylong;
   struct vox vox;
   char wasvox;
   int voxtotimer;
   char voxtostate;
   int linkposttimer;         
   int keyposttimer;       
   char newkey;
   char inpadtest;
#ifdef OLD_ASTERISK
   AST_LIST_HEAD(, ast_frame) txq;
#else
   AST_LIST_HEAD_NOLOCK(, ast_frame) txq;
#endif
   char txrealkeyed;
#ifdef   __RPT_NOTCH
   struct rptfilter
   {
      char  desc[100];
      float x0;
      float x1;
      float x2;
      float y0;
      float y1;
      float y2;
      float gain;
      float const0;
      float const1;
      float const2;
   } filters[MAXFILTERS];
#endif
#ifdef   _MDC_DECODE_H_
   mdc_decoder_t *mdc;
   unsigned short lastunit;
#endif
   struct rpt_cmd_struct cmdAction;
} rpt_vars[MAXRPTS]; 

struct nodelog {
struct nodelog *next;
struct nodelog *prev;
time_t   timestamp;
char archivedir[MAXNODESTR];
char str[MAXNODESTR * 2];
} nodelog;

static int service_scan(struct rpt *myrpt);
static int set_mode_ft897(struct rpt *myrpt, char newmode);
static int set_mode_ic706(struct rpt *myrpt, char newmode);
static int simple_command_ft897(struct rpt *myrpt, char command);
static int setrem(struct rpt *myrpt);
static int setrtx_check(struct rpt *myrpt);
static int channel_revert(struct rpt *myrpt);
static int channel_steer(struct rpt *myrpt, char *data);

AST_MUTEX_DEFINE_STATIC(nodeloglock);

AST_MUTEX_DEFINE_STATIC(nodelookuplock);

#ifdef   APP_RPT_LOCK_DEBUG

#warning COMPILING WITH LOCK-DEBUGGING ENABLED!!

#define  MAXLOCKTHREAD 100

#define rpt_mutex_lock(x) _rpt_mutex_lock(x,myrpt,__LINE__)
#define rpt_mutex_unlock(x) _rpt_mutex_unlock(x,myrpt,__LINE__)

struct lockthread
{
   pthread_t id;
   int lockcount;
   int lastlock;
   int lastunlock;
} lockthreads[MAXLOCKTHREAD];


struct by_lightning
{
   int line;
   struct timeval tv;
   struct rpt *rpt;
   struct lockthread lockthread;
} lock_ring[32];

int lock_ring_index = 0;

AST_MUTEX_DEFINE_STATIC(locklock);

static struct lockthread *get_lockthread(pthread_t id)
{
int   i;

   for(i = 0; i < MAXLOCKTHREAD; i++)
   {
      if (lockthreads[i].id == id) return(&lockthreads[i]);
   }
   return(NULL);
}

static struct lockthread *put_lockthread(pthread_t id)
{
int   i;

   for(i = 0; i < MAXLOCKTHREAD; i++)
   {
      if (lockthreads[i].id == id)
         return(&lockthreads[i]);
   }
   for(i = 0; i < MAXLOCKTHREAD; i++)
   {
      if (!lockthreads[i].id)
      {
         lockthreads[i].lockcount = 0;
         lockthreads[i].lastlock = 0;
         lockthreads[i].lastunlock = 0;
         lockthreads[i].id = id;
         return(&lockthreads[i]);
      }
   }
   return(NULL);
}


static void rpt_mutex_spew(void)
{
   struct by_lightning lock_ring_copy[32];
   int lock_ring_index_copy;
   int i,j;
   long long diff;
   char a[100];
   struct timeval lasttv;

   ast_mutex_lock(&locklock);
   memcpy(&lock_ring_copy, &lock_ring, sizeof(lock_ring_copy));
   lock_ring_index_copy = lock_ring_index;
   ast_mutex_unlock(&locklock);

   lasttv.tv_sec = lasttv.tv_usec = 0;
   for(i = 0 ; i < 32 ; i++)
   {
      j = (i + lock_ring_index_copy) % 32;
      strftime(a,sizeof(a) - 1,"%m/%d/%Y %H:%M:%S",
         localtime(&lock_ring_copy[j].tv.tv_sec));
      diff = 0;
      if(lasttv.tv_sec)
      {
         diff = (lock_ring_copy[j].tv.tv_sec - lasttv.tv_sec)
            * 1000000;
         diff += (lock_ring_copy[j].tv.tv_usec - lasttv.tv_usec);
      }
      lasttv.tv_sec = lock_ring_copy[j].tv.tv_sec;
      lasttv.tv_usec = lock_ring_copy[j].tv.tv_usec;
      if (!lock_ring_copy[j].tv.tv_sec) continue;
      if (lock_ring_copy[j].line < 0)
      {
         ast_log(LOG_NOTICE,"LOCKDEBUG [#%d] UNLOCK app_rpt.c:%d node %s pid %x diff %lld us at %s.%06d\n",
            i - 31,-lock_ring_copy[j].line,lock_ring_copy[j].rpt->name,(int) lock_ring_copy[j].lockthread.id,diff,a,(int)lock_ring_copy[j].tv.tv_usec);
      }
      else
      {
         ast_log(LOG_NOTICE,"LOCKDEBUG [#%d] LOCK app_rpt.c:%d node %s pid %x diff %lld us at %s.%06d\n",
            i - 31,lock_ring_copy[j].line,lock_ring_copy[j].rpt->name,(int) lock_ring_copy[j].lockthread.id,diff,a,(int)lock_ring_copy[j].tv.tv_usec);
      }
   }
}


static void _rpt_mutex_lock(ast_mutex_t *lockp, struct rpt *myrpt, int line)
{
struct lockthread *t;
pthread_t id;

   id = pthread_self();
   ast_mutex_lock(&locklock);
   t = put_lockthread(id);
   if (!t)
   {
      ast_mutex_unlock(&locklock);
      return;
   }
   if (t->lockcount)
   {
      int lastline = t->lastlock;
      ast_mutex_unlock(&locklock);
      ast_log(LOG_NOTICE,"rpt_mutex_lock: Double lock request line %d node %s pid %x, last lock was line %d\n",line,myrpt->name,(int) t->id,lastline);
      rpt_mutex_spew();
      return;
   }
   t->lastlock = line;
   t->lockcount = 1;
   gettimeofday(&lock_ring[lock_ring_index].tv, NULL);
   lock_ring[lock_ring_index].rpt = myrpt;
   memcpy(&lock_ring[lock_ring_index].lockthread,t,sizeof(struct lockthread));
   lock_ring[lock_ring_index++].line = line;
   if(lock_ring_index == 32)
      lock_ring_index = 0;
   ast_mutex_unlock(&locklock);
   ast_mutex_lock(lockp);
}


static void _rpt_mutex_unlock(ast_mutex_t *lockp, struct rpt *myrpt, int line)
{
struct lockthread *t;
pthread_t id;

   id = pthread_self();
   ast_mutex_lock(&locklock);
   t = put_lockthread(id);
   if (!t)
   {
      ast_mutex_unlock(&locklock);
      return;
   }
   if (!t->lockcount)
   {
      int lastline = t->lastunlock;
      ast_mutex_unlock(&locklock);
      ast_log(LOG_NOTICE,"rpt_mutex_lock: Double un-lock request line %d node %s pid %x, last un-lock was line %d\n",line,myrpt->name,(int) t->id,lastline);
      rpt_mutex_spew();
      return;
   }
   t->lastunlock = line;
   t->lockcount = 0;
   gettimeofday(&lock_ring[lock_ring_index].tv, NULL);
   lock_ring[lock_ring_index].rpt = myrpt;
   memcpy(&lock_ring[lock_ring_index].lockthread,t,sizeof(struct lockthread));
   lock_ring[lock_ring_index++].line = -line;
   if(lock_ring_index == 32)
      lock_ring_index = 0;
   ast_mutex_unlock(&locklock);
   ast_mutex_unlock(lockp);
}

#else  /* APP_RPT_LOCK_DEBUG */

#define rpt_mutex_lock(x) ast_mutex_lock(x)
#define rpt_mutex_unlock(x) ast_mutex_unlock(x)

#endif  /* APP_RPT_LOCK_DEBUG */

/*
* Return 1 if rig is multimode capable
*/

static int multimode_capable(struct rpt *myrpt)
{
   if(!strcmp(myrpt->remoterig, remote_rig_ft897))
      return 1;
   if(!strcmp(myrpt->remoterig, remote_rig_ic706))
      return 1;
   return 0;
}  

static void voxinit_rpt(struct rpt *myrpt,char enable)
{

   myrpt->vox.speech_energy = 0.0;
   myrpt->vox.noise_energy = 0.0;
   myrpt->vox.enacount = 0;
   myrpt->vox.voxena = 0;
   if (!enable) myrpt->vox.voxena = -1;
   myrpt->vox.lastvox = 0;
   myrpt->vox.ondebcnt = VOX_ON_DEBOUNCE_COUNT;
   myrpt->vox.offdebcnt = VOX_OFF_DEBOUNCE_COUNT;
   myrpt->wasvox = 0;
   myrpt->voxtotimer = 0;
   myrpt->voxtostate = 0;
}

static void voxinit_link(struct rpt_link *mylink,char enable)
{

   mylink->vox.speech_energy = 0.0;
   mylink->vox.noise_energy = 0.0;
   mylink->vox.enacount = 0;
   mylink->vox.voxena = 0;
   if (!enable) mylink->vox.voxena = -1;
   mylink->vox.lastvox = 0;
   mylink->vox.ondebcnt = VOX_ON_DEBOUNCE_COUNT;
   mylink->vox.offdebcnt = VOX_OFF_DEBOUNCE_COUNT;
   mylink->wasvox = 0;
   mylink->voxtotimer = 0;
   mylink->voxtostate = 0;
}

static int dovox(struct vox *v,short *buf,int bs)
{

   int i;
   float esquare = 0.0;
   float energy = 0.0;
   float threshold = 0.0;
   
   if (v->voxena < 0) return(v->lastvox);
   for(i = 0; i < bs; i++)
   {
      esquare += (float) buf[i] * (float) buf[i];
   }
   energy = sqrt(esquare);

   if (energy >= v->speech_energy)
      v->speech_energy += (energy - v->speech_energy) / 4;
   else
      v->speech_energy += (energy - v->speech_energy) / 64;

   if (energy >= v->noise_energy)
      v->noise_energy += (energy - v->noise_energy) / 64;
   else
      v->noise_energy += (energy - v->noise_energy) / 4;
   
   if (v->voxena) threshold = v->speech_energy / 8;
   else
   {
      threshold = mymax(v->speech_energy / 16,v->noise_energy * 2);
      threshold = mymin(threshold,VOX_MAX_THRESHOLD);
   }
   threshold = mymax(threshold,VOX_MIN_THRESHOLD);
   if (energy > threshold)
   {
      if (v->voxena) v->noise_energy *= 0.75;
      v->voxena = 1;
   } else   v->voxena = 0;
   if (v->lastvox != v->voxena)
   {
      if (v->enacount++ >= ((v->lastvox) ? v->offdebcnt : v->ondebcnt))
      {
         v->lastvox = v->voxena;
         v->enacount = 0;
      }
   } else v->enacount = 0;
   return(v->lastvox);
}




/*
* CLI extensions
*/

/* Debug mode */
static int rpt_do_debug(int fd, int argc, char *argv[]);
static int rpt_do_dump(int fd, int argc, char *argv[]);
static int rpt_do_stats(int fd, int argc, char *argv[]);
static int rpt_do_lstats(int fd, int argc, char *argv[]);
static int rpt_do_nodes(int fd, int argc, char *argv[]);
static int rpt_do_local_nodes(int fd, int argc, char *argv[]);
static int rpt_do_reload(int fd, int argc, char *argv[]);
static int rpt_do_restart(int fd, int argc, char *argv[]);
static int rpt_do_fun(int fd, int argc, char *argv[]);
static int rpt_do_fun1(int fd, int argc, char *argv[]);
static int rpt_do_cmd(int fd, int argc, char *argv[]);

static char debug_usage[] =
"Usage: rpt debug level {0-7}\n"
"       Enables debug messages in app_rpt\n";

static char dump_usage[] =
"Usage: rpt dump <nodename>\n"
"       Dumps struct debug info to log\n";

static char dump_stats[] =
"Usage: rpt stats <nodename>\n"
"       Dumps node statistics to console\n";

static char dump_lstats[] =
"Usage: rpt lstats <nodename>\n"
"       Dumps link statistics to console\n";

static char dump_nodes[] =
"Usage: rpt nodes <nodename>\n"
"       Dumps a list of directly and indirectly connected nodes to the console\n";

static char usage_local_nodes[] =
"Usage: rpt localnodes\n"
"       Dumps a list of the locally configured node numbers to the console.\n";

static char reload_usage[] =
"Usage: rpt reload\n"
"       Reloads app_rpt running config parameters\n";

static char restart_usage[] =
"Usage: rpt restart\n"
"       Restarts app_rpt\n";

static char fun_usage[] =
"Usage: rpt fun <nodename> <command>\n"
"       Send a DTMF function to a node\n";

static char cmd_usage[] =
"Usage: rpt cmd <nodename> <cmd-name> <cmd-index> <cmd-args.\n"
"       Send a command to a node.\n        i.e. rpt cmd 2000 ilink 3 2001\n";

#ifndef  NEW_ASTERISK

static struct ast_cli_entry  cli_debug =
        { { "rpt", "debug", "level" }, rpt_do_debug, 
      "Enable app_rpt debugging", debug_usage };

static struct ast_cli_entry  cli_dump =
        { { "rpt", "dump" }, rpt_do_dump,
      "Dump app_rpt structs for debugging", dump_usage };

static struct ast_cli_entry  cli_stats =
        { { "rpt", "stats" }, rpt_do_stats,
      "Dump node statistics", dump_stats };

static struct ast_cli_entry  cli_nodes =
        { { "rpt", "nodes" }, rpt_do_nodes,
      "Dump node list", dump_nodes };

static struct ast_cli_entry  cli_local_nodes =
        { { "rpt", "localnodes" }, rpt_do_local_nodes,
      "Dump list of local node numbers", usage_local_nodes };

static struct ast_cli_entry  cli_lstats =
        { { "rpt", "lstats" }, rpt_do_lstats,
      "Dump link statistics", dump_lstats };

static struct ast_cli_entry  cli_reload =
        { { "rpt", "reload" }, rpt_do_reload,
      "Reload app_rpt config", reload_usage };

static struct ast_cli_entry  cli_restart =
        { { "rpt", "restart" }, rpt_do_restart,
      "Restart app_rpt", restart_usage };

static struct ast_cli_entry  cli_fun =
        { { "rpt", "fun" }, rpt_do_fun,
      "Execute a DTMF function", fun_usage };

static struct ast_cli_entry  cli_fun1 =
        { { "rpt", "fun1" }, rpt_do_fun1,
      "Execute a DTMF function", fun_usage };

static struct ast_cli_entry  cli_cmd =
        { { "rpt", "cmd" }, rpt_do_cmd,
      "Execute a DTMF function", cmd_usage };

#endif

/*
* Telemetry defaults
*/


static struct telem_defaults tele_defs[] = {
   {"ct1","|t(350,0,100,3072)(500,0,100,3072)(660,0,100,3072)"},
   {"ct2","|t(660,880,150,3072)"},
   {"ct3","|t(440,0,150,3072)"},
   {"ct4","|t(550,0,150,3072)"},
   {"ct5","|t(660,0,150,3072)"},
   {"ct6","|t(880,0,150,3072)"},
   {"ct7","|t(660,440,150,3072)"},
   {"ct8","|t(700,1100,150,3072)"},
   {"remotemon","|t(1600,0,75,2048)"},
   {"remotetx","|t(2000,0,75,2048)(0,0,75,0)(1600,0,75,2048)"},
   {"cmdmode","|t(900,904,200,2048)"},
   {"functcomplete","|t(1000,0,100,2048)(0,0,100,0)(1000,0,100,2048)"}
} ;

/*
* Forward decl's - these suppress compiler warnings when funcs coded further down the file than thier invokation
*/

static int setrbi(struct rpt *myrpt);
static int set_ft897(struct rpt *myrpt);
static int set_ic706(struct rpt *myrpt);
static int setkenwood(struct rpt *myrpt);
static int set_tm271(struct rpt *myrpt);
static int setrbi_check(struct rpt *myrpt);



/*
* Define function protos for function table here
*/

static int function_ilink(struct rpt *myrpt, char *param, char *digitbuf, int command_source, struct rpt_link *mylink);
static int function_autopatchup(struct rpt *myrpt, char *param, char *digitbuf, int command_source, struct rpt_link *mylink);
static int function_autopatchdn(struct rpt *myrpt, char *param, char *digitbuf, int command_source, struct rpt_link *mylink);
static int function_status(struct rpt *myrpt, char *param, char *digitbuf, int command_source, struct rpt_link *mylink);
static int function_cop(struct rpt *myrpt, char *param, char *digitbuf, int command_source, struct rpt_link *mylink);
static int function_remote(struct rpt *myrpt, char *param, char *digitbuf, int command_source, struct rpt_link *mylink);
static int function_macro(struct rpt *myrpt, char *param, char *digitbuf, int command_source, struct rpt_link *mylink);
static int function_playback(struct rpt *myrpt, char *param, char *digitbuf, int command_source, struct rpt_link *mylink);
/*
* Function table
*/

static struct function_table_tag function_table[] = {
   {"cop", function_cop},
   {"autopatchup", function_autopatchup},
   {"autopatchdn", function_autopatchdn},
   {"ilink", function_ilink},
   {"status", function_status},
   {"remote", function_remote},
   {"macro", function_macro},
   {"playback", function_playback}
} ;

static long diskavail(struct rpt *myrpt)
{
struct   statfs statfsbuf;

   if (!myrpt->p.archivedir) return(0);
   if (statfs(myrpt->p.archivedir,&statfsbuf) == -1)
   {
      ast_log(LOG_WARNING,"Cannot get filesystem size for %s node %s\n",
         myrpt->p.archivedir,myrpt->name);
      return(-1);
   }
   return(statfsbuf.f_bavail);
}

static void flush_telem(struct rpt *myrpt)
{
   struct rpt_tele *telem;
   if(debug > 2)
      ast_log(LOG_NOTICE, "flush_telem()!!");
   rpt_mutex_lock(&myrpt->lock);
   telem = myrpt->tele.next;
   while(telem != &myrpt->tele)
   {
      if (telem->mode != SETREMOTE) ast_softhangup(telem->chan,AST_SOFTHANGUP_DEV);
      telem = telem->next;
   }
   rpt_mutex_unlock(&myrpt->lock);
}
/*
   return via error priority
*/
static int priority_jump(struct rpt *myrpt, struct ast_channel *chan)
{
   int res=0;

   // if (ast_test_flag(&flags,OPT_JUMP) && ast_goto_if_exists(chan, chan->context, chan->exten, chan->priority + 101) == 0){
   if (ast_goto_if_exists(chan, chan->context, chan->exten, chan->priority + 101) == 0){
      res = 0;
   } else {
      res = -1;
   }
   return res;
}
/*
*/
static int linkcount(struct rpt *myrpt)
{
   struct   rpt_link *l;
   char *reverse_patch_state;
   int numoflinks;

   reverse_patch_state = "DOWN";
   numoflinks = 0;
   l = myrpt->links.next;
   while(l && (l != &myrpt->links)){
      if(numoflinks >= MAX_STAT_LINKS){
         ast_log(LOG_WARNING,
         "maximum number of links exceeds %d in rpt_do_stats()!",MAX_STAT_LINKS);
         break;
      }
      //if (l->name[0] == '0'){ /* Skip '0' nodes */
      // reverse_patch_state = "UP";
      // l = l->next;
      // continue;
      //}
      numoflinks++;
    
      l = l->next;
   }
   ast_log(LOG_NOTICE, "numoflinks=%i\n",numoflinks);
   return numoflinks;
}
/*
 * Retrieve a memory channel
 * Return 0 if sucessful,
 * -1 if channel not found,
 *  1 if parse error
 */
static int retreive_memory(struct rpt *myrpt, char *memory)
{
   char tmp[30], *s, *s1, *val;

   if (debug)ast_log(LOG_NOTICE, "memory=%s block=%s\n",memory,myrpt->p.memory);

   val = (char *) ast_variable_retrieve(myrpt->cfg, myrpt->p.memory, memory);
   if (!val){
      return -1;
   }        
   strncpy(tmp,val,sizeof(tmp) - 1);
   tmp[sizeof(tmp)-1] = 0;

   s = strchr(tmp,',');
   if (!s)
      return 1; 
   *s++ = 0;
   s1 = strchr(s,',');
   if (!s1)
      return 1;
   *s1++ = 0;
   strncpy(myrpt->freq, tmp, sizeof(myrpt->freq) - 1);
   strncpy(myrpt->rxpl, s, sizeof(myrpt->rxpl) - 1);
   strncpy(myrpt->txpl, s, sizeof(myrpt->rxpl) - 1);
   myrpt->remmode = REM_MODE_FM;
   myrpt->offset = REM_SIMPLEX;
   myrpt->powerlevel = REM_MEDPWR;
   myrpt->txplon = myrpt->rxplon = 0;
   while(*s1){
      switch(*s1++){
         case 'A':
         case 'a':
            strcpy(myrpt->rxpl, "100.0");
            strcpy(myrpt->txpl, "100.0");
            myrpt->remmode = REM_MODE_AM; 
            break;
         case 'B':
         case 'b':
            strcpy(myrpt->rxpl, "100.0");
            strcpy(myrpt->txpl, "100.0");
            myrpt->remmode = REM_MODE_LSB;
            break;
         case 'F':
            myrpt->remmode = REM_MODE_FM;
            break;
         case 'L':
         case 'l':
            myrpt->powerlevel = REM_LOWPWR;
            break;               
         case 'H':
         case 'h':
            myrpt->powerlevel = REM_HIPWR;
            break;
               
         case 'M':
         case 'm':
            myrpt->powerlevel = REM_MEDPWR;
            break;
                  
         case '-':
            myrpt->offset = REM_MINUS;
            break;
                  
         case '+':
            myrpt->offset = REM_PLUS;
            break;
                  
         case 'S':
         case 's':
            myrpt->offset = REM_SIMPLEX;
            break;
                  
         case 'T':
         case 't':
            myrpt->txplon = 1;
            break;
                  
         case 'R':
         case 'r':
            myrpt->rxplon = 1;
            break;

         case 'U':
         case 'u':
            strcpy(myrpt->rxpl, "100.0");
            strcpy(myrpt->txpl, "100.0");
            myrpt->remmode = REM_MODE_USB;
            break;
         default:
            return 1;
      }
   }
   return 0;
}
/*

*/
static void birdbath(struct rpt *myrpt)
{
   struct rpt_tele *telem;
   if(debug > 2)
      ast_log(LOG_NOTICE, "birdbath!!");
   rpt_mutex_lock(&myrpt->lock);
   telem = myrpt->tele.next;
   while(telem != &myrpt->tele)
   {
      if (telem->mode == PARROT) ast_softhangup(telem->chan,AST_SOFTHANGUP_DEV);
      telem = telem->next;
   }
   rpt_mutex_unlock(&myrpt->lock);
}

static void do_dtmf_phone(struct rpt *myrpt, struct rpt_link *mylink, char c)
{
struct        rpt_link *l;

       l = myrpt->links.next;
       /* go thru all the links */
       while(l != &myrpt->links)
       {
               if (!l->phonemode)
               {
                       l = l->next;
                       continue;
               }
               /* dont send to self */
               if (mylink && (l == mylink))
               {
                       l = l->next;
                       continue;
               }
#ifdef   NEW_ASTERISK
               if (l->chan) ast_senddigit(l->chan,c,0);
#else
               if (l->chan) ast_senddigit(l->chan,c);
#endif
               l = l->next;
       }
       return;
}

/* node logging function */
static void donodelog(struct rpt *myrpt,char *str)
{
struct nodelog *nodep;
char  datestr[100];

   if (!myrpt->p.archivedir) return;
   nodep = (struct nodelog *)ast_malloc(sizeof(struct nodelog));
   if (nodep == NULL)
   {
      ast_log(LOG_ERROR,"Cannot get memory for node log");
      return;
   }
   time(&nodep->timestamp);
   strncpy(nodep->archivedir,myrpt->p.archivedir,
      sizeof(nodep->archivedir) - 1);
   strftime(datestr,sizeof(datestr) - 1,"%Y%m%d%H%M%S",
      localtime(&nodep->timestamp));
   snprintf(nodep->str,sizeof(nodep->str) - 1,"%s %s,%s\n",
      myrpt->name,datestr,str);
   ast_mutex_lock(&nodeloglock);
   insque((struct qelem *) nodep, (struct qelem *) nodelog.prev);
   ast_mutex_unlock(&nodeloglock);
}

/* must be called locked */
static void do_dtmf_local(struct rpt *myrpt, char c)
{
int   i;
char  digit;
static const char* dtmf_tones[] = {
   "!941+1336/200,!0/200", /* 0 */
   "!697+1209/200,!0/200", /* 1 */
   "!697+1336/200,!0/200", /* 2 */
   "!697+1477/200,!0/200", /* 3 */
   "!770+1209/200,!0/200", /* 4 */
   "!770+1336/200,!0/200", /* 5 */
   "!770+1477/200,!0/200", /* 6 */
   "!852+1209/200,!0/200", /* 7 */
   "!852+1336/200,!0/200", /* 8 */
   "!852+1477/200,!0/200", /* 9 */
   "!697+1633/200,!0/200", /* A */
   "!770+1633/200,!0/200", /* B */
   "!852+1633/200,!0/200", /* C */
   "!941+1633/200,!0/200", /* D */
   "!941+1209/200,!0/200", /* * */
   "!941+1477/200,!0/200" };  /* # */


   if (c)
   {
      snprintf(myrpt->dtmf_local_str + strlen(myrpt->dtmf_local_str),sizeof(myrpt->dtmf_local_str) - 1,"%c",c);
      if (!myrpt->dtmf_local_timer) 
          myrpt->dtmf_local_timer = DTMF_LOCAL_STARTTIME;
   }
   /* if at timeout */
   if (myrpt->dtmf_local_timer == 1)
   {
      if(debug > 6)
         ast_log(LOG_NOTICE,"time out dtmf_local_timer=%i\n",myrpt->dtmf_local_timer);

      /* if anything in the string */
      if (myrpt->dtmf_local_str[0])
      {
         digit = myrpt->dtmf_local_str[0];
         myrpt->dtmf_local_str[0] = 0;
         for(i = 1; myrpt->dtmf_local_str[i]; i++)
         {
            myrpt->dtmf_local_str[i - 1] =
               myrpt->dtmf_local_str[i];
         }
         myrpt->dtmf_local_str[i - 1] = 0;
         myrpt->dtmf_local_timer = DTMF_LOCAL_TIME;
         rpt_mutex_unlock(&myrpt->lock);
         if (digit >= '0' && digit <='9')
            ast_playtones_start(myrpt->txchannel, 0, dtmf_tones[digit-'0'], 0);
         else if (digit >= 'A' && digit <= 'D')
            ast_playtones_start(myrpt->txchannel, 0, dtmf_tones[digit-'A'+10], 0);
         else if (digit == '*')
            ast_playtones_start(myrpt->txchannel, 0, dtmf_tones[14], 0);
         else if (digit == '#')
            ast_playtones_start(myrpt->txchannel, 0, dtmf_tones[15], 0);
         else {
            /* not handled */
            ast_log(LOG_DEBUG, "Unable to generate DTMF tone '%c' for '%s'\n", digit, myrpt->txchannel->name);
         }
         rpt_mutex_lock(&myrpt->lock);
      }
      else
      {
         myrpt->dtmf_local_timer = 0;
      }
   }
}

static int setdtr(int fd, int enable)
{
struct termios mode;

   if (fd < 0) return -1;
   if (tcgetattr(fd, &mode)) {
      ast_log(LOG_WARNING, "Unable to get serial parameters for dtr: %s\n", strerror(errno));
      return -1;
   }
   if (enable)
   {
      cfsetspeed(&mode, B9600);
   }
   else
   {
      cfsetspeed(&mode, B0);
      usleep(100000);
   }
   if (tcsetattr(fd, TCSADRAIN, &mode)) {
      ast_log(LOG_WARNING, "Unable to set serial parameters for dtr: %s\n", strerror(errno));
      return -1;
   }
   if (enable) usleep(100000);
   return 0;
}

static int openserial(struct rpt *myrpt,char *fname)
{
   struct termios mode;
   int fd;

   fd = open(fname,O_RDWR);
   if (fd == -1)
   {
      ast_log(LOG_WARNING,"Cannot open serial port %s\n",fname);
      return -1;
   }
   memset(&mode, 0, sizeof(mode));
   if (tcgetattr(fd, &mode)) {
      ast_log(LOG_WARNING, "Unable to get serial parameters on %s: %s\n", fname, strerror(errno));
      return -1;
   }
#ifndef  SOLARIS
   cfmakeraw(&mode);
#else
        mode.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
                        |INLCR|IGNCR|ICRNL|IXON);
        mode.c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
        mode.c_cflag &= ~(CSIZE|PARENB|CRTSCTS);
        mode.c_cflag |= CS8;
   mode.c_cc[VTIME] = 3;
   mode.c_cc[VMIN] = 1; 
#endif

   cfsetispeed(&mode, B9600);
   cfsetospeed(&mode, B9600);
   if (tcsetattr(fd, TCSANOW, &mode)) 
      ast_log(LOG_WARNING, "Unable to set serial parameters on %s: %s\n", fname, strerror(errno));
   if(!strcmp(myrpt->remoterig, remote_rig_kenwood)) setdtr(fd,0); 
   usleep(100000);
   if (debug)ast_log(LOG_NOTICE,"Opened serial port %s\n",fname);
   return(fd); 
}

static void mdc1200_notify(struct rpt *myrpt,char *fromnode, unsigned int unit)
{
   if (!fromnode)
   {
      ast_verbose("Got MDC-1200 ID %04X from local system (%s)\n",
         unit,myrpt->name);
   }
   else
   {
      ast_verbose("Got MDC-1200 ID %04X from node %s (%s)\n",
         unit,fromnode,myrpt->name);
   }
}

#ifdef   _MDC_DECODE_H_

static void mdc1200_send(struct rpt *myrpt, unsigned int unit)
{
struct rpt_link *l;
struct   ast_frame wf;
char  str[200];


   sprintf(str,"I %s %04X",myrpt->name,unit);

   wf.frametype = AST_FRAME_TEXT;
   wf.subclass = 0;
   wf.offset = 0;
   wf.mallocd = 0;
   wf.datalen = strlen(str) + 1;
   wf.samples = 0;


   l = myrpt->links.next;
   /* otherwise, send it to all of em */
   while(l != &myrpt->links)
   {
      if (l->name[0] == '0') 
      {
         l = l->next;
         continue;
      }
      wf.data = str;
      if (l->chan) ast_write(l->chan,&wf); 
      l = l->next;
   }
   return;
}

#endif

static char func_xlat(struct rpt *myrpt,char c,struct rpt_xlat *xlat)
{
time_t   now;
int   gotone;

   time(&now);
   gotone = 0;
   /* if too much time, reset the skate machine */
   if ((now - xlat->lastone) > MAXXLATTIME)
   {
      xlat->funcindex = xlat->endindex = 0;
   }
   if (xlat->funccharseq[0] && (c == xlat->funccharseq[xlat->funcindex++]))
   {
      time(&xlat->lastone);
      gotone = 1;
      if (!xlat->funccharseq[xlat->funcindex])
      {
         xlat->funcindex = xlat->endindex = 0;
         return(myrpt->p.funcchar);
      }
   } else xlat->funcindex = 0;
   if (xlat->endcharseq[0] && (c == xlat->endcharseq[xlat->endindex++]))
   {
      time(&xlat->lastone);
      gotone = 1;
      if (!xlat->endcharseq[xlat->endindex])
      {
         xlat->funcindex = xlat->endindex = 0;
         return(myrpt->p.endchar);
      }
   } else xlat->endindex = 0;
   /* if in middle of decode seq, send nothing back */
   if (gotone) return(0);
   /* if no pass chars specified, return em all */
   if (!xlat->passchars[0]) return(c);
   /* if a "pass char", pass it */
   if (strchr(xlat->passchars,c)) return(c);
   return(0);
}

/*
 * Return a pointer to the first non-whitespace character
 */

static char *eatwhite(char *s)
{
   while((*s == ' ') || (*s == 0x09)){ /* get rid of any leading white space */
      if(!*s)
         break;
      s++;
   }
   return s;
}

/*
* Break up a delimited string into a table of substrings
*
* str - delimited string ( will be modified )
* strp- list of pointers to substrings (this is built by this function), NULL will be placed at end of list
* limit- maximum number of substrings to process
*/
   


static int finddelim(char *str, char *strp[], int limit)
{
int     i,l,inquo;

        inquo = 0;
        i = 0;
        strp[i++] = str;
        if (!*str)
           {
                strp[0] = 0;
                return(0);
           }
        for(l = 0; *str && (l < limit) ; str++)
           {
                if (*str == QUOTECHR)
                   {
                        if (inquo)
                           {
                                *str = 0;
                                inquo = 0;
                           }
                        else
                           {
                                strp[i - 1] = str + 1;
                                inquo = 1;
                           }
      }
                if ((*str == DELIMCHR) && (!inquo))
                {
                        *str = 0;
         l++;
                        strp[i++] = str + 1;
                }
           }
        strp[i] = 0;
        return(i);

}
/*
   send asterisk frame text message on the current tx channel
*/
static int send_usb_txt(struct rpt *myrpt, char *txt) 
{
   struct ast_frame wf;
 
   if (debug)ast_log(LOG_NOTICE, "send_usb_txt %s\n",txt);
   wf.frametype = AST_FRAME_TEXT;
   wf.subclass = 0;
   wf.offset = 0;
   wf.mallocd = 0;
   wf.datalen = strlen(txt) + 1;
   wf.data.ptr = txt;
   wf.samples = 0;
   ast_write(myrpt->txchannel,&wf); 
   return 0;
}
/* must be called locked */
static void __mklinklist(struct rpt *myrpt, struct rpt_link *mylink, char *buf)
{
struct rpt_link *l;
char mode;
int   i,spos;

   buf[0] = 0; /* clear output buffer */
   if (myrpt->remote) return;
   /* go thru all links */
   for(l = myrpt->links.next; l != &myrpt->links; l = l->next)
   {
      /* if is not a real link, ignore it */
      if (l->name[0] == '0') continue;
      /* dont count our stuff */
      if (l == mylink) continue;
      if (mylink && (!strcmp(l->name,mylink->name))) continue;
      /* figure out mode to report */
      mode = 'T'; /* use Tranceive by default */
      if (!l->mode) mode = 'R'; /* indicate RX for our mode */
      if (!l->thisconnected)  mode = 'C'; /* indicate connecting */
      spos = strlen(buf); /* current buf size (b4 we add our stuff) */
      if (spos)
      {
         strcat(buf,",");
         spos++;
      }
      /* add nodes into buffer */
      if (l->linklist[0])
      {
         snprintf(buf + spos,MAXLINKLIST - spos,
            "%c%s,%s",mode,l->name,l->linklist);
      }
      else /* if no nodes, add this node into buffer */
      {
         snprintf(buf + spos,MAXLINKLIST - spos,
            "%c%s",mode,l->name);
      }
      /* if we are in tranceive mode, let all modes stand */
      if (mode == 'T') continue;
      /* downgrade everyone on this node if appropriate */
      for(i = spos; buf[i]; i++)
      {
         if (buf[i] == 'T') buf[i] = mode;
         if ((buf[i] == 'R') && (mode == 'C')) buf[i] = mode;
      }
   }
   return;
}

/* must be called locked */
static void __kickshort(struct rpt *myrpt)
{
struct rpt_link *l;

   for(l = myrpt->links.next; l != &myrpt->links; l = l->next)
   {
      /* if is not a real link, ignore it */
      if (l->name[0] == '0') continue;
      l->linklisttimer = LINKLISTSHORTTIME;
   }
   myrpt->linkposttimer = LINKPOSTSHORTTIME;
   return;
}

static void statpost(struct rpt *myrpt,char *pairs)
{
char *str,*astr;
char *astrs[100];
int   n,pid;
time_t   now;
unsigned int seq;

   if (!myrpt->p.statpost_url) return;
   str = ast_malloc(strlen(pairs) + strlen(myrpt->p.statpost_url) + 200);
   astr = ast_strdup(myrpt->p.statpost_program);
   if ((!str) || (!astr)) return;
   n = finddelim(astr,astrs,100);
   if (n < 1) return;
   ast_mutex_lock(&myrpt->statpost_lock);
   seq = ++myrpt->statpost_seqno;
   ast_mutex_unlock(&myrpt->statpost_lock);
   astrs[n++] = str;
   astrs[n] = NULL;
   time(&now);
   sprintf(str,"%s?node=%s&time=%u&seqno=%u",myrpt->p.statpost_url,
      myrpt->name,(unsigned int) now,seq);
   if (pairs) sprintf(str + strlen(str),"&%s",pairs);
   if (!(pid = ast_safe_fork(0)))
   {
      execv(astrs[0],astrs);
      ast_log(LOG_ERROR, "exec of %s failed.\n", astrs[0]);
      perror("asterisk");
      exit(0);
   }
   ast_free(astr);
   ast_free(str);
   return;
}

static char *node_lookup(struct rpt *myrpt,char *digitbuf)
{

char *val;
int longestnode,j;
struct stat mystat;
static time_t last = 0;
static struct ast_config *ourcfg = NULL;
struct ast_variable *vp;

   /* try to look it up locally first */
   val = (char *) ast_variable_retrieve(myrpt->cfg, myrpt->p.nodes, digitbuf);
   if (val) return(val);
   ast_mutex_lock(&nodelookuplock);
   /* if file does not exist */
   if (stat(myrpt->p.extnodefile,&mystat) == -1)
   {
      if (ourcfg) ast_config_destroy(ourcfg);
      ourcfg = NULL;
      ast_mutex_unlock(&nodelookuplock);
      return(NULL);
   }
   /* if we need to reload */
   if (mystat.st_mtime > last)
   {
      if (ourcfg) ast_config_destroy(ourcfg);
#ifdef   NEW_ASTERISK
      ourcfg = ast_config_load(myrpt->p.extnodefile,config_flags);
#else
      ourcfg = ast_config_load(myrpt->p.extnodefile);
#endif
      /* if file not there, just bail */
      if (!ourcfg || ourcfg == CONFIG_STATUS_FILEINVALID)
      {
         ast_mutex_unlock(&nodelookuplock);
         return(NULL);
      }
      /* reset "last" time */
      last = mystat.st_mtime;

      /* determine longest node length again */    
      longestnode = 0;
      vp = ast_variable_browse(myrpt->cfg, myrpt->p.nodes);
      while(vp){
         j = strlen(vp->name);
         if (j > longestnode)
            longestnode = j;
         vp = vp->next;
      }

      vp = ast_variable_browse(ourcfg, myrpt->p.extnodes);
      while(vp){
         j = strlen(vp->name);
         if (j > longestnode)
            longestnode = j;
         vp = vp->next;
      }

      myrpt->longestnode = longestnode;
   }
   val = NULL;
   if (ourcfg)
      val = (char *) ast_variable_retrieve(ourcfg, myrpt->p.extnodes, digitbuf);
   ast_mutex_unlock(&nodelookuplock);
   return(val);
}

/*
* Match a keyword in a list, and return index of string plus 1 if there was a match,* else return 0.
* If param is passed in non-null, then it will be set to the first character past the match
*/

static int matchkeyword(char *string, char **param, char *keywords[])
{
int   i,ls;
   for( i = 0 ; keywords[i] ; i++){
      ls = strlen(keywords[i]);
      if(!ls){
         *param = NULL;
         return 0;
      }
      if(!strncmp(string, keywords[i], ls)){
         if(param)
            *param = string + ls;
         return i + 1; 
      }
   }
   *param = NULL;
   return 0;
}

/*
* Skip characters in string which are in charlist, and return a pointer to the
* first non-matching character
*/

static char *skipchars(char *string, char *charlist)
{
int i;   
   while(*string){
      for(i = 0; charlist[i] ; i++){
         if(*string == charlist[i]){
            string++;
            break;
         }
      }
      if(!charlist[i])
         return string;
   }
   return string;
}  
               


static int myatoi(char *str)
{
int   ret;

   if (str == NULL) return -1;
   /* leave this %i alone, non-base-10 input is useful here */
   if (sscanf(str, "%30i", &ret) != 1) {
      return -1;
   }

   return ret;
}

static int mycompar(const void *a, const void *b)
{
char  **x = (char **) a;
char  **y = (char **) b;
int   xoff,yoff;

   if ((**x < '0') || (**x > '9')) xoff = 1; else xoff = 0;
   if ((**y < '0') || (**y > '9')) yoff = 1; else yoff = 0;
   return(strcmp((*x) + xoff,(*y) + yoff));
}

static int topcompar(const void *a, const void *b)
{
struct rpt_topkey *x = (struct rpt_topkey *) a;
struct rpt_topkey *y = (struct rpt_topkey *) b;

   return(x->timesince - y->timesince);
}

#ifdef   __RPT_NOTCH

/* rpt filter routine */
static void rpt_filter(struct rpt *myrpt, volatile short *buf, int len)
{
int   i,j;
struct   rptfilter *f;

   for(i = 0; i < len; i++)
   {
      for(j = 0; j < MAXFILTERS; j++)
      {
         f = &myrpt->filters[j];
         if (!*f->desc) continue;
         f->x0 = f->x1; f->x1 = f->x2;
              f->x2 = ((float)buf[i]) / f->gain;
              f->y0 = f->y1; f->y1 = f->y2;
              f->y2 =   (f->x0 + f->x2) +   f->const0 * f->x1
                           + (f->const1 * f->y0) + (f->const2 * f->y1);
         buf[i] = (short)f->y2;
      }
   }
}

#endif


/*
 Get the time for the machine's time zone
 Note: Asterisk requires a copy of localtime
 in the /etc directory for this to work properly.
 If /etc/localtime is not present, you will get
 GMT time! This is especially important on systems
 running embedded linux distributions as they don't usually
 have support for locales. 

 If OLD_ASTERISK is defined, then the older localtime_r
 function will be used. The /etc/localtime file is not
 required in this case. This provides backward compatibility
 with Asterisk 1.2 systems.

*/

#ifdef   NEW_ASTERISK
static void rpt_localtime( time_t * t, struct ast_tm *lt)
{
   struct timeval when;

   when.tv_sec = *t;
   when.tv_usec = 0;
   ast_localtime(&when, lt, NULL);
}

#else
static void rpt_localtime( time_t * t, struct tm *lt)
{
#ifdef OLD_ASTERISK
   localtime_r(t, lt);
#else
   ast_localtime(t, lt, NULL);
#endif
}
#endif


/* Retrieve an int from a config file */
                                                                                
static int retrieve_astcfgint(struct rpt *myrpt,char *category, char *name, int min, int max, int defl)
{
        char *var;
        int ret;
   char include_zero = 0;

   if(min < 0){ /* If min is negative, this means include 0 as a valid entry */
      min = -min;
      include_zero = 1;
   }           
                                                                     
        var = (char *) ast_variable_retrieve(myrpt->cfg, category, name);
        if(var){
                ret = myatoi(var);
      if(include_zero && !ret)
         return 0;
                if(ret < min)
                        ret = min;
                if(ret > max)
                        ret = max;
        }
        else
                ret = defl;
        return ret;
}


static void load_rpt_vars(int n,int init)
{
char *this,*val;
int   i,j,longestnode;
struct ast_variable *vp;
struct ast_config *cfg;
char *strs[100];
char s1[256];
static char *cs_keywords[] = {"rptena","rptdis","apena","apdis","lnkena","lnkdis","totena","totdis","skena","skdis",
            "ufena","ufdis","atena","atdis",NULL};

   if (option_verbose > 2)
      ast_verbose(VERBOSE_PREFIX_3 "%s config for repeater %s\n",
         (init) ? "Loading initial" : "Re-Loading",rpt_vars[n].name);
   ast_mutex_lock(&rpt_vars[n].lock);
   if (rpt_vars[n].cfg) ast_config_destroy(rpt_vars[n].cfg);
#ifdef   NEW_ASTERISK
   cfg = ast_config_load("rpt.conf",config_flags);
#else
   cfg = ast_config_load("rpt.conf");
#endif
   if (!cfg || cfg == CONFIG_STATUS_FILEINVALID) {
      ast_mutex_unlock(&rpt_vars[n].lock);
      ast_log(LOG_NOTICE, "Unable to open radio repeater configuration rpt.conf.  Radio Repeater disabled.\n");
      pthread_exit(NULL);
   }
   rpt_vars[n].cfg = cfg; 
   this = rpt_vars[n].name;
   memset(&rpt_vars[n].p,0,sizeof(rpt_vars[n].p));
   if (init)
   {
      char *cp;
      int savearea = (char *)&rpt_vars[n].p - (char *)&rpt_vars[n];

      cp = (char *) &rpt_vars[n].p;
      memset(cp + sizeof(rpt_vars[n].p),0,
         sizeof(rpt_vars[n]) - (sizeof(rpt_vars[n].p) + savearea));
      rpt_vars[n].tele.next = &rpt_vars[n].tele;
      rpt_vars[n].tele.prev = &rpt_vars[n].tele;
      rpt_vars[n].rpt_thread = AST_PTHREADT_NULL;
      rpt_vars[n].tailmessagen = 0;
   }
#ifdef   __RPT_NOTCH
   /* zot out filters stuff */
   memset(&rpt_vars[n].filters,0,sizeof(rpt_vars[n].filters));
#endif
   val = (char *) ast_variable_retrieve(cfg,this,"context");
   if (val) rpt_vars[n].p.ourcontext = val;
   else rpt_vars[n].p.ourcontext = this;
   val = (char *) ast_variable_retrieve(cfg,this,"callerid");
   if (val) rpt_vars[n].p.ourcallerid = val;
   val = (char *) ast_variable_retrieve(cfg,this,"accountcode");
   if (val) rpt_vars[n].p.acctcode = val;
   val = (char *) ast_variable_retrieve(cfg,this,"idrecording");
   if (val) rpt_vars[n].p.ident = val;
   val = (char *) ast_variable_retrieve(cfg,this,"hangtime");
   if (val) rpt_vars[n].p.hangtime = atoi(val);
      else rpt_vars[n].p.hangtime = HANGTIME;
   val = (char *) ast_variable_retrieve(cfg,this,"althangtime");
   if (val) rpt_vars[n].p.althangtime = atoi(val);
      else rpt_vars[n].p.althangtime = HANGTIME;
   val = (char *) ast_variable_retrieve(cfg,this,"totime");
   if (val) rpt_vars[n].p.totime = atoi(val);
      else rpt_vars[n].p.totime = TOTIME;
   val = (char *) ast_variable_retrieve(cfg,this,"voxtimeout");
   if (val) rpt_vars[n].p.voxtimeout_ms = atoi(val);
      else rpt_vars[n].p.voxtimeout_ms = VOX_TIMEOUT_MS;
   val = (char *) ast_variable_retrieve(cfg,this,"voxrecover");
   if (val) rpt_vars[n].p.voxrecover_ms = atoi(val);
      else rpt_vars[n].p.voxrecover_ms = VOX_RECOVER_MS;
   val = (char *) ast_variable_retrieve(cfg,this,"simplexpatchdelay");
   if (val) rpt_vars[n].p.simplexpatchdelay = atoi(val);
      else rpt_vars[n].p.simplexpatchdelay = SIMPLEX_PATCH_DELAY;
   val = (char *) ast_variable_retrieve(cfg,this,"simplexphonedelay");
   if (val) rpt_vars[n].p.simplexphonedelay = atoi(val);
      else rpt_vars[n].p.simplexphonedelay = SIMPLEX_PHONE_DELAY;
   val = (char *) ast_variable_retrieve(cfg,this,"statpost_program");
   if (val) rpt_vars[n].p.statpost_program = val;
      else rpt_vars[n].p.statpost_program = STATPOST_PROGRAM;
   rpt_vars[n].p.statpost_url = 
      (char *) ast_variable_retrieve(cfg,this,"statpost_url");
   rpt_vars[n].p.tailmessagetime = retrieve_astcfgint(&rpt_vars[n],this, "tailmessagetime", 0, 2400000, 0);    
   rpt_vars[n].p.tailsquashedtime = retrieve_astcfgint(&rpt_vars[n],this, "tailsquashedtime", 0, 2400000, 0);     
   rpt_vars[n].p.duplex = retrieve_astcfgint(&rpt_vars[n],this,"duplex",0,4,2);
   rpt_vars[n].p.idtime = retrieve_astcfgint(&rpt_vars[n],this, "idtime", -60000, 2400000, IDTIME);   /* Enforce a min max including zero */
   rpt_vars[n].p.politeid = retrieve_astcfgint(&rpt_vars[n],this, "politeid", 30000, 300000, POLITEID); /* Enforce a min max */
   val = (char *) ast_variable_retrieve(cfg,this,"tonezone");
   if (val) rpt_vars[n].p.tonezone = val;
   rpt_vars[n].p.tailmessages[0] = 0;
   rpt_vars[n].p.tailmessagemax = 0;
   val = (char *) ast_variable_retrieve(cfg,this,"tailmessagelist");
   if (val) rpt_vars[n].p.tailmessagemax = finddelim(val, rpt_vars[n].p.tailmessages, 500);
   val = (char *) ast_variable_retrieve(cfg,this,"memory");
   if (!val) val = MEMORY;
   rpt_vars[n].p.memory = val;
   val = (char *) ast_variable_retrieve(cfg,this,"macro");
   if (!val) val = MACRO;
   rpt_vars[n].p.macro = val;
   val = (char *) ast_variable_retrieve(cfg,this,"tonemacro");
   if (!val) val = TONEMACRO;
   rpt_vars[n].p.tonemacro = val;
   val = (char *) ast_variable_retrieve(cfg,this,"startup_macro");
   if (val) rpt_vars[n].p.startupmacro = val;
   val = (char *) ast_variable_retrieve(cfg,this,"iobase");
   /* do not use atoi() here, we need to be able to have
      the input specified in hex or decimal so we use
      sscanf with a %i */
   if ((!val) || (sscanf(val,"%30i",&rpt_vars[n].p.iobase) != 1))
      rpt_vars[n].p.iobase = DEFAULT_IOBASE;
   val = (char *) ast_variable_retrieve(cfg,this,"ioport");
   rpt_vars[n].p.ioport = val;
   val = (char *) ast_variable_retrieve(cfg,this,"functions");
   if (!val)
      {
         val = FUNCTIONS;
         rpt_vars[n].p.simple = 1;
      } 
   rpt_vars[n].p.functions = val;
   val =  (char *) ast_variable_retrieve(cfg,this,"link_functions");
   if (val) rpt_vars[n].p.link_functions = val;
   else 
      rpt_vars[n].p.link_functions = rpt_vars[n].p.functions;
   val = (char *) ast_variable_retrieve(cfg,this,"phone_functions");
   if (val) rpt_vars[n].p.phone_functions = val;
   val = (char *) ast_variable_retrieve(cfg,this,"dphone_functions");
   if (val) rpt_vars[n].p.dphone_functions = val;
   val = (char *) ast_variable_retrieve(cfg,this,"alt_functions");
   if (val) rpt_vars[n].p.alt_functions = val;
   val = (char *) ast_variable_retrieve(cfg,this,"funcchar");
   if (!val) rpt_vars[n].p.funcchar = FUNCCHAR; else 
      rpt_vars[n].p.funcchar = *val;      
   val = (char *) ast_variable_retrieve(cfg,this,"endchar");
   if (!val) rpt_vars[n].p.endchar = ENDCHAR; else 
      rpt_vars[n].p.endchar = *val;    
   val = (char *) ast_variable_retrieve(cfg,this,"nobusyout");
   if (val) rpt_vars[n].p.nobusyout = ast_true(val);
   val = (char *) ast_variable_retrieve(cfg,this,"notelemtx");
   if (val) rpt_vars[n].p.notelemtx = ast_true(val);
   val = (char *) ast_variable_retrieve(cfg,this,"propagate_dtmf");
   if (val) rpt_vars[n].p.propagate_dtmf = ast_true(val);
   val = (char *) ast_variable_retrieve(cfg,this,"propagate_phonedtmf");
   if (val) rpt_vars[n].p.propagate_phonedtmf = ast_true(val);
   val = (char *) ast_variable_retrieve(cfg,this,"linktolink");
   if (val) rpt_vars[n].p.linktolink = ast_true(val);
   val = (char *) ast_variable_retrieve(cfg,this,"nodes");
   if (!val) val = NODES;
   rpt_vars[n].p.nodes = val;
   val = (char *) ast_variable_retrieve(cfg,this,"extnodes");
   if (!val) val = EXTNODES;
   rpt_vars[n].p.extnodes = val;
   val = (char *) ast_variable_retrieve(cfg,this,"extnodefile");
   if (!val) val = EXTNODEFILE;
   rpt_vars[n].p.extnodefile = val;
   val = (char *) ast_variable_retrieve(cfg,this,"archivedir");
   if (val) rpt_vars[n].p.archivedir = val;
   val = (char *) ast_variable_retrieve(cfg,this,"authlevel");
   if (val) rpt_vars[n].p.authlevel = atoi(val); 
   else rpt_vars[n].p.authlevel = 0;
   val = (char *) ast_variable_retrieve(cfg,this,"parrot");
   if (val) rpt_vars[n].p.parrotmode = ast_true(val) * 2;
   else rpt_vars[n].p.parrotmode = 0;
   val = (char *) ast_variable_retrieve(cfg,this,"parrottime");
   if (val) rpt_vars[n].p.parrottime = atoi(val); 
   else rpt_vars[n].p.parrottime = PARROTTIME;
   val = (char *) ast_variable_retrieve(cfg,this,"rptnode");
   rpt_vars[n].p.rptnode = val;
   val = (char *) ast_variable_retrieve(cfg,this,"mars");
   if (val) rpt_vars[n].p.remote_mars = atoi(val); 
   else rpt_vars[n].p.remote_mars = 0;
   val = (char *) ast_variable_retrieve(cfg,this,"monminblocks");
   if (val) rpt_vars[n].p.monminblocks = atol(val); 
   else rpt_vars[n].p.monminblocks = DEFAULT_MONITOR_MIN_DISK_BLOCKS;
   val = (char *) ast_variable_retrieve(cfg,this,"remote_inact_timeout");
   if (val) rpt_vars[n].p.remoteinacttimeout = atoi(val); 
   else rpt_vars[n].p.remoteinacttimeout = DEFAULT_REMOTE_INACT_TIMEOUT;
   val = (char *) ast_variable_retrieve(cfg,this,"civaddr");
   if (val) rpt_vars[n].p.civaddr = atoi(val); 
   else rpt_vars[n].p.civaddr = DEFAULT_CIV_ADDR;
   val = (char *) ast_variable_retrieve(cfg,this,"remote_timeout");
   if (val) rpt_vars[n].p.remotetimeout = atoi(val); 
   else rpt_vars[n].p.remotetimeout = DEFAULT_REMOTE_TIMEOUT;
   val = (char *) ast_variable_retrieve(cfg,this,"remote_timeout_warning");
   if (val) rpt_vars[n].p.remotetimeoutwarning = atoi(val); 
   else rpt_vars[n].p.remotetimeoutwarning = DEFAULT_REMOTE_TIMEOUT_WARNING;
   val = (char *) ast_variable_retrieve(cfg,this,"remote_timeout_warning_freq");
   if (val) rpt_vars[n].p.remotetimeoutwarningfreq = atoi(val); 
   else rpt_vars[n].p.remotetimeoutwarningfreq = DEFAULT_REMOTE_TIMEOUT_WARNING_FREQ;
#ifdef   __RPT_NOTCH
   val = (char *) ast_variable_retrieve(cfg,this,"rxnotch");
   if (val) {
      i = finddelim(val,strs,MAXFILTERS * 2);
      i &= ~1; /* force an even number, rounded down */
      if (i >= 2) for(j = 0; j < i; j += 2)
      {
         rpt_mknotch(atof(strs[j]),atof(strs[j + 1]),
           &rpt_vars[n].filters[j >> 1].gain,
             &rpt_vars[n].filters[j >> 1].const0,
            &rpt_vars[n].filters[j >> 1].const1,
                &rpt_vars[n].filters[j >> 1].const2);
         sprintf(rpt_vars[n].filters[j >> 1].desc,"%s Hz, BW = %s",
            strs[j],strs[j + 1]);
      }

   }
#endif
   val = (char *) ast_variable_retrieve(cfg,this,"inxlat");
   if (val) {
      memset(&rpt_vars[n].p.inxlat,0,sizeof(struct rpt_xlat));
      i = finddelim(val,strs,3);
      if (i) strncpy(rpt_vars[n].p.inxlat.funccharseq,strs[0],MAXXLAT - 1);
      if (i > 1) strncpy(rpt_vars[n].p.inxlat.endcharseq,strs[1],MAXXLAT - 1);
      if (i > 2) strncpy(rpt_vars[n].p.inxlat.passchars,strs[2],MAXXLAT - 1);
   }
   val = (char *) ast_variable_retrieve(cfg,this,"outxlat");
   if (val) {
      memset(&rpt_vars[n].p.outxlat,0,sizeof(struct rpt_xlat));
      i = finddelim(val,strs,3);
      if (i) strncpy(rpt_vars[n].p.outxlat.funccharseq,strs[0],MAXXLAT - 1);
      if (i > 1) strncpy(rpt_vars[n].p.outxlat.endcharseq,strs[1],MAXXLAT - 1);
      if (i > 2) strncpy(rpt_vars[n].p.outxlat.passchars,strs[2],MAXXLAT - 1);
   }
   /* retreive the stanza name for the control states if there is one */
   val = (char *) ast_variable_retrieve(cfg,this,"controlstates");
   rpt_vars[n].p.csstanzaname = val;
      
   /* retreive the stanza name for the scheduler if there is one */
   val = (char *) ast_variable_retrieve(cfg,this,"scheduler");
   rpt_vars[n].p.skedstanzaname = val;

   /* retreive the stanza name for the txlimits */
   val = (char *) ast_variable_retrieve(cfg,this,"txlimits");
   rpt_vars[n].p.txlimitsstanzaname = val;

   longestnode = 0;

   vp = ast_variable_browse(cfg, rpt_vars[n].p.nodes);
      
   while(vp){
      j = strlen(vp->name);
      if (j > longestnode)
         longestnode = j;
      vp = vp->next;
   }

   rpt_vars[n].longestnode = longestnode;
      
   /*
   * For this repeater, Determine the length of the longest function 
   */
   rpt_vars[n].longestfunc = 0;
   vp = ast_variable_browse(cfg, rpt_vars[n].p.functions);
   while(vp){
      j = strlen(vp->name);
      if (j > rpt_vars[n].longestfunc)
         rpt_vars[n].longestfunc = j;
      vp = vp->next;
   }
   /*
   * For this repeater, Determine the length of the longest function 
   */
   rpt_vars[n].link_longestfunc = 0;
   vp = ast_variable_browse(cfg, rpt_vars[n].p.link_functions);
   while(vp){
      j = strlen(vp->name);
      if (j > rpt_vars[n].link_longestfunc)
         rpt_vars[n].link_longestfunc = j;
      vp = vp->next;
   }
   rpt_vars[n].phone_longestfunc = 0;
   if (rpt_vars[n].p.phone_functions)
   {
      vp = ast_variable_browse(cfg, rpt_vars[n].p.phone_functions);
      while(vp){
         j = strlen(vp->name);
         if (j > rpt_vars[n].phone_longestfunc)
            rpt_vars[n].phone_longestfunc = j;
         vp = vp->next;
      }
   }
   rpt_vars[n].dphone_longestfunc = 0;
   if (rpt_vars[n].p.dphone_functions)
   {
      vp = ast_variable_browse(cfg, rpt_vars[n].p.dphone_functions);
      while(vp){
         j = strlen(vp->name);
         if (j > rpt_vars[n].dphone_longestfunc)
            rpt_vars[n].dphone_longestfunc = j;
         vp = vp->next;
      }
   }
   rpt_vars[n].alt_longestfunc = 0;
   if (rpt_vars[n].p.alt_functions)
   {
      vp = ast_variable_browse(cfg, rpt_vars[n].p.alt_functions);
      while(vp){
         j = strlen(vp->name);
         if (j > rpt_vars[n].alt_longestfunc)
            rpt_vars[n].alt_longestfunc = j;
         vp = vp->next;
      }
   }
   rpt_vars[n].macro_longest = 1;
   vp = ast_variable_browse(cfg, rpt_vars[n].p.macro);
   while(vp){
      j = strlen(vp->name);
      if (j > rpt_vars[n].macro_longest)
         rpt_vars[n].macro_longest = j;
      vp = vp->next;
   }
   
   /* Browse for control states */
   if(rpt_vars[n].p.csstanzaname)
      vp = ast_variable_browse(cfg, rpt_vars[n].p.csstanzaname);
   else
      vp = NULL;
   for( i = 0 ; vp && (i < MAX_SYSSTATES) ; i++){ /* Iterate over the number of control state lines in the stanza */
      int k,nukw,statenum;
      statenum=atoi(vp->name);
      strncpy(s1, vp->value, 255);
      s1[255] = 0;
      nukw  = finddelim(s1,strs,32);
      
      for (k = 0 ; k < nukw ; k++){ /* for each user specified keyword */  
         for(j = 0 ; cs_keywords[j] != NULL ; j++){ /* try to match to one in our internal table */
            if(!strcmp(strs[k],cs_keywords[j])){
               switch(j){
                  case 0: /* rptena */
                     rpt_vars[n].p.s[statenum].txdisable = 0;
                     break;
                  case 1: /* rptdis */
                     rpt_vars[n].p.s[statenum].txdisable = 1;
                     break;
         
                  case 2: /* apena */
                     rpt_vars[n].p.s[statenum].autopatchdisable = 0;
                     break;

                  case 3: /* apdis */
                     rpt_vars[n].p.s[statenum].autopatchdisable = 1;
                     break;

                  case 4: /* lnkena */
                     rpt_vars[n].p.s[statenum].linkfundisable = 0;
                     break;
   
                  case 5: /* lnkdis */
                     rpt_vars[n].p.s[statenum].linkfundisable = 1;
                     break;

                  case 6: /* totena */
                     rpt_vars[n].p.s[statenum].totdisable = 0;
                     break;
               
                  case 7: /* totdis */
                     rpt_vars[n].p.s[statenum].totdisable = 1;
                     break;

                  case 8: /* skena */
                     rpt_vars[n].p.s[statenum].schedulerdisable = 0;
                     break;

                  case 9: /* skdis */
                     rpt_vars[n].p.s[statenum].schedulerdisable = 1;
                     break;

                  case 10: /* ufena */
                     rpt_vars[n].p.s[statenum].userfundisable = 0;
                     break;

                  case 11: /* ufdis */
                     rpt_vars[n].p.s[statenum].userfundisable = 1;
                     break;

                  case 12: /* atena */
                     rpt_vars[n].p.s[statenum].alternatetail = 1;
                     break;

                  case 13: /* atdis */
                     rpt_vars[n].p.s[statenum].alternatetail = 0;
                     break;
         
                  default:
                     ast_log(LOG_WARNING,
                        "Unhandled control state keyword %s", cs_keywords[i]);
                     break;
               }
            }
         }
      }
      vp = vp->next;
   }
   ast_mutex_unlock(&rpt_vars[n].lock);
}

/*
* Enable or disable debug output at a given level at the console
*/
                                                                                                                                 
static int rpt_do_debug(int fd, int argc, char *argv[])
{
   int newlevel;

        if (argc != 4)
                return RESULT_SHOWUSAGE;
        newlevel = myatoi(argv[3]);
        if((newlevel < 0) || (newlevel > 7))
                return RESULT_SHOWUSAGE;
        if(newlevel)
                ast_cli(fd, "app_rpt Debugging enabled, previous level: %d, new level: %d\n", debug, newlevel);
        else
                ast_cli(fd, "app_rpt Debugging disabled\n");

        debug = newlevel;                                                                                                                          
        return RESULT_SUCCESS;
}

/*
* Dump rpt struct debugging onto console
*/
                                                                                                                                 
static int rpt_do_dump(int fd, int argc, char *argv[])
{
   int i;

        if (argc != 3)
                return RESULT_SHOWUSAGE;

   for(i = 0; i < nrpts; i++)
   {
      if (!strcmp(argv[2],rpt_vars[i].name))
      {
         rpt_vars[i].disgorgetime = time(NULL) + 10; /* Do it 10 seconds later */
              ast_cli(fd, "app_rpt struct dump requested for node %s\n",argv[2]);
              return RESULT_SUCCESS;
      }
   }
   return RESULT_FAILURE;
}

/*
* Dump statistics onto console
*/

static int rpt_do_stats(int fd, int argc, char *argv[])
{
   int i,j,numoflinks;
   int dailytxtime, dailykerchunks;
   time_t now;
   int totalkerchunks, dailykeyups, totalkeyups, timeouts;
   int totalexecdcommands, dailyexecdcommands, hours, minutes, seconds;
   int uptime;
   long long totaltxtime;
   struct   rpt_link *l;
   char *listoflinks[MAX_STAT_LINKS];  
   char *lastdtmfcommand,*parrot_ena;
   char *tot_state, *ider_state, *patch_state;
   char *reverse_patch_state, *sys_ena, *tot_ena, *link_ena, *patch_ena;
   char *sch_ena, *input_signal, *called_number, *user_funs, *tail_type;
   struct rpt *myrpt;

   static char *not_applicable = "N/A";

   if(argc != 3)
      return RESULT_SHOWUSAGE;

   tot_state = ider_state = 
   patch_state = reverse_patch_state = 
   input_signal = not_applicable;
   called_number = lastdtmfcommand = NULL;

   time(&now);
   for(i = 0; i < nrpts; i++)
   {
      if (!strcmp(argv[2],rpt_vars[i].name)){
         /* Make a copy of all stat variables while locked */
         myrpt = &rpt_vars[i];
         rpt_mutex_lock(&myrpt->lock); /* LOCK */
         uptime = (int)(now - starttime);
         dailytxtime = myrpt->dailytxtime;
         totaltxtime = myrpt->totaltxtime;
         dailykeyups = myrpt->dailykeyups;
         totalkeyups = myrpt->totalkeyups;
         dailykerchunks = myrpt->dailykerchunks;
         totalkerchunks = myrpt->totalkerchunks;
         dailyexecdcommands = myrpt->dailyexecdcommands;
         totalexecdcommands = myrpt->totalexecdcommands;
         timeouts = myrpt->timeouts;

         /* Traverse the list of connected nodes */
         reverse_patch_state = "DOWN";
         numoflinks = 0;
         l = myrpt->links.next;
         while(l && (l != &myrpt->links)){
            if(numoflinks >= MAX_STAT_LINKS){
               ast_log(LOG_NOTICE,
               "maximum number of links exceeds %d in rpt_do_stats()!",MAX_STAT_LINKS);
               break;
            }
            if (l->name[0] == '0'){ /* Skip '0' nodes */
               reverse_patch_state = "UP";
               l = l->next;
               continue;
            }
            listoflinks[numoflinks] = ast_strdup(l->name);
            if(listoflinks[numoflinks] == NULL){
               break;
            }
            else{
               numoflinks++;
            }
            l = l->next;
         }

         if(myrpt->keyed)
            input_signal = "YES";
         else
            input_signal = "NO";

         if(myrpt->p.parrotmode)
            parrot_ena = "ENABLED";
         else
            parrot_ena = "DISABLED";

         if(myrpt->p.s[myrpt->p.sysstate_cur].txdisable)
            sys_ena = "DISABLED";
         else
            sys_ena = "ENABLED";

         if(myrpt->p.s[myrpt->p.sysstate_cur].totdisable)
            tot_ena = "DISABLED";
         else
            tot_ena = "ENABLED";

         if(myrpt->p.s[myrpt->p.sysstate_cur].linkfundisable)
            link_ena = "DISABLED";
         else
            link_ena = "ENABLED";

         if(myrpt->p.s[myrpt->p.sysstate_cur].autopatchdisable)
            patch_ena = "DISABLED";
         else
            patch_ena = "ENABLED";

         if(myrpt->p.s[myrpt->p.sysstate_cur].schedulerdisable)
            sch_ena = "DISABLED";
         else
            sch_ena = "ENABLED";

         if(myrpt->p.s[myrpt->p.sysstate_cur].userfundisable)
            user_funs = "DISABLED";
         else
            user_funs = "ENABLED";

         if(myrpt->p.s[myrpt->p.sysstate_cur].alternatetail)
            tail_type = "ALTERNATE";
         else
            tail_type = "STANDARD";

         if(!myrpt->totimer)
            tot_state = "TIMED OUT!";
         else if(myrpt->totimer != myrpt->p.totime)
            tot_state = "ARMED";
         else
            tot_state = "RESET";

         if(myrpt->tailid)
            ider_state = "QUEUED IN TAIL";
         else if(myrpt->mustid)
            ider_state = "QUEUED FOR CLEANUP";
         else
            ider_state = "CLEAN";

         switch(myrpt->callmode){
            case 1:
               patch_state = "DIALING";
               break;
            case 2:
               patch_state = "CONNECTING";
               break;
            case 3:
               patch_state = "UP";
               break;

            case 4:
               patch_state = "CALL FAILED";
               break;

            default:
               patch_state = "DOWN";
         }

         if(strlen(myrpt->exten)){
            called_number = ast_strdup(myrpt->exten);
         }

         if(strlen(myrpt->lastdtmfcommand)){
            lastdtmfcommand = ast_strdup(myrpt->lastdtmfcommand);
         }
         rpt_mutex_unlock(&myrpt->lock); /* UNLOCK */

         ast_cli(fd, "************************ NODE %s STATISTICS *************************\n\n", myrpt->name);
         ast_cli(fd, "Selected system state............................: %d\n", myrpt->p.sysstate_cur);
         ast_cli(fd, "Signal on input..................................: %s\n", input_signal);
         ast_cli(fd, "System...........................................: %s\n", sys_ena);
         ast_cli(fd, "Parrot Mode......................................: %s\n", parrot_ena);
         ast_cli(fd, "Scheduler........................................: %s\n", sch_ena);
         ast_cli(fd, "Tail Time........................................: %s\n", tail_type);
         ast_cli(fd, "Time out timer...................................: %s\n", tot_ena);
         ast_cli(fd, "Time out timer state.............................: %s\n", tot_state);
         ast_cli(fd, "Time outs since system initialization............: %d\n", timeouts);
         ast_cli(fd, "Identifier state.................................: %s\n", ider_state);
         ast_cli(fd, "Kerchunks today..................................: %d\n", dailykerchunks);
         ast_cli(fd, "Kerchunks since system initialization............: %d\n", totalkerchunks);
         ast_cli(fd, "Keyups today.....................................: %d\n", dailykeyups);
         ast_cli(fd, "Keyups since system initialization...............: %d\n", totalkeyups);
         ast_cli(fd, "DTMF commands today..............................: %d\n", dailyexecdcommands);
         ast_cli(fd, "DTMF commands since system initialization........: %d\n", totalexecdcommands);
         ast_cli(fd, "Last DTMF command executed.......................: %s\n", 
         (lastdtmfcommand && strlen(lastdtmfcommand)) ? lastdtmfcommand : not_applicable);
         hours = dailytxtime/3600000;
         dailytxtime %= 3600000;
         minutes = dailytxtime/60000;
         dailytxtime %= 60000;
         seconds = dailytxtime/1000;
         dailytxtime %= 1000;

         ast_cli(fd, "TX time today....................................: %02d:%02d:%02d.%d\n",
            hours, minutes, seconds, dailytxtime);

         hours = (int) totaltxtime/3600000;
         totaltxtime %= 3600000;
         minutes = (int) totaltxtime/60000;
         totaltxtime %= 60000;
         seconds = (int)  totaltxtime/1000;
         totaltxtime %= 1000;

         ast_cli(fd, "TX time since system initialization..............: %02d:%02d:%02d.%d\n",
             hours, minutes, seconds, (int) totaltxtime);

                        hours = uptime/3600;
                        uptime %= 3600;
                        minutes = uptime/60;
                        uptime %= 60;

                        ast_cli(fd, "Uptime...........................................: %02d:%02d:%02d\n",
                                hours, minutes, uptime);

         ast_cli(fd, "Nodes currently connected to us..................: ");
                        if(!numoflinks){
                         ast_cli(fd,"<NONE>");
                        }
         else{
            for(j = 0 ;j < numoflinks; j++){
               ast_cli(fd, "%s", listoflinks[j]);
               if(j % 4 == 3){
                  ast_cli(fd, "\n");
                  ast_cli(fd, "                                                 : ");
               }  
               else{
                  if((numoflinks - 1) - j  > 0)
                     ast_cli(fd, ", ");
               }
            }
         }
         ast_cli(fd,"\n");

         ast_cli(fd, "Autopatch........................................: %s\n", patch_ena);
         ast_cli(fd, "Autopatch state..................................: %s\n", patch_state);
         ast_cli(fd, "Autopatch called number..........................: %s\n",
         (called_number && strlen(called_number)) ? called_number : not_applicable);
         ast_cli(fd, "Reverse patch/IAXRPT connected...................: %s\n", reverse_patch_state);
         ast_cli(fd, "User linking commands............................: %s\n", link_ena);
         ast_cli(fd, "User functions...................................: %s\n\n", user_funs);

         for(j = 0; j < numoflinks; j++){ /* ast_free() all link names */
            ast_free(listoflinks[j]);
         }
         if(called_number){
            ast_free(called_number);
         }
         if(lastdtmfcommand){
            ast_free(lastdtmfcommand);
         }
              return RESULT_SUCCESS;
      }
   }
   return RESULT_FAILURE;
}

/*
* Link stats function
*/

static int rpt_do_lstats(int fd, int argc, char *argv[])
{
   int i,j;
   char *connstate;
   struct rpt *myrpt;
   struct rpt_link *l;
   struct rpt_lstat *s,*t;
   struct rpt_lstat s_head;
   if(argc != 3)
      return RESULT_SHOWUSAGE;

   s = NULL;
   s_head.next = &s_head;
   s_head.prev = &s_head;

   for(i = 0; i < nrpts; i++)
   {
      if (!strcmp(argv[2],rpt_vars[i].name)){
         /* Make a copy of all stat variables while locked */
         myrpt = &rpt_vars[i];
         rpt_mutex_lock(&myrpt->lock); /* LOCK */
         /* Traverse the list of connected nodes */
         j = 0;
         l = myrpt->links.next;
         while(l && (l != &myrpt->links)){
            if (l->name[0] == '0'){ /* Skip '0' nodes */
               l = l->next;
               continue;
            }
            if((s = (struct rpt_lstat *) ast_malloc(sizeof(struct rpt_lstat))) == NULL){
               ast_log(LOG_ERROR, "Malloc failed in rpt_do_lstats\n");
               rpt_mutex_unlock(&myrpt->lock); /* UNLOCK */
               return RESULT_FAILURE;
            }
            memset(s, 0, sizeof(struct rpt_lstat));
            strncpy(s->name, l->name, MAXREMSTR - 1);
            if (l->chan) pbx_substitute_variables_helper(l->chan, "${IAXPEER(CURRENTCHANNEL)}", s->peer, MAXPEERSTR - 1);
            else strcpy(s->peer,"(none)");
            s->mode = l->mode;
            s->outbound = l->outbound;
            s->reconnects = l->reconnects;
            s->connecttime = l->connecttime;
            s->thisconnected = l->thisconnected;
            memcpy(s->chan_stat,l->chan_stat,NRPTSTAT * sizeof(struct rpt_chan_stat));
            insque((struct qelem *) s, (struct qelem *) s_head.next);
            memset(l->chan_stat,0,NRPTSTAT * sizeof(struct rpt_chan_stat));
            l = l->next;
         }
         rpt_mutex_unlock(&myrpt->lock); /* UNLOCK */
         ast_cli(fd, "NODE      PEER                RECONNECTS  DIRECTION  CONNECT TIME        CONNECT STATE\n");
         ast_cli(fd, "----      ----                ----------  ---------  ------------        -------------\n");

         for(s = s_head.next; s != &s_head; s = s->next){
            int hours, minutes, seconds;
            long long connecttime = s->connecttime;
            char conntime[21];
            hours = (int) connecttime/3600000;
            connecttime %= 3600000;
            minutes = (int) connecttime/60000;
            connecttime %= 60000;
            seconds = (int)  connecttime/1000;
            connecttime %= 1000;
            snprintf(conntime, 20, "%02d:%02d:%02d.%d",
               hours, minutes, seconds, (int) connecttime);
            conntime[20] = 0;
            if(s->thisconnected)
               connstate  = "ESTABLISHED";
            else
               connstate = "CONNECTING";
            ast_cli(fd, "%-10s%-20s%-12d%-11s%-20s%-20s\n",
               s->name, s->peer, s->reconnects, (s->outbound)? "OUT":"IN", conntime, connstate);
         }  
         /* destroy our local link queue */
         s = s_head.next;
         while(s != &s_head){
            t = s;
            s = s->next;
            remque((struct qelem *)t);
            ast_free(t);
         }        
         return RESULT_SUCCESS;
      }
   }
   return RESULT_FAILURE;
}

/*
* List all nodes connected, directly or indirectly
*/

static int rpt_do_nodes(int fd, int argc, char *argv[])
{
   int i,j;
   char ns;
   char lbuf[MAXLINKLIST],*strs[MAXLINKLIST];
   struct rpt *myrpt;
   if(argc != 3)
      return RESULT_SHOWUSAGE;

   for(i = 0; i < nrpts; i++)
   {
      if (!strcmp(argv[2],rpt_vars[i].name)){
         /* Make a copy of all stat variables while locked */
         myrpt = &rpt_vars[i];
         rpt_mutex_lock(&myrpt->lock); /* LOCK */
         __mklinklist(myrpt,NULL,lbuf);
         rpt_mutex_unlock(&myrpt->lock); /* UNLOCK */
         /* parse em */
         ns = finddelim(lbuf,strs,MAXLINKLIST);
         /* sort em */
         if (ns) qsort((void *)strs,ns,sizeof(char *),mycompar);
         ast_cli(fd,"\n");
         ast_cli(fd, "************************* CONNECTED NODES *************************\n\n");
         for(j = 0 ;; j++){
            if(!strs[j]){
               if(!j){
                  ast_cli(fd,"<NONE>");
               }
               break;
            }
            ast_cli(fd, "%s", strs[j]);
            if(j % 8 == 7){
               ast_cli(fd, "\n");
            }
            else{
               if(strs[j + 1])
                  ast_cli(fd, ", ");
            }
         }
         ast_cli(fd,"\n\n");
         return RESULT_SUCCESS;
      }
   }
   return RESULT_FAILURE;
}

/*
* List all locally configured nodes
*/

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

    int i;
    ast_cli(fd, "\nNode\n----\n");
    for (i=0; i< nrpts; i++)
    {
        ast_cli(fd, "%s\n", rpt_vars[i].name);        
    } /* for i */
    ast_cli(fd,"\n");
    return RESULT_SUCCESS;
} 


/*
* reload vars 
*/

static int rpt_do_reload(int fd, int argc, char *argv[])
{
int   n;

        if (argc > 2) return RESULT_SHOWUSAGE;

   for(n = 0; n < nrpts; n++) rpt_vars[n].reload = 1;

   return RESULT_FAILURE;
}

/*
* restart app_rpt
*/
                                                                                                                                 
static int rpt_do_restart(int fd, int argc, char *argv[])
{
int   i;

        if (argc > 2) return RESULT_SHOWUSAGE;
   for(i = 0; i < nrpts; i++)
   {
      if (rpt_vars[i].rxchannel) ast_softhangup(rpt_vars[i].rxchannel,AST_SOFTHANGUP_DEV);
   }
   return RESULT_FAILURE;
}


/*
* send an app_rpt DTMF function from the CLI
*/
                                                                                                                                 
static int rpt_do_fun(int fd, int argc, char *argv[])
{
   int   i,busy=0;

        if (argc != 4) return RESULT_SHOWUSAGE;

   for(i = 0; i < nrpts; i++){
      if(!strcmp(argv[2], rpt_vars[i].name)){
         struct rpt *myrpt = &rpt_vars[i];
         rpt_mutex_lock(&myrpt->lock);
         if ((MAXMACRO - strlen(myrpt->macrobuf)) < strlen(argv[3])){
            rpt_mutex_unlock(&myrpt->lock);
            busy=1;
         }
         if(!busy){
            myrpt->macrotimer = MACROTIME;
            strncat(myrpt->macrobuf,argv[3],MAXMACRO - 1);
         }
         rpt_mutex_unlock(&myrpt->lock);
      }
   }
   if(busy){
      ast_cli(fd, "Function decoder busy");
   }
   return RESULT_FAILURE;
}
/*
   the convention is that macros in the data from the rpt() application
   are all at the end of the data, separated by the | and start with a *
   when put into the macro buffer, the characters have their high bit
   set so the macro processor knows they came from the application data
   and to use the alt-functions table.
   sph:
*/
static int rpt_push_alt_macro(struct rpt *myrpt, char *sptr)
{
   int   busy=0;

   rpt_mutex_lock(&myrpt->lock);
   if ((MAXMACRO - strlen(myrpt->macrobuf)) < strlen(sptr)){
      rpt_mutex_unlock(&myrpt->lock);
      busy=1;
   }
   if(!busy){
      int x;
      if (debug)ast_log(LOG_NOTICE, "rpt_push_alt_macro %s\n",sptr);
      myrpt->macrotimer = MACROTIME;
      for(x = 0; *(sptr + x); x++)
          myrpt->macrobuf[x] = *(sptr + x) | 0x80;
      *(sptr + x) = 0;
   }
   rpt_mutex_unlock(&myrpt->lock);

   if(busy)ast_log(LOG_WARNING, "Function decoder busy on app_rpt command macro.\n");

   return busy;
}
/*
   allows us to test rpt() application data commands
*/
static int rpt_do_fun1(int fd, int argc, char *argv[])
{
   int   i;

    if (argc != 4) return RESULT_SHOWUSAGE;

   for(i = 0; i < nrpts; i++){
      if(!strcmp(argv[2], rpt_vars[i].name)){
         struct rpt *myrpt = &rpt_vars[i];
         rpt_push_alt_macro(myrpt,argv[3]);
      }
   }
   return RESULT_FAILURE;
}
/*
* send an app_rpt **command** from the CLI
*/

static int rpt_do_cmd(int fd, int argc, char *argv[])
{
   int i, l;
   int busy=0;
   int maxActions = sizeof(function_table)/sizeof(struct function_table_tag);

   int thisRpt = -1;
   int thisAction = -1;
   struct rpt *myrpt = NULL;
   if (argc != 6) return RESULT_SHOWUSAGE;
   
   for(i = 0; i < nrpts; i++)
   {
      if(!strcmp(argv[2], rpt_vars[i].name))
      {
         thisRpt = i;
         myrpt = &rpt_vars[i];
         break;
      } /* if !strcmp... */
   } /* for i */

   if (thisRpt < 0)
   {
      ast_cli(fd, "Unknown node number %s.\n", argv[2]);
      return RESULT_FAILURE;
   } /* if thisRpt < 0 */
   
   /* Look up the action */
   l = strlen(argv[3]);
   for(i = 0 ; i < maxActions; i++)
   {
      if(!strncasecmp(argv[3], function_table[i].action, l))
      {
         thisAction = i;
         break;
      } /* if !strncasecmp... */
   } /* for i */
   
   if (thisAction < 0)
   {
      ast_cli(fd, "Unknown action name %s.\n", argv[3]);
      return RESULT_FAILURE;
   } /* if thisAction < 0 */

   /* at this point, it looks like all the arguments make sense... */

   rpt_mutex_lock(&myrpt->lock);

   if (rpt_vars[thisRpt].cmdAction.state == CMD_STATE_IDLE)
   {
      rpt_vars[thisRpt].cmdAction.state = CMD_STATE_BUSY;
      rpt_vars[thisRpt].cmdAction.functionNumber = thisAction;
      strncpy(rpt_vars[thisRpt].cmdAction.param, argv[4], MAXDTMF);
      strncpy(rpt_vars[thisRpt].cmdAction.digits, argv[5], MAXDTMF);
      rpt_vars[thisRpt].cmdAction.command_source = SOURCE_RPT;
      rpt_vars[thisRpt].cmdAction.state = CMD_STATE_READY;
   } /* if (rpt_vars[thisRpt].cmdAction.state == CMD_STATE_IDLE */
   else
   {
      busy = 1;
   } /* if (rpt_vars[thisRpt].cmdAction.state == CMD_STATE_IDLE */
   rpt_mutex_unlock(&myrpt->lock);

   return (busy ? RESULT_FAILURE : RESULT_SUCCESS);
} /* rpt_do_cmd() */

static int play_tone_pair(struct ast_channel *chan, int f1, int f2, int duration, int amplitude)
{
   int res;

        if ((res = ast_tonepair_start(chan, f1, f2, duration, amplitude)))
                return res;
                                                                                                                                            
        while(chan->generatordata) {
      if (ast_safe_sleep(chan,1)) return -1;
   }

        return 0;
}

static int play_tone(struct ast_channel *chan, int freq, int duration, int amplitude)
{
   return play_tone_pair(chan, freq, 0, duration, amplitude);
}

static int play_silence(struct ast_channel *chan, int duration)
{
   return play_tone_pair(chan, 0, 0, duration, 0);
}

#ifdef   NEW_ASTERISK

static char *res2cli(int r)

{
   switch (r)
   {
       case RESULT_SUCCESS:
      return(CLI_SUCCESS);
       case RESULT_SHOWUSAGE:
      return(CLI_SHOWUSAGE);
       default:
      return(CLI_FAILURE);
   }
}

static char *handle_cli_debug(struct ast_cli_entry *e,
   int cmd, struct ast_cli_args *a)
{
        switch (cmd) {
        case CLI_INIT:
                e->command = "rpt debug level";
                e->usage = debug_usage;
                return NULL;
        case CLI_GENERATE:
                return NULL;
   }
   return res2cli(rpt_do_debug(a->fd,a->argc,a->argv));
}

static char *handle_cli_dump(struct ast_cli_entry *e,
   int cmd, struct ast_cli_args *a)
{
        switch (cmd) {
        case CLI_INIT:
                e->command = "rpt dump level";
                e->usage = dump_usage;
                return NULL;
        case CLI_GENERATE:
                return NULL;
   }
   return res2cli(rpt_do_dump(a->fd,a->argc,a->argv));
}


static char *handle_cli_stats(struct ast_cli_entry *e,
   int cmd, struct ast_cli_args *a)
{
        switch (cmd) {
        case CLI_INIT:
                e->command = "rpt stats";
                e->usage = dump_stats;
                return NULL;
        case CLI_GENERATE:
                return NULL;
   }
   return res2cli(rpt_do_stats(a->fd,a->argc,a->argv));
}

static char *handle_cli_nodes(struct ast_cli_entry *e,
   int cmd, struct ast_cli_args *a)
{
        switch (cmd) {
        case CLI_INIT:
                e->command = "rpt nodes";
                e->usage = dump_nodes;
                return NULL;
        case CLI_GENERATE:
                return NULL;
   }
   return res2cli(rpt_do_nodes(a->fd,a->argc,a->argv));
}

static char *handle_cli_local_nodes(struct ast_cli_entry *e,
   int cmd, struct ast_cli_args *a)
{
        switch (cmd) {
        case CLI_INIT:
                e->command = "rpt localnodes";
                e->usage = usage_local_nodes;
                return NULL;
        case CLI_GENERATE:
                return NULL;
   }
   return res2cli(rpt_do_local_nodes(a->fd,a->argc,a->argv));
}

static char *handle_cli_lstats(struct ast_cli_entry *e,
   int cmd, struct ast_cli_args *a)
{
        switch (cmd) {
        case CLI_INIT:
                e->command = "rpt lstats";
                e->usage = dump_lstats;
                return NULL;
        case CLI_GENERATE:
                return NULL;
   }
   return res2cli(rpt_do_lstats(a->fd,a->argc,a->argv));
}

static char *handle_cli_reload(struct ast_cli_entry *e,
   int cmd, struct ast_cli_args *a)
{
        switch (cmd) {
        case CLI_INIT:
                e->command = "rpt reload";
                e->usage = reload_usage;
                return NULL;
        case CLI_GENERATE:
                return NULL;
   }
   return res2cli(rpt_do_reload(a->fd,a->argc,a->argv));
}

static char *handle_cli_restart(struct ast_cli_entry *e,
   int cmd, struct ast_cli_args *a)
{
        switch (cmd) {
        case CLI_INIT:
                e->command = "rpt restart";
                e->usage = restart_usage;
                return NULL;
        case CLI_GENERATE:
                return NULL;
   }
   return res2cli(rpt_do_restart(a->fd,a->argc,a->argv));
}

static char *handle_cli_fun(struct ast_cli_entry *e,
   int cmd, struct ast_cli_args *a)
{
        switch (cmd) {
        case CLI_INIT:
                e->command = "rpt fun";
                e->usage = fun_usage;
                return NULL;
        case CLI_GENERATE:
                return NULL;
   }
   return res2cli(rpt_do_fun(a->fd,a->argc,a->argv));
}

static char *handle_cli_fun1(struct ast_cli_entry *e,
   int cmd, struct ast_cli_args *a)
{
        switch (cmd) {
        case CLI_INIT:
                e->command = "rpt fun1";
                e->usage = fun_usage;
                return NULL;
        case CLI_GENERATE:
                return NULL;
   }
   return res2cli(rpt_do_fun1(a->fd,a->argc,a->argv));
}

static char *handle_cli_cmd(struct ast_cli_entry *e,
   int cmd, struct ast_cli_args *a)
{
        switch (cmd) {
        case CLI_INIT:
                e->command = "rpt cmd";
                e->usage = cmd_usage;
                return NULL;
        case CLI_GENERATE:
                return NULL;
   }
   return res2cli(rpt_do_cmd(a->fd,a->argc,a->argv));
}

static struct ast_cli_entry rpt_cli[] = {
   AST_CLI_DEFINE(handle_cli_debug,"Enable app_rpt debugging"),
   AST_CLI_DEFINE(handle_cli_dump,"Dump app_rpt structs for debugging"),
   AST_CLI_DEFINE(handle_cli_stats,"Dump node statistics"),
   AST_CLI_DEFINE(handle_cli_nodes,"Dump node list"),
   AST_CLI_DEFINE(handle_cli_local_nodes, "Dump list of local node numbers"),
   AST_CLI_DEFINE(handle_cli_lstats,"Dump link statistics"),
   AST_CLI_DEFINE(handle_cli_reload,"Reload app_rpt config"),
   AST_CLI_DEFINE(handle_cli_restart,"Restart app_rpt"),
   AST_CLI_DEFINE(handle_cli_fun,"Execute a DTMF function"),
   AST_CLI_DEFINE(handle_cli_fun1,"Execute a DTMF function"),
   AST_CLI_DEFINE(handle_cli_cmd,"Execute a DTMF function")
};

#endif

static int send_morse(struct ast_channel *chan, char *string, int speed, int freq, int amplitude)
{

static struct morse_bits mbits[] = {
      {0, 0}, /* SPACE */
      {0, 0}, 
      {6, 18},/* " */
      {0, 0},
      {7, 72},/* $ */
      {0, 0},
      {0, 0},
      {6, 30},/* ' */
      {5, 13},/* ( */
      {6, 29},/* ) */
      {0, 0},
      {5, 10},/* + */
      {6, 51},/* , */
      {6, 33},/* - */
      {6, 42},/* . */
      {5, 9}, /* / */
      {5, 31},/* 0 */
      {5, 30},/* 1 */
      {5, 28},/* 2 */
      {5, 24},/* 3 */
      {5, 16},/* 4 */
      {5, 0}, /* 5 */
      {5, 1}, /* 6 */
      {5, 3}, /* 7 */
      {5, 7}, /* 8 */
      {5, 15},/* 9 */
      {6, 7}, /* : */
      {6, 21},/* ; */
      {0, 0},
      {5, 33},/* = */
      {0, 0},
      {6, 12},/* ? */
      {0, 0},
         {2, 2}, /* A */
      {4, 1}, /* B */
      {4, 5}, /* C */
      {3, 1}, /* D */
      {1, 0}, /* E */
      {4, 4}, /* F */
      {3, 3}, /* G */
      {4, 0}, /* H */
      {2, 0}, /* I */
      {4, 14},/* J */
      {3, 5}, /* K */
      {4, 2}, /* L */
      {2, 3}, /* M */
      {2, 1}, /* N */
      {3, 7}, /* O */
      {4, 6}, /* P */
      {4, 11},/* Q */
      {3, 2}, /* R */
      {3, 0}, /* S */
      {1, 1}, /* T */
      {3, 4}, /* U */
      {4, 8}, /* V */
      {3, 6}, /* W */
      {4, 9}, /* X */
      {4, 13},/* Y */
      {4, 3}  /* Z */
   };


   int dottime;
   int dashtime;
   int intralettertime;
   int interlettertime;
   int interwordtime;
   int len, ddcomb;
   int res;
   int c;
   int i;
   int flags;
         
   res = 0;
   
   /* Approximate the dot time from the speed arg. */
   
   dottime = 900/speed;
   
   /* Establish timing releationships */
   
   dashtime = 3 * dottime;
   intralettertime = dottime;
   interlettertime = dottime * 4 ;
   interwordtime = dottime * 7;
   
   for(;(*string) && (!res); string++){
   
      c = *string;
      
      /* Convert lower case to upper case */
      
      if((c >= 'a') && (c <= 'z'))
         c -= 0x20;
      
      /* Can't deal with any char code greater than Z, skip it */
      
      if(c  > 'Z')
         continue;
      
      /* If space char, wait the inter word time */
               
      if(c == ' '){
         if(!res)
            res = play_silence(chan, interwordtime);
         continue;
      }
      
      /* Subtract out control char offset to match our table */
      
      c -= 0x20;
      
      /* Get the character data */
      
      len = mbits[c].len;
      ddcomb = mbits[c].ddcomb;
      
      /* Send the character */
      
      for(; len ; len--){
         if(!res)
            res = play_tone(chan, freq, (ddcomb & 1) ? dashtime : dottime, amplitude);
         if(!res)
            res = play_silence(chan, intralettertime);
         ddcomb >>= 1;
      }
      
      /* Wait the interletter time */
      
      if(!res)
         res = play_silence(chan, interlettertime - intralettertime);
   }
   
   /* Wait for all the frames to be sent */
   
   if (!res) 
      res = ast_waitstream(chan, "");
   ast_stopstream(chan);
   
   /*
   * Wait for the DAHDI driver to physically write the tone blocks to the hardware
   */

   for(i = 0; i < 20 ; i++){
      flags =  DAHDI_IOMUX_WRITEEMPTY | DAHDI_IOMUX_NOWAIT; 
      res = ioctl(chan->fds[0], DAHDI_IOMUX, &flags);
      if(flags & DAHDI_IOMUX_WRITEEMPTY)
         break;
      if( ast_safe_sleep(chan, 50)){
         res = -1;
         break;
      }
   }

   
   return res;
}

static int send_tone_telemetry(struct ast_channel *chan, char *tonestring)
{
   char *p,*stringp;
   char *tonesubset;
   int f1,f2;
   int duration;
   int amplitude;
   int res;
   int i;
   int flags;
   
   res = 0;

   if(!tonestring)
      return res;
   
   p = stringp = ast_strdup(tonestring);

   for(;tonestring;){
      tonesubset = strsep(&stringp,")");
      if(!tonesubset)
         break;
      if(sscanf(tonesubset,"(%30d,%30d,%30d,%30d", &f1, &f2, &duration, &amplitude) != 4)
         break;
      res = play_tone_pair(chan, f1, f2, duration, amplitude);
      if(res)
         break;
   }
   if(p)
      ast_free(p);
   if(!res)
      res = play_tone_pair(chan, 0, 0, 100, 0); /* This is needed to ensure the last tone segment is timed correctly */
   
   if (!res) 
      res = ast_waitstream(chan, "");

   ast_stopstream(chan);

   /*
   * Wait for the DAHDI driver to physically write the tone blocks to the hardware
   */

   for(i = 0; i < 20 ; i++){
      flags =  DAHDI_IOMUX_WRITEEMPTY | DAHDI_IOMUX_NOWAIT; 
      res = ioctl(chan->fds[0], DAHDI_IOMUX, &flags);
      if(flags & DAHDI_IOMUX_WRITEEMPTY)
         break;
      if( ast_safe_sleep(chan, 50)){
         res = -1;
         break;
      }
   }
      
   return res;
      
}

static int sayfile(struct ast_channel *mychannel,char *fname)
{
int   res;

   res = ast_streamfile(mychannel, fname, mychannel->language);
   if (!res) 
      res = ast_waitstream(mychannel, "");
   else
       ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
   ast_stopstream(mychannel);
   return res;
}

static int saycharstr(struct ast_channel *mychannel,char *str)
{
int   res;

   res = ast_say_character_str(mychannel,str,NULL,mychannel->language);
   if (!res) 
      res = ast_waitstream(mychannel, "");
   else
       ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
   ast_stopstream(mychannel);
   return res;
}

static int saynum(struct ast_channel *mychannel, int num)
{
   int res;
   res = ast_say_number(mychannel, num, NULL, mychannel->language, NULL);
   if(!res)
      res = ast_waitstream(mychannel, "");
   else
      ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
   ast_stopstream(mychannel);
   return res;
}

/* say a node and nodename. Try to look in dir referred to by nodenames in
config, and see if there's a custom node file to play, and if so, play it */

static int saynode(struct rpt *myrpt, struct ast_channel *mychannel, char *name)
{
int   res;
char  *val,fname[300];

   val = (char *) ast_variable_retrieve(myrpt->cfg, myrpt->name, "nodenames");
   if (!val) val = NODENAMES;
   snprintf(fname,sizeof(fname) - 1,"%s/%s",val,name);
   if (ast_fileexists(fname,NULL,mychannel->language) > 0)
      return(sayfile(mychannel,fname));
   res = sayfile(mychannel,"rpt/node");
   if (!res) 
      res = ast_say_character_str(mychannel,name,NULL,mychannel->language);
   return res;
}

static int telem_any(struct rpt *myrpt,struct ast_channel *chan, char *entry)
{
   int res;
   char c;
   
   static int morsespeed;
   static int morsefreq;
   static int morseampl;
   static int morseidfreq = 0;
   static int morseidampl;
   static char mcat[] = MORSE;
   
   res = 0;
   
   if(!morseidfreq){ /* Get the morse parameters if not already loaded */
      morsespeed = retrieve_astcfgint(myrpt, mcat, "speed", 5, 20, 20);
         morsefreq = retrieve_astcfgint(myrpt, mcat, "frequency", 300, 3000, 800);
         morseampl = retrieve_astcfgint(myrpt, mcat, "amplitude", 200, 8192, 4096);
      morseidampl = retrieve_astcfgint(myrpt, mcat, "idamplitude", 200, 8192, 2048);
      morseidfreq = retrieve_astcfgint(myrpt, mcat, "idfrequency", 300, 3000, 330); 
   }
   
   /* Is it a file, or a tone sequence? */
         
   if(entry[0] == '|'){
      c = entry[1];
      if((c >= 'a')&&(c <= 'z'))
         c -= 0x20;
   
      switch(c){
         case 'I': /* Morse ID */
            res = send_morse(chan, entry + 2, morsespeed, morseidfreq, morseidampl);
            break;
         
         case 'M': /* Morse Message */
            res = send_morse(chan, entry + 2, morsespeed, morsefreq, morseampl);
            break;
         
         case 'T': /* Tone sequence */
            res = send_tone_telemetry(chan, entry + 2);
            break;
         default:
            res = -1;
      }
   }
   else
      res = sayfile(chan, entry); /* File */
   return res;
}

/*
* This function looks up a telemetry name in the config file, and does a telemetry response as configured.
*
* 4 types of telemtry are handled: Morse ID, Morse Message, Tone Sequence, and a File containing a recording.
*/

static int telem_lookup(struct rpt *myrpt,struct ast_channel *chan, char *node, char *name)
{
   
   int res;
   int i;
   char *entry;
   char *telemetry;
   char *telemetry_save;

   res = 0;
   telemetry_save = NULL;
   entry = NULL;
   
   /* Retrieve the section name for telemetry from the node section */
   telemetry = (char *) ast_variable_retrieve(myrpt->cfg, node, TELEMETRY);
   if(telemetry ){
      telemetry_save = ast_strdup(telemetry);
      if(!telemetry_save){
         ast_log(LOG_WARNING,"ast_strdup() failed in telem_lookup()\n");
         return res;
      }
      entry = (char *) ast_variable_retrieve(myrpt->cfg, telemetry_save, name);
   }
   
   /* Try to look up the telemetry name */   

   if(!entry){
      /* Telemetry name wasn't found in the config file, use the default */
      for(i = 0; i < sizeof(tele_defs)/sizeof(struct telem_defaults) ; i++){
         if(!strcasecmp(tele_defs[i].name, name))
            entry = tele_defs[i].value;
      }
   }
   if(entry){  
      if(strlen(entry))
         if (chan) telem_any(myrpt,chan, entry);
   }
   else{
      res = -1;
   }
   if(telemetry_save)
      ast_free(telemetry_save);
   return res;
}

/*
* Retrieve a wait interval
*/

static int get_wait_interval(struct rpt *myrpt, int type)
{
        int interval;
        char *wait_times;
        char *wait_times_save;
                                                                                                                  
        wait_times_save = NULL;
        wait_times = (char *) ast_variable_retrieve(myrpt->cfg, myrpt->name, "wait_times");
                                                                                                                  
        if(wait_times){
                wait_times_save = ast_strdup(wait_times);
                if(!wait_times_save)
         return 0;
                
        }
                                                                                                                  
        switch(type){
                case DLY_TELEM:
                        if(wait_times)
                                interval = retrieve_astcfgint(myrpt,wait_times_save, "telemwait", 500, 5000, 1000);
                        else
                                interval = 1000;
                        break;
                                                                                                                  
                case DLY_ID:
                        if(wait_times)
                                interval = retrieve_astcfgint(myrpt,wait_times_save, "idwait",250,5000,500);
                        else
                                interval = 500;
                        break;
                                                                                                                  
                case DLY_UNKEY:
                        if(wait_times)
                                interval = retrieve_astcfgint(myrpt,wait_times_save, "unkeywait",50,5000,1000);
                        else
                                interval = 1000;
                        break;
                                                                                                                  
                case DLY_LINKUNKEY:
                        if(wait_times)
                                interval = retrieve_astcfgint(myrpt,wait_times_save, "linkunkeywait",500,5000,1000);
                        else
                                interval = 1000;
                        break;
                                                                                                                  
                case DLY_CALLTERM:
                        if(wait_times)
                                interval = retrieve_astcfgint(myrpt,wait_times_save, "calltermwait",500,5000,1500);
                        else
                                interval = 1500;
                        break;
                                                                                                                  
                case DLY_COMP:
                        if(wait_times)
                                interval = retrieve_astcfgint(myrpt,wait_times_save, "compwait",500,5000,200);
                        else
                                interval = 200;
                        break;
                                                                                                                  
                case DLY_PARROT:
                        if(wait_times)
                                interval = retrieve_astcfgint(myrpt,wait_times_save, "parrotwait",500,5000,200);
                        else
                                interval = 200;
                        break;
                                                                                                                  
                default:
         interval = 0;
         break;
        }
   if(wait_times_save)
            ast_free(wait_times_save);
   return interval;
}                                                                                                                  


/*
* Wait a configurable interval of time 
*/
static void wait_interval(struct rpt *myrpt, int type, struct ast_channel *chan)
{
   int interval;
   interval = get_wait_interval(myrpt, type);
   if(debug)
      ast_log(LOG_NOTICE,"Delay interval = %d\n", interval);
   if(interval)
      ast_safe_sleep(chan,interval);
   if(debug)
      ast_log(LOG_NOTICE,"Delay complete\n");
   return;
}

static int split_freq(char *mhz, char *decimals, char *freq);

static void *rpt_tele_thread(void *this)
{
struct dahdi_confinfo ci;  /* conference info */
int   res = 0,haslink,hastx,hasremote,imdone = 0, unkeys_queued, x;
struct   rpt_tele *mytele = (struct rpt_tele *)this;
struct  rpt_tele *tlist;
struct   rpt *myrpt;
struct   rpt_link *l,*l1,linkbase;
struct   ast_channel *mychannel;
int vmajor, vminor, m;
char *p,*ct,*ct_copy,*ident, *nodename,*cp;
time_t t;
#ifdef   NEW_ASTERISK
struct ast_tm localtm;
#else
struct tm localtm;
#endif
char lbuf[MAXLINKLIST],*strs[MAXLINKLIST];
int   i,ns,rbimode;
char mhz[MAXREMSTR];
char decimals[MAXREMSTR];
char  mystr[200];
struct dahdi_params par;


   /* get a pointer to myrpt */
   myrpt = mytele->rpt;

   /* Snag copies of a few key myrpt variables */
   rpt_mutex_lock(&myrpt->lock);
   nodename = ast_strdup(myrpt->name);
   if(!nodename)
   {
       fprintf(stderr,"rpt:Sorry unable strdup nodename\n");
       rpt_mutex_lock(&myrpt->lock);
       remque((struct qelem *)mytele);
       ast_log(LOG_NOTICE,"Telemetry thread aborted at line %d, mode: %d\n",__LINE__, mytele->mode); /*@@@@@@@@@@@*/
       rpt_mutex_unlock(&myrpt->lock);
       ast_free(mytele);
       pthread_exit(NULL);
   }

   if (myrpt->p.ident){
      ident = ast_strdup(myrpt->p.ident);
         if(!ident)
      {
                 fprintf(stderr,"rpt:Sorry unable strdup ident\n");
         rpt_mutex_lock(&myrpt->lock);
                  remque((struct qelem *)mytele);
                  ast_log(LOG_NOTICE,"Telemetry thread aborted at line %d, mode: %d\n",
         __LINE__, mytele->mode); /*@@@@@@@@@@@*/
                  rpt_mutex_unlock(&myrpt->lock);
         ast_free(nodename);
                  ast_free(mytele);
                  pthread_exit(NULL);
         }
   }
   else
   {
      ident = "";
   }
   rpt_mutex_unlock(&myrpt->lock);
      


   /* allocate a pseudo-channel thru asterisk */
   mychannel = ast_request("DAHDI",AST_FORMAT_SLINEAR,"pseudo",NULL);
   if (!mychannel)
   {
      fprintf(stderr,"rpt:Sorry unable to obtain pseudo channel\n");
      rpt_mutex_lock(&myrpt->lock);
      remque((struct qelem *)mytele);
      ast_log(LOG_NOTICE,"Telemetry thread aborted at line %d, mode: %d\n",__LINE__, mytele->mode); /*@@@@@@@@@@@*/
      rpt_mutex_unlock(&myrpt->lock);
      ast_free(nodename);
      ast_free(ident);
      ast_free(mytele);    
      pthread_exit(NULL);
   }
#ifdef   AST_CDR_FLAG_POST_DISABLED
   if (mychannel->cdr) 
      ast_set_flag(mychannel->cdr,AST_CDR_FLAG_POST_DISABLED);
#endif
   rpt_mutex_lock(&myrpt->lock);
   mytele->chan = mychannel;
   rpt_mutex_unlock(&myrpt->lock);

   while((mytele->mode != SETREMOTE) && (mytele->mode != UNKEY) &&
      (mytele->mode != LINKUNKEY))
   {  
                rpt_mutex_lock(&myrpt->lock);
      if (!myrpt->active_telem)
      {
         myrpt->active_telem = mytele;
                   rpt_mutex_unlock(&myrpt->lock);
         break;
      }
                rpt_mutex_unlock(&myrpt->lock);
      usleep(100000);
   }

   /* make a conference for the tx */
   ci.chan = 0;
   /* If the telemetry is only intended for a local audience, */
   /* only connect the ID audio to the local tx conference so */
   /* linked systems can't hear it */
   ci.confno = (((mytele->mode == ID) || (mytele->mode == IDTALKOVER) || (mytele->mode == UNKEY) || 
      (mytele->mode == TAILMSG) || (mytele->mode == LINKUNKEY) || (mytele->mode == TIMEOUT) || 
      (mytele->mode == PARROT) || (mytele->mode == STATS_TIME_LOCAL)) ? 
         myrpt->txconf : myrpt->conf);
   ci.confmode = DAHDI_CONF_CONFANN;
   /* first put the channel on the conference in announce mode */
   if (ioctl(mychannel->fds[0],DAHDI_SETCONF,&ci) == -1)
   {
      ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
      rpt_mutex_lock(&myrpt->lock);
      myrpt->active_telem = NULL;
      remque((struct qelem *)mytele);
      rpt_mutex_unlock(&myrpt->lock);
      ast_log(LOG_NOTICE,"Telemetry thread aborted at line %d, mode: %d\n",__LINE__, mytele->mode); /*@@@@@@@@@@@*/
      ast_free(nodename);
      ast_free(ident);
      ast_free(mytele);    
      ast_hangup(mychannel);
      pthread_exit(NULL);
   }
   ast_stopstream(mychannel);
   switch(mytele->mode)
   {
       case ID:
       case ID1:
      /* wait a bit */
      wait_interval(myrpt, (mytele->mode == ID) ? DLY_ID : DLY_TELEM,mychannel);
      res = telem_any(myrpt,mychannel, ident); 
      imdone=1;   
      break;
      
       case TAILMSG:
      res = ast_streamfile(mychannel, myrpt->p.tailmessages[myrpt->tailmessagen], mychannel->language); 
      break;
      
       case IDTALKOVER:
         p = (char *) ast_variable_retrieve(myrpt->cfg, nodename, "idtalkover");
         if(p)
         res = telem_any(myrpt,mychannel, p); 
      imdone=1;   
         break;
            
       case PROC:
      /* wait a little bit longer */
      wait_interval(myrpt, DLY_TELEM, mychannel);
      res = telem_lookup(myrpt, mychannel, myrpt->name, "patchup");
      if(res < 0){ /* Then default message */
         res = ast_streamfile(mychannel, "rpt/callproceeding", mychannel->language);
      }
      break;
       case TERM:
      /* wait a little bit longer */
      wait_interval(myrpt, DLY_CALLTERM, mychannel);
      res = telem_lookup(myrpt, mychannel, myrpt->name, "patchdown");
      if(res < 0){ /* Then default message */
         res = ast_streamfile(mychannel, "rpt/callterminated", mychannel->language);
      }
      break;
       case COMPLETE:
      /* wait a little bit */
      wait_interval(myrpt, DLY_TELEM, mychannel);
      res = telem_lookup(myrpt,mychannel, myrpt->name, "functcomplete");
      break;
       case MACRO_NOTFOUND:
      /* wait a little bit */
      wait_interval(myrpt, DLY_TELEM, mychannel);
      res = ast_streamfile(mychannel, "rpt/macro_notfound", mychannel->language);
      break;
       case MACRO_BUSY:
      /* wait a little bit */
      wait_interval(myrpt, DLY_TELEM, mychannel);
      res = ast_streamfile(mychannel, "rpt/macro_busy", mychannel->language);
      break;
       case UNKEY:
      if(myrpt->patchnoct && myrpt->callmode){ /* If no CT during patch configured, then don't send one */
         imdone = 1;
         break;
      }
         
      /*
      * Reset the Unkey to CT timer
      */

      x = get_wait_interval(myrpt, DLY_UNKEY);
      rpt_mutex_lock(&myrpt->lock);
      myrpt->unkeytocttimer = x; /* Must be protected as it is changed below */
      rpt_mutex_unlock(&myrpt->lock);

      /*
      * If there's one already queued, don't do another
      */

      tlist = myrpt->tele.next;
      unkeys_queued = 0;
                if (tlist != &myrpt->tele)
                {
                        rpt_mutex_lock(&myrpt->lock);
                        while(tlist != &myrpt->tele){
                                if (tlist->mode == UNKEY) unkeys_queued++;
                                tlist = tlist->next;
                        }
                        rpt_mutex_unlock(&myrpt->lock);
      }
      if( unkeys_queued > 1){
         imdone = 1;
         break;
      }

      /* Wait for the telemetry timer to expire */
      /* Periodically check the timer since it can be re-initialized above */
      while(myrpt->unkeytocttimer)
      {
         int ctint;
         if(myrpt->unkeytocttimer > 100)
            ctint = 100;
         else
            ctint = myrpt->unkeytocttimer;
         ast_safe_sleep(mychannel, ctint);
         rpt_mutex_lock(&myrpt->lock);
         if(myrpt->unkeytocttimer < ctint)
            myrpt->unkeytocttimer = 0;
         else
            myrpt->unkeytocttimer -= ctint;
         rpt_mutex_unlock(&myrpt->lock);
      }
   
      /*
      * Now, the carrier on the rptr rx should be gone. 
      * If it re-appeared, then forget about sending the CT
      */
      if(myrpt->keyed){
         imdone = 1;
         break;
      }
      
      rpt_mutex_lock(&myrpt->lock); /* Update the kerchunk counters */
      myrpt->dailykerchunks++;
      myrpt->totalkerchunks++;
      rpt_mutex_unlock(&myrpt->lock);
   
      haslink = 0;
      hastx = 0;
      hasremote = 0;    
      l = myrpt->links.next;
      if (l != &myrpt->links)
      {
         rpt_mutex_lock(&myrpt->lock);
         while(l != &myrpt->links)
         {
            if (l->name[0] == '0')
            {
               l = l->next;
               continue;
            }
            haslink = 1;
            if (l->mode) {
               hastx++;
               if (l->isremote) hasremote++;
            }
            l = l->next;
         }
         rpt_mutex_unlock(&myrpt->lock);
      }
      if (haslink)
      {

         res = telem_lookup(myrpt,mychannel, myrpt->name, (!hastx) ? "remotemon" : "remotetx");
         if(res)
            ast_log(LOG_WARNING, "telem_lookup:remotexx failed on %s\n", mychannel->name);
         
      
         /* if in remote cmd mode, indicate it */
         if (myrpt->cmdnode[0])
         {
            ast_safe_sleep(mychannel,200);
            res = telem_lookup(myrpt,mychannel, myrpt->name, "cmdmode");
            if(res)
               ast_log(LOG_WARNING, "telem_lookup:cmdmode failed on %s\n", mychannel->name);
            ast_stopstream(mychannel);
         }
      }
      else if((ct = (char *) ast_variable_retrieve(myrpt->cfg, nodename, "unlinkedct"))){ /* Unlinked Courtesy Tone */
         ct_copy = ast_strdup(ct);
         if(ct_copy)
         {
            res = telem_lookup(myrpt,mychannel, myrpt->name, ct_copy);
            ast_free(ct_copy);
         }
         else
            res = -1;
         if(res)
            ast_log(LOG_WARNING, "telem_lookup:ctx failed on %s\n", mychannel->name);     
      }  
      if (hasremote && (!myrpt->cmdnode[0]))
      {
         /* set for all to hear */
         ci.chan = 0;
         ci.confno = myrpt->conf;
         ci.confmode = DAHDI_CONF_CONFANN;
         /* first put the channel on the conference in announce mode */
         if (ioctl(mychannel->fds[0],DAHDI_SETCONF,&ci) == -1)
         {
            ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
            rpt_mutex_lock(&myrpt->lock);
            myrpt->active_telem = NULL;
            remque((struct qelem *)mytele);
            rpt_mutex_unlock(&myrpt->lock);
            ast_log(LOG_NOTICE,"Telemetry thread aborted at line %d, mode: %d\n",__LINE__, mytele->mode); /*@@@@@@@@@@@*/
            ast_free(nodename);
            ast_free(ident);
            ast_free(mytele);    
            ast_hangup(mychannel);
            pthread_exit(NULL);
         }
         if((ct = (char *) ast_variable_retrieve(myrpt->cfg, nodename, "remotect"))){ /* Unlinked Courtesy Tone */
            ast_safe_sleep(mychannel,200);
            ct_copy = ast_strdup(ct);
            if(ct_copy)
            {
               res = telem_lookup(myrpt,mychannel, myrpt->name, ct_copy);
               ast_free(ct_copy);
            }
            else
               res = -1;
      
            if(res)
               ast_log(LOG_WARNING, "telem_lookup:ctx failed on %s\n", mychannel->name);     
         }  
      }
#if   defined(_MDC_DECODE_H_) && defined(MDC_SAY_WHEN_DOING_CT)
      if (myrpt->lastunit)
      {
         char mystr[10];

         ast_safe_sleep(mychannel,200);
         /* set for all to hear */
         ci.chan = 0;
         ci.confno = myrpt->txconf;
         ci.confmode = DAHDI_CONF_CONFANN;
         /* first put the channel on the conference in announce mode */
         if (ioctl(mychannel->fds[0],DAHDI_SETCONF,&ci) == -1)
         {
            ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
            rpt_mutex_lock(&myrpt->lock);
            myrpt->active_telem = NULL;
            remque((struct qelem *)mytele);
            rpt_mutex_unlock(&myrpt->lock);
            ast_log(LOG_NOTICE,"Telemetry thread aborted at line %d, mode: %d\n",__LINE__, mytele->mode); /*@@@@@@@@@@@*/
            ast_free(nodename);
            ast_free(ident);
            ast_free(mytele);    
            ast_hangup(mychannel);
            pthread_exit(NULL);
         }
         sprintf(mystr,"%04x",myrpt->lastunit);
         myrpt->lastunit = 0;
         ast_say_character_str(mychannel,mystr,NULL,mychannel->language);
         break;
      }
#endif
      imdone = 1;
      break;
       case LINKUNKEY:
      if(myrpt->patchnoct && myrpt->callmode){ /* If no CT during patch configured, then don't send one */
         imdone = 1;
         break;
      }
         
      /*
      * Reset the Unkey to CT timer
      */

      x = get_wait_interval(myrpt, DLY_LINKUNKEY);
      mytele->mylink.linkunkeytocttimer = x; /* Must be protected as it is changed below */

      /*
      * If there's one already queued, don't do another
      */

      tlist = myrpt->tele.next;
      unkeys_queued = 0;
                if (tlist != &myrpt->tele)
                {
                        rpt_mutex_lock(&myrpt->lock);
                        while(tlist != &myrpt->tele){
                                if (tlist->mode == LINKUNKEY) unkeys_queued++;
                                tlist = tlist->next;
                        }
                        rpt_mutex_unlock(&myrpt->lock);
      }
      if( unkeys_queued > 1){
         imdone = 1;
         break;
      }

      /* Wait for the telemetry timer to expire */
      /* Periodically check the timer since it can be re-initialized above */
      while(mytele->mylink.linkunkeytocttimer)
      {
         int ctint;
         if(mytele->mylink.linkunkeytocttimer > 100)
            ctint = 100;
         else
            ctint = mytele->mylink.linkunkeytocttimer;
         ast_safe_sleep(mychannel, ctint);
         rpt_mutex_lock(&myrpt->lock);
         if(mytele->mylink.linkunkeytocttimer < ctint)
            mytele->mylink.linkunkeytocttimer = 0;
         else
            mytele->mylink.linkunkeytocttimer -= ctint;
         rpt_mutex_unlock(&myrpt->lock);
      }
   
      if((ct = (char *) ast_variable_retrieve(myrpt->cfg, nodename, "linkunkeyct"))){ /* Unlinked Courtesy Tone */
         ct_copy = ast_strdup(ct);
         if(ct_copy){
            res = telem_lookup(myrpt,mychannel, myrpt->name, ct_copy);
            ast_free(ct_copy);
         }
         else
            res = -1;
         if(res)
            ast_log(LOG_WARNING, "telem_lookup:ctx failed on %s\n", mychannel->name);     
      }  
      imdone = 1;
      break;
       case REMDISC:
      /* wait a little bit */
      wait_interval(myrpt, DLY_TELEM, mychannel);
      l = myrpt->links.next;
      haslink = 0;
      /* dont report if a link for this one still on system */
      if (l != &myrpt->links)
      {
         rpt_mutex_lock(&myrpt->lock);
         while(l != &myrpt->links)
         {
            if (l->name[0] == '0')
            {
               l = l->next;
               continue;
            }
            if (!strcmp(l->name,mytele->mylink.name))
            {
               haslink = 1;
               break;
            }
            l = l->next;
         }
         rpt_mutex_unlock(&myrpt->lock);
      }
      if (haslink)
      {
         imdone = 1;
         break;
      }
      res = saynode(myrpt,mychannel,mytele->mylink.name);
      if (!res) 
          res = ast_streamfile(mychannel, ((mytele->mylink.hasconnected) ? 
         "rpt/remote_disc" : "rpt/remote_busy"), mychannel->language);
      break;
       case REMALREADY:
      /* wait a little bit */
      wait_interval(myrpt, DLY_TELEM, mychannel);
      res = ast_streamfile(mychannel, "rpt/remote_already", mychannel->language);
      break;
       case REMNOTFOUND:
      /* wait a little bit */
      wait_interval(myrpt, DLY_TELEM, mychannel);
      res = ast_streamfile(mychannel, "rpt/remote_notfound", mychannel->language);
      break;
       case REMGO:
      /* wait a little bit */
      wait_interval(myrpt, DLY_TELEM, mychannel);
      res = ast_streamfile(mychannel, "rpt/remote_go", mychannel->language);
      break;
       case CONNECTED:
      /* wait a little bit */
      wait_interval(myrpt, DLY_TELEM,  mychannel);
      res = saynode(myrpt,mychannel,mytele->mylink.name);
      if (!res)
          res = ast_streamfile(mychannel, "rpt/connected", mychannel->language);
      if (!res) 
         res = ast_waitstream(mychannel, "");
      else
          ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
      ast_stopstream(mychannel);
      res = ast_streamfile(mychannel, "digits/2", mychannel->language);
      if (!res) 
         res = ast_waitstream(mychannel, "");
      else
          ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
      ast_stopstream(mychannel);
      res = saynode(myrpt,mychannel,myrpt->name);
      imdone = 1;
      break;
       case CONNFAIL:
      res = saynode(myrpt,mychannel,mytele->mylink.name);
      if (!res) 
          res = ast_streamfile(mychannel, "rpt/connection_failed", mychannel->language);
      break;
       case MEMNOTFOUND:
      /* wait a little bit */
      wait_interval(myrpt, DLY_TELEM, mychannel);
      res = ast_streamfile(mychannel, "rpt/memory_notfound", mychannel->language);
      break;
       case PLAYBACK:
      /* wait a little bit */
      wait_interval(myrpt, DLY_TELEM, mychannel);
      res = ast_streamfile(mychannel, mytele->param, mychannel->language);
      break;
       case TOPKEY:
      /* wait a little bit */
      wait_interval(myrpt, DLY_TELEM, mychannel);
      for(i = 0; i < TOPKEYN; i++)
      {
         if (!myrpt->topkey[i].node[0]) continue;
         if ((!myrpt->topkeylong) && (myrpt->topkey[i].keyed)) continue;
         res = saynode(myrpt, mychannel,  myrpt->topkey[i].node);
         if (!res) res = sayfile(mychannel,(myrpt->topkey[i].keyed) ?
            "rpt/keyedfor" : "rpt/unkeyedfor");
         if (!res) res = saynum(mychannel,
            myrpt->topkey[i].timesince);
         if (!res) res = sayfile(mychannel,"rpt/seconds");
         if (!myrpt->topkeylong) break;
      }
      imdone = 1;
      break;
       case SETREMOTE:
      ast_mutex_lock(&myrpt->remlock);
      res = 0;
      if(!strcmp(myrpt->remoterig, remote_rig_ft897))
      {
         res = set_ft897(myrpt);
      }
      else if(!strcmp(myrpt->remoterig, remote_rig_tm271))
      {
         res = set_tm271(myrpt);
      }
      else if(!strcmp(myrpt->remoterig, remote_rig_ic706))
      {
         res = set_ic706(myrpt);
      }
#ifdef HAVE_IOPERM
      else if(!strcmp(myrpt->remoterig, remote_rig_rbi)||!strcmp(myrpt->remoterig, remote_rig_ppp16))
      {
         if (ioperm(myrpt->p.iobase,1,1) == -1)
         {
            rpt_mutex_unlock(&myrpt->lock);
            ast_log(LOG_WARNING, "Cant get io permission on IO port %x hex\n",myrpt->p.iobase);
            res = -1;
         }
         else res = setrbi(myrpt);
      }
#endif
      else if(!strcmp(myrpt->remoterig, remote_rig_kenwood))
      {
         if (myrpt->iofd >= 0) setdtr(myrpt->iofd,1);
         res = setkenwood(myrpt);
         if (myrpt->iofd >= 0) setdtr(myrpt->iofd,0);
         if (ast_safe_sleep(mychannel,200) == -1)
         {
            ast_mutex_unlock(&myrpt->remlock);
            res = -1;
            break;
         }
         if (myrpt->iofd < 0)
         {
            i = DAHDI_FLUSH_EVENT;
            if (ioctl(myrpt->dahditxchannel->fds[0],DAHDI_FLUSH,&i) == -1)
            {
               ast_mutex_unlock(&myrpt->remlock);
               ast_log(LOG_ERROR,"Cant flush events");
               res = -1;
               break;
            }
            if (ioctl(myrpt->dahdirxchannel->fds[0],DAHDI_GET_PARAMS,&par) == -1)
            {
               ast_mutex_unlock(&myrpt->remlock);
               ast_log(LOG_ERROR,"Cant get params");
               res = -1;
               break;
            }
            myrpt->remoterx = 
               (par.rxisoffhook || (myrpt->tele.next != &myrpt->tele));
         }
      }

      ast_mutex_unlock(&myrpt->remlock);
      if (!res)
      {
         imdone = 1;
         break;
      }
      /* fall thru to invalid freq */
       case INVFREQ:
      /* wait a little bit */
      wait_interval(myrpt, DLY_TELEM, mychannel);
      res = ast_streamfile(mychannel, "rpt/invalid-freq", mychannel->language);
      break;
       case REMMODE:
      cp = 0;
      wait_interval(myrpt, DLY_TELEM, mychannel);
      switch(myrpt->remmode)
      {
          case REM_MODE_FM:
         saycharstr(mychannel,"FM");
         break;
          case REM_MODE_USB:
         saycharstr(mychannel,"USB");
         break;
          case REM_MODE_LSB:
         saycharstr(mychannel,"LSB");
         break;
          case REM_MODE_AM:
         saycharstr(mychannel,"AM");
         break;
      }
      wait_interval(myrpt, DLY_COMP, mychannel);
      if (!res) res = telem_lookup(myrpt,mychannel, myrpt->name, "functcomplete");
      break;
       case LOGINREQ:
      wait_interval(myrpt, DLY_TELEM, mychannel);
      sayfile(mychannel,"rpt/login");
      saycharstr(mychannel,myrpt->name);
      break;
       case REMLOGIN:
      wait_interval(myrpt, DLY_TELEM, mychannel);
      saycharstr(mychannel,myrpt->loginuser);
      saynode(myrpt,mychannel,myrpt->name);
      wait_interval(myrpt, DLY_COMP, mychannel);
      if (!res) res = telem_lookup(myrpt,mychannel, myrpt->name, "functcomplete");
      break;
       case REMXXX:
      wait_interval(myrpt, DLY_TELEM, mychannel);
      res = 0;
      switch(mytele->submode)
      {
          case 100: /* RX PL Off */
         sayfile(mychannel, "rpt/rxpl");
         sayfile(mychannel, "rpt/off");
         break;
          case 101: /* RX PL On */
         sayfile(mychannel, "rpt/rxpl");
         sayfile(mychannel, "rpt/on");
         break;
          case 102: /* TX PL Off */
         sayfile(mychannel, "rpt/txpl");
         sayfile(mychannel, "rpt/off");
         break;
          case 103: /* TX PL On */
         sayfile(mychannel, "rpt/txpl");
         sayfile(mychannel, "rpt/on");
         break;
          case 104: /* Low Power */
         sayfile(mychannel, "rpt/lopwr");
         break;
          case 105: /* Medium Power */
         sayfile(mychannel, "rpt/medpwr");
         break;
          case 106: /* Hi Power */
         sayfile(mychannel, "rpt/hipwr");
         break;
          case 113: /* Scan down slow */
         sayfile(mychannel,"rpt/down");
         sayfile(mychannel, "rpt/slow");
         break;
          case 114: /* Scan down quick */
         sayfile(mychannel,"rpt/down");
         sayfile(mychannel, "rpt/quick");
         break;
          case 115: /* Scan down fast */
         sayfile(mychannel,"rpt/down");
         sayfile(mychannel, "rpt/fast");
         break;
          case 116: /* Scan up slow */
         sayfile(mychannel,"rpt/up");
         sayfile(mychannel, "rpt/slow");
         break;
          case 117: /* Scan up quick */
         sayfile(mychannel,"rpt/up");
         sayfile(mychannel, "rpt/quick");
         break;
          case 118: /* Scan up fast */
         sayfile(mychannel,"rpt/up");
         sayfile(mychannel, "rpt/fast");
         break;
          default:
         res = -1;
      }
      wait_interval(myrpt, DLY_COMP, mychannel);
      if (!res) res = telem_lookup(myrpt,mychannel, myrpt->name, "functcomplete");
      break;
       case SCAN:
      ast_mutex_lock(&myrpt->remlock);
      if (myrpt->hfscanstop)
      {
         myrpt->hfscanstatus = 0;
         myrpt->hfscanmode = 0;
         myrpt->hfscanstop = 0;
         mytele->mode = SCANSTAT;
         ast_mutex_unlock(&myrpt->remlock);
         if (ast_safe_sleep(mychannel,1000) == -1) break;
         sayfile(mychannel, "rpt/stop"); 
         imdone = 1;
         break;
      }
      if (myrpt->hfscanstatus > -2) service_scan(myrpt);
      i = myrpt->hfscanstatus;
      myrpt->hfscanstatus = 0;
      if (i) mytele->mode = SCANSTAT;
      ast_mutex_unlock(&myrpt->remlock);
      if (i < 0) sayfile(mychannel, "rpt/stop"); 
      else if (i > 0) saynum(mychannel,i);
      imdone = 1;
      break;
       case TUNE:
      ast_mutex_lock(&myrpt->remlock);
      if (!strcmp(myrpt->remoterig,remote_rig_ic706))
      {
         set_mode_ic706(myrpt, REM_MODE_AM);
         if(play_tone(mychannel, 800, 6000, 8192) == -1) break;
         ast_safe_sleep(mychannel,500);
         set_mode_ic706(myrpt, myrpt->remmode);
         myrpt->tunerequest = 0;
         ast_mutex_unlock(&myrpt->remlock);
         imdone = 1;
         break;
      }
      set_mode_ft897(myrpt, REM_MODE_AM);
      simple_command_ft897(myrpt, 8);
      if(play_tone(mychannel, 800, 6000, 8192) == -1) break;
      simple_command_ft897(myrpt, 0x88);
      ast_safe_sleep(mychannel,500);
      set_mode_ft897(myrpt, myrpt->remmode);
      myrpt->tunerequest = 0;
      ast_mutex_unlock(&myrpt->remlock);
      imdone = 1;
      break;
       case REMSHORTSTATUS:
       case REMLONGSTATUS: 
      wait_interval(myrpt, DLY_TELEM, mychannel);
      res = saynode(myrpt,mychannel,myrpt->name);
      if(!res)
         res = sayfile(mychannel,"rpt/frequency");
      if(!res)
         res = split_freq(mhz, decimals, myrpt->freq);
      if (!multimode_capable(myrpt)) decimals[3] = 0;
      if(!res){
         m = atoi(mhz);
         if(m < 100)
            res = saynum(mychannel, m);
         else
            res = saycharstr(mychannel, mhz);
      }
      if(!res)
         res = sayfile(mychannel, "letters/dot");
      if(!res)
         res = saycharstr(mychannel, decimals);
   
      if(res)  break;
      if(myrpt->remmode == REM_MODE_FM){ /* Mode FM? */
         switch(myrpt->offset){
   
            case REM_MINUS:
               res = sayfile(mychannel,"rpt/minus");
               break;
            
            case REM_SIMPLEX:
               res = sayfile(mychannel,"rpt/simplex");
               break;
               
            case REM_PLUS:
               res = sayfile(mychannel,"rpt/plus");
               break;
               
            default:
               break;
         }
      }
      else{ /* Must be USB, LSB, or AM */
         switch(myrpt->remmode){

            case REM_MODE_USB:
               res = saycharstr(mychannel, "USB");
               break;

            case REM_MODE_LSB:
               res = saycharstr(mychannel, "LSB");
               break;

            case REM_MODE_AM:
               res = saycharstr(mychannel, "AM");
               break;


            default:
               break;
         }
      }

      if (res == -1) break;

      if(mytele->mode == REMSHORTSTATUS){ /* Short status? */
         wait_interval(myrpt, DLY_COMP, mychannel);
         if (!res) res = telem_lookup(myrpt,mychannel, myrpt->name, "functcomplete");
         break;
      }

      if (strcmp(myrpt->remoterig,remote_rig_ic706))
      {
         switch(myrpt->powerlevel){

            case REM_LOWPWR:
               res = sayfile(mychannel,"rpt/lopwr") ;
               break;
            case REM_MEDPWR:
               res = sayfile(mychannel,"rpt/medpwr");
               break;
            case REM_HIPWR:
               res = sayfile(mychannel,"rpt/hipwr"); 
               break;
            }
      }

      rbimode = ((!strncmp(myrpt->remoterig,remote_rig_rbi,3))
        || (!strncmp(myrpt->remoterig,remote_rig_ic706,3)));
      if (res || (sayfile(mychannel,"rpt/rxpl") == -1)) break;
      if (rbimode && (sayfile(mychannel,"rpt/txpl") == -1)) break;
      if ((sayfile(mychannel,"rpt/frequency") == -1) ||
         (saycharstr(mychannel,myrpt->rxpl) == -1)) break;
      if ((!rbimode) && ((sayfile(mychannel,"rpt/txpl") == -1) ||
         (sayfile(mychannel,"rpt/frequency") == -1) ||
         (saycharstr(mychannel,myrpt->txpl) == -1))) break;
      if(myrpt->remmode == REM_MODE_FM){ /* Mode FM? */
         if ((sayfile(mychannel,"rpt/rxpl") == -1) ||
            (sayfile(mychannel,((myrpt->rxplon) ? "rpt/on" : "rpt/off")) == -1) ||
            (sayfile(mychannel,"rpt/txpl") == -1) ||
            (sayfile(mychannel,((myrpt->txplon) ? "rpt/on" : "rpt/off")) == -1))
            {
               break;
            }
      }
      wait_interval(myrpt, DLY_COMP, mychannel);
      if (!res) res = telem_lookup(myrpt,mychannel, myrpt->name, "functcomplete");
      break;
       case STATUS:
      /* wait a little bit */
      wait_interval(myrpt, DLY_TELEM, mychannel);
      hastx = 0;
      linkbase.next = &linkbase;
      linkbase.prev = &linkbase;
      rpt_mutex_lock(&myrpt->lock);
      /* make our own list of links */
      l = myrpt->links.next;
      while(l != &myrpt->links)
      {
         if (l->name[0] == '0')
         {
            l = l->next;
            continue;
         }
         l1 = ast_malloc(sizeof(struct rpt_link));
         if (!l1)
         {
            ast_log(LOG_WARNING, "Cannot alloc memory on %s\n", mychannel->name);
            remque((struct qelem *)mytele);
            myrpt->active_telem = NULL;
            rpt_mutex_unlock(&myrpt->lock);
            ast_log(LOG_NOTICE,"Telemetry thread aborted at line %d, mode: %d\n",__LINE__, mytele->mode); /*@@@@@@@@@@@*/
            ast_free(nodename);
            ast_free(ident);
            ast_free(mytele);    
            ast_hangup(mychannel);
            pthread_exit(NULL);
         }
         memcpy(l1,l,sizeof(struct rpt_link));
         l1->next = l1->prev = NULL;
         insque((struct qelem *)l1,(struct qelem *)linkbase.next);
         l = l->next;
      }
      rpt_mutex_unlock(&myrpt->lock);
      res = saynode(myrpt,mychannel,myrpt->name);
      if (myrpt->callmode)
      {
         hastx = 1;
         res = ast_streamfile(mychannel, "rpt/autopatch_on", mychannel->language);
         if (!res) 
            res = ast_waitstream(mychannel, "");
         else
             ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
         ast_stopstream(mychannel);
      }
      l = linkbase.next;
      while(l != &linkbase)
      {
         char *s;

         hastx = 1;
         res = saynode(myrpt,mychannel,l->name);
         s = "rpt/tranceive";
         if (!l->mode) s = "rpt/monitor";
         if (!l->thisconnected) s = "rpt/connecting";
         res = ast_streamfile(mychannel, s, mychannel->language);
         if (!res) 
            res = ast_waitstream(mychannel, "");
         else
            ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
         ast_stopstream(mychannel);
         l = l->next;
      }        
      if (!hastx)
      {
         res = ast_streamfile(mychannel, "rpt/repeat_only", mychannel->language);
         if (!res) 
            res = ast_waitstream(mychannel, "");
         else
             ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
         ast_stopstream(mychannel);
      }
      /* destroy our local link queue */
      l = linkbase.next;
      while(l != &linkbase)
      {
         l1 = l;
         l = l->next;
         remque((struct qelem *)l1);
         ast_free(l1);
      }        
      imdone = 1;
      break;
       case FULLSTATUS:
      rpt_mutex_lock(&myrpt->lock);
      /* get all the nodes */
      __mklinklist(myrpt,NULL,lbuf);
      rpt_mutex_unlock(&myrpt->lock);
      /* parse em */
      ns = finddelim(lbuf,strs,MAXLINKLIST);
      /* sort em */
      if (ns) qsort((void *)strs,ns,sizeof(char *),mycompar);
      /* wait a little bit */
      wait_interval(myrpt, DLY_TELEM, mychannel);
      hastx = 0;
      res = saynode(myrpt,mychannel,myrpt->name);
      if (myrpt->callmode)
      {
         hastx = 1;
         res = ast_streamfile(mychannel, "rpt/autopatch_on", mychannel->language);
         if (!res) 
            res = ast_waitstream(mychannel, "");
         else
             ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
         ast_stopstream(mychannel);
      }
      /* go thru all the nodes in list */
      for(i = 0; i < ns; i++)
      {
         char *s,mode = 'T';

         /* if a mode spec at first, handle it */
         if ((*strs[i] < '0') || (*strs[i] > '9'))
         {
            mode = *strs[i];
            strs[i]++;
         }

         hastx = 1;
         res = saynode(myrpt,mychannel,strs[i]);
         s = "rpt/tranceive";
         if (mode == 'R') s = "rpt/monitor";
         if (mode == 'C') s = "rpt/connecting";
         res = ast_streamfile(mychannel, s, mychannel->language);
         if (!res) 
            res = ast_waitstream(mychannel, "");
         else
            ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
         ast_stopstream(mychannel);
      }        
      if (!hastx)
      {
         res = ast_streamfile(mychannel, "rpt/repeat_only", mychannel->language);
         if (!res) 
            res = ast_waitstream(mychannel, "");
         else
             ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
         ast_stopstream(mychannel);
      }
      imdone = 1;
      break;

       case LASTNODEKEY: /* Identify last node which keyed us up */
      rpt_mutex_lock(&myrpt->lock);
      if(myrpt->lastnodewhichkeyedusup){
         p = ast_strdup(myrpt->lastnodewhichkeyedusup); /* Make a local copy of the node name */
         if(!p){
            ast_log(LOG_WARNING, "ast_strdup failed in telemetery LASTNODEKEY");
            imdone = 1;
            break;
         }
      }
      else
         p = NULL;
      rpt_mutex_unlock(&myrpt->lock);
      if(!p){
         imdone = 1; /* no node previously keyed us up, or the node which did has been disconnected */
         break;
      }
      wait_interval(myrpt, DLY_TELEM, mychannel);
      res = saynode(myrpt,mychannel,p);
      ast_free(p);
      imdone = 1;
      break;      

       case UNAUTHTX: /* Say unauthorized transmit frequency */
      wait_interval(myrpt, DLY_TELEM, mychannel);
      res = ast_streamfile(mychannel, "rpt/unauthtx", mychannel->language);
      if (!res) 
         res = ast_waitstream(mychannel, "");
      else
          ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
      ast_stopstream(mychannel);
      imdone = 1;
      break;

       case PARROT: /* Repeat stuff */

      sprintf(mystr,PARROTFILE,myrpt->name,(unsigned int)mytele->parrot);
      if (ast_fileexists(mystr,NULL,mychannel->language) <= 0)
      {
         imdone = 1;
         myrpt->parrotstate = 0;
         break;
      }
      wait_interval(myrpt, DLY_PARROT, mychannel);
      sprintf(mystr,PARROTFILE,myrpt->name,(unsigned int)mytele->parrot);
      res = ast_streamfile(mychannel, mystr, mychannel->language);
      if (!res) 
         res = ast_waitstream(mychannel, "");
      else
          ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
      ast_stopstream(mychannel);
      sprintf(mystr,PARROTFILE,myrpt->name,(unsigned int)mytele->parrot);
      strcat(mystr,".wav");
      unlink(mystr);       
      imdone = 1;
      myrpt->parrotstate = 0;
      break;

       case TIMEOUT:
      res = saynode(myrpt,mychannel,myrpt->name);
      if (!res)
         res = ast_streamfile(mychannel, "rpt/timeout", mychannel->language);
      break;
      
       case TIMEOUT_WARNING:
      time(&t);
      res = saynode(myrpt,mychannel,myrpt->name);
      if (!res)
         res = ast_streamfile(mychannel, "rpt/timeout-warning", mychannel->language);
      if (!res) 
         res = ast_waitstream(mychannel, "");
      else
          ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
      ast_stopstream(mychannel);
      if(!res) /* Say number of seconds */
         ast_say_number(mychannel, myrpt->p.remotetimeout - 
             (t - myrpt->last_activity_time), 
            "", mychannel->language, (char *) NULL);
      if (!res) 
         res = ast_waitstream(mychannel, "");
      ast_stopstream(mychannel); 
      res = ast_streamfile(mychannel, "queue-seconds", mychannel->language);
      break;

       case ACT_TIMEOUT_WARNING:
      time(&t);
      res = saynode(myrpt,mychannel,myrpt->name);
      if (!res)
          res = ast_streamfile(mychannel, "rpt/act-timeout-warning", mychannel->language);
      if (!res) 
         res = ast_waitstream(mychannel, "");
      else
          ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
      ast_stopstream(mychannel);
      if(!res) /* Say number of seconds */
         ast_say_number(mychannel, myrpt->p.remoteinacttimeout - 
             (t - myrpt->last_activity_time), 
            "", mychannel->language, (char *) NULL);
      if (!res) 
         res = ast_waitstream(mychannel, "");
      ast_stopstream(mychannel); 
      res = ast_streamfile(mychannel, "queue-seconds", mychannel->language);
      break;
      
       case STATS_TIME:
            case STATS_TIME_LOCAL:
         wait_interval(myrpt, DLY_TELEM, mychannel); /* Wait a little bit */
      t = time(NULL);
      rpt_localtime(&t, &localtm);
      /* Say the phase of the day is before the time */
      if((localtm.tm_hour >= 0) && (localtm.tm_hour < 12))
         p = "rpt/goodmorning";
      else if((localtm.tm_hour >= 12) && (localtm.tm_hour < 18))
         p = "rpt/goodafternoon";
      else
         p = "rpt/goodevening";
      if (sayfile(mychannel,p) == -1)
      {
         imdone = 1;
         break;
      }
      /* Say the time is ... */     
      if (sayfile(mychannel,"rpt/thetimeis") == -1)
      {
         imdone = 1;
         break;
      }
      /* Say the time */            
         res = ast_say_time(mychannel, t, "", mychannel->language);
      if (!res) 
         res = ast_waitstream(mychannel, "");
      ast_stopstream(mychannel);    
      imdone = 1;
         break;
       case STATS_VERSION:
      p = strstr(tdesc, "version"); 
      if(!p)
         break;   
      if(sscanf(p, "version %30d.%30d", &vmajor, &vminor) != 2)
         break;
         wait_interval(myrpt, DLY_TELEM, mychannel); /* Wait a little bit */
      /* Say "version" */
      if (sayfile(mychannel,"rpt/version") == -1)
      {
         imdone = 1;
         break;
      }
      if(!res) /* Say "X" */
         ast_say_number(mychannel, vmajor, "", mychannel->language, (char *) NULL);
      if (!res) 
         res = ast_waitstream(mychannel, "");
      ast_stopstream(mychannel); 
      if (saycharstr(mychannel,".") == -1)
      {
         imdone = 1;
         break;
      }
      if(!res) /* Say "Y" */
         ast_say_number(mychannel, vminor, "", mychannel->language, (char *) NULL);
      if (!res){
         res = ast_waitstream(mychannel, "");
         ast_stopstream(mychannel);
      }  
      else
          ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
      imdone = 1;
         break;
       case ARB_ALPHA:
         wait_interval(myrpt, DLY_TELEM, mychannel); /* Wait a little bit */
         if(mytele->param)
            saycharstr(mychannel, mytele->param);
         imdone = 1;
      break;
       case REV_PATCH:
         wait_interval(myrpt, DLY_TELEM, mychannel); /* Wait a little bit */
         if(mytele->param) {

         /* Parts of this section taken from app_parkandannounce */
         char *tpl_working, *tpl_current;
         char *tmp[100], *myparm;
         int looptemp=0,idx=0, dres = 0;
   

         tpl_working = ast_strdup(mytele->param);
         myparm = strsep(&tpl_working,",");
         tpl_current=strsep(&tpl_working, ":");

         while(tpl_current && looptemp < sizeof(tmp)) {
            tmp[looptemp]=tpl_current;
            looptemp++;
            tpl_current=strsep(&tpl_working,":");
         }

         for(idx=0; idx<looptemp; idx++) {
            if(!strcmp(tmp[idx], "PARKED")) {
               ast_say_digits(mychannel, atoi(myparm), "", mychannel->language);
            } else if(!strcmp(tmp[idx], "NODE")) {
               ast_say_digits(mychannel, atoi(myrpt->name), "", mychannel->language);
            } else {
               dres = ast_streamfile(mychannel, tmp[idx], mychannel->language);
               if(!dres) {
                  dres = ast_waitstream(mychannel, "");
               } else {
                  ast_log(LOG_WARNING, "ast_streamfile of %s failed on %s\n", tmp[idx], mychannel->name);
                  dres = 0;
               }
            }
         }
         ast_free(tpl_working);
      }
         imdone = 1;
      break;
       case TEST_TONE:
      imdone = 1;
      if (myrpt->stopgen) break;
      myrpt->stopgen = -1;
           if ((res = ast_tonepair_start(mychannel, 1004.0, 0, 99999999, 7200.0))) 
      {
         myrpt->stopgen = 0;
         break;
      }
           while(mychannel->generatordata && (myrpt->stopgen <= 0)) {
         if (ast_safe_sleep(mychannel,1)) break;
            imdone = 1;
         }
      myrpt->stopgen = 0;
      break;
       default:
         break;
   }
   if (!imdone)
   {
      if (!res) 
         res = ast_waitstream(mychannel, "");
      else {
         ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
         res = 0;
      }
   }
   ast_stopstream(mychannel);
   rpt_mutex_lock(&myrpt->lock);
   if (mytele->mode == TAILMSG)
   {
      if (!res)
      {
         myrpt->tailmessagen++;
         if(myrpt->tailmessagen >= myrpt->p.tailmessagemax) myrpt->tailmessagen = 0;
      }
      else
      {
         myrpt->tmsgtimer = myrpt->p.tailsquashedtime;
      }
   }
   remque((struct qelem *)mytele);
   myrpt->active_telem = NULL;
   rpt_mutex_unlock(&myrpt->lock);
   ast_free(nodename);
   ast_free(ident);
   ast_free(mytele);    
   ast_hangup(mychannel);
#ifdef  APP_RPT_LOCK_DEBUG
   {
      struct lockthread *t;

      sleep(5);
      ast_mutex_lock(&locklock);
      t = get_lockthread(pthread_self());
      if (t) memset(t,0,sizeof(struct lockthread));
      ast_mutex_unlock(&locklock);
   }        
#endif
   pthread_exit(NULL);
}

static void rpt_telemetry(struct rpt *myrpt,int mode, void *data)
{
struct rpt_tele *tele;
struct rpt_link *mylink = NULL;
int res;
pthread_attr_t attr;
char *v1, *v2;

   if(debug > 6)
      ast_log(LOG_NOTICE,"mode=%i  data=%s\n",mode, (char *)data);

   switch(mode)
   {
       case UNKEY:
      /* if any of the following are defined, go ahead and do it,
         otherwise, dont bother */
      v1 = (char *) ast_variable_retrieve(myrpt->cfg, myrpt->name, 
         "unlinkedct");
      v2 = (char *) ast_variable_retrieve(myrpt->cfg, myrpt->name, 
         "remotect");
      if (telem_lookup(myrpt,NULL, myrpt->name, "remotemon") &&
        telem_lookup(myrpt,NULL, myrpt->name, "remotetx") &&
        telem_lookup(myrpt,NULL, myrpt->name, "cmdmode") &&
        (!(v1 && telem_lookup(myrpt,NULL, myrpt->name, v1))) && 
        (!(v2 && telem_lookup(myrpt,NULL, myrpt->name, v2)))) return;
      break;
       case LINKUNKEY:
      if (!ast_variable_retrieve(myrpt->cfg, myrpt->name, "linkunkeyct"))
         return;
      break;
       default:
      break;
   }
   tele = ast_malloc(sizeof(struct rpt_tele));
   if (!tele)
   {
      ast_log(LOG_WARNING, "Unable to allocate memory\n");
      pthread_exit(NULL);
      return;
   }
   /* zero it out */
   memset((char *)tele,0,sizeof(struct rpt_tele));
   tele->rpt = myrpt;
   tele->mode = mode;
   if (mode == PARROT) tele->parrot = (uintptr_t) data;
   else mylink = (struct rpt_link *) data;
   rpt_mutex_lock(&myrpt->lock);
   if((mode == CONNFAIL) || (mode == REMDISC) || (mode == CONNECTED) ||
       (mode == LINKUNKEY)){
      memset(&tele->mylink,0,sizeof(struct rpt_link));
      if (mylink){
         memcpy(&tele->mylink,mylink,sizeof(struct rpt_link));
      }
   }
   else if ((mode == ARB_ALPHA) || (mode == REV_PATCH) || (mode == PLAYBACK)) {
      strncpy(tele->param, (char *) data, TELEPARAMSIZE - 1);
      tele->param[TELEPARAMSIZE - 1] = 0;
   }
   if (mode == REMXXX) tele->submode = (intptr_t) data;
   insque((struct qelem *)tele, (struct qelem *)myrpt->tele.next);
   rpt_mutex_unlock(&myrpt->lock);
        pthread_attr_init(&attr);
        pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
   res = ast_pthread_create(&tele->threadid,&attr,rpt_tele_thread,(void *) tele);
   if(res < 0){
      rpt_mutex_lock(&myrpt->lock);
      remque((struct qlem *) tele); /* We don't like stuck transmitters, remove it from the queue */
      rpt_mutex_unlock(&myrpt->lock);  
      ast_log(LOG_WARNING, "Could not create telemetry thread: %s",strerror(res));
   }
   return;
}

static void *rpt_call(void *this)
{
struct dahdi_confinfo ci;  /* conference info */
struct   rpt *myrpt = (struct rpt *)this;
int   res;
int stopped,congstarted,dialtimer,lastcidx,aborted;
struct ast_channel *mychannel,*genchannel;

   myrpt->mydtmf = 0;
   /* allocate a pseudo-channel thru asterisk */
   mychannel = ast_request("DAHDI",AST_FORMAT_SLINEAR,"pseudo",NULL);
   if (!mychannel)
   {
      fprintf(stderr,"rpt:Sorry unable to obtain pseudo channel\n");
      pthread_exit(NULL);
   }
#ifdef   AST_CDR_FLAG_POST_DISABLED
   if (mychannel->cdr)
      ast_set_flag(mychannel->cdr,AST_CDR_FLAG_POST_DISABLED);
#endif
   ci.chan = 0;
   ci.confno = myrpt->conf; /* use the pseudo conference */
#if   0
   ci.confmode = DAHDI_CONF_REALANDPSEUDO | DAHDI_CONF_TALKER | DAHDI_CONF_LISTENER
      | DAHDI_CONF_PSEUDO_TALKER | DAHDI_CONF_PSEUDO_LISTENER; 
#endif
   ci.confmode = DAHDI_CONF_CONF | DAHDI_CONF_TALKER | DAHDI_CONF_LISTENER;
   /* first put the channel on the conference */
   if (ioctl(mychannel->fds[0],DAHDI_SETCONF,&ci) == -1)
   {
      ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
      ast_hangup(mychannel);
      myrpt->callmode = 0;
      pthread_exit(NULL);
   }
   /* allocate a pseudo-channel thru asterisk */
   genchannel = ast_request("DAHDI",AST_FORMAT_SLINEAR,"pseudo",NULL);
   if (!genchannel)
   {
      fprintf(stderr,"rpt:Sorry unable to obtain pseudo channel\n");
      ast_hangup(mychannel);
      pthread_exit(NULL);
   }
#ifdef   AST_CDR_FLAG_POST_DISABLED
   if (genchannel->cdr)
      ast_set_flag(genchannel->cdr,AST_CDR_FLAG_POST_DISABLED);
#endif
   ci.chan = 0;
   ci.confno = myrpt->conf;
   ci.confmode = DAHDI_CONF_REALANDPSEUDO | DAHDI_CONF_TALKER | DAHDI_CONF_LISTENER
      | DAHDI_CONF_PSEUDO_TALKER | DAHDI_CONF_PSEUDO_LISTENER; 
   /* first put the channel on the conference */
   if (ioctl(genchannel->fds[0],DAHDI_SETCONF,&ci) == -1)
   {
      ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
      ast_hangup(mychannel);
      ast_hangup(genchannel);
      myrpt->callmode = 0;
      pthread_exit(NULL);
   }
   if (myrpt->p.tonezone && (tone_zone_set_zone(mychannel->fds[0],myrpt->p.tonezone) == -1))
   {
      ast_log(LOG_WARNING, "Unable to set tone zone %s\n",myrpt->p.tonezone);
      ast_hangup(mychannel);
      ast_hangup(genchannel);
      myrpt->callmode = 0;
      pthread_exit(NULL);
   }
   if (myrpt->p.tonezone && (tone_zone_set_zone(genchannel->fds[0],myrpt->p.tonezone) == -1))
   {
      ast_log(LOG_WARNING, "Unable to set tone zone %s\n",myrpt->p.tonezone);
      ast_hangup(mychannel);
      ast_hangup(genchannel);
      myrpt->callmode = 0;
      pthread_exit(NULL);
   }
   /* start dialtone if patchquiet is 0. Special patch modes don't send dial tone */
   if ((!myrpt->patchquiet) && (tone_zone_play_tone(genchannel->fds[0],DAHDI_TONE_DIALTONE) < 0))
   {
      ast_log(LOG_WARNING, "Cannot start dialtone\n");
      ast_hangup(mychannel);
      ast_hangup(genchannel);
      myrpt->callmode = 0;
      pthread_exit(NULL);
   }
   stopped = 0;
   congstarted = 0;
   dialtimer = 0;
   lastcidx = 0;
   myrpt->calldigittimer = 0;
   aborted = 0;

   while ((myrpt->callmode == 1) || (myrpt->callmode == 4))
   {
      if((myrpt->patchdialtime)&&(myrpt->callmode == 1)&&(myrpt->cidx != lastcidx)){
         dialtimer = 0;
         lastcidx = myrpt->cidx;
      }     

      if((myrpt->patchdialtime)&&(dialtimer >= myrpt->patchdialtime)){ 
          if(debug)
            ast_log(LOG_NOTICE, "dialtimer %i > patchdialtime %i\n", dialtimer,myrpt->patchdialtime);
         rpt_mutex_lock(&myrpt->lock);
         aborted = 1;
         myrpt->callmode = 0;
         rpt_mutex_unlock(&myrpt->lock);
         break;
      }
   
      if ((!myrpt->patchquiet) && (!stopped) && (myrpt->callmode == 1) && (myrpt->cidx > 0))
      {
         stopped = 1;
         /* stop dial tone */
         tone_zone_play_tone(genchannel->fds[0],-1);
      }
      if (myrpt->callmode == 1)
      {
         if(myrpt->calldigittimer > PATCH_DIALPLAN_TIMEOUT)
         {
            myrpt->callmode = 2;
            break;
         }
         /* bump timer if active */
         if (myrpt->calldigittimer) 
            myrpt->calldigittimer += MSWAIT;
      }
      if (myrpt->callmode == 4)
      {
         if(!congstarted){
            congstarted = 1;
            /* start congestion tone */
            tone_zone_play_tone(genchannel->fds[0],DAHDI_TONE_CONGESTION);
         }
      }
      res = ast_safe_sleep(mychannel, MSWAIT);
      if (res < 0)
      {
          if(debug)
            ast_log(LOG_NOTICE, "ast_safe_sleep=%i\n", res);
         ast_hangup(mychannel);
         ast_hangup(genchannel);
         rpt_mutex_lock(&myrpt->lock);
         myrpt->callmode = 0;
         rpt_mutex_unlock(&myrpt->lock);
         pthread_exit(NULL);
      }
      dialtimer += MSWAIT;
   }
   /* stop any tone generation */
   tone_zone_play_tone(genchannel->fds[0],-1);
   /* end if done */
   if (!myrpt->callmode)
   {
      if(debug)
         ast_log(LOG_NOTICE, "callmode==0\n");
      ast_hangup(mychannel);
      ast_hangup(genchannel);
      rpt_mutex_lock(&myrpt->lock);
      myrpt->callmode = 0;
      myrpt->macropatch=0;
      channel_revert(myrpt);
      rpt_mutex_unlock(&myrpt->lock);
      if((!myrpt->patchquiet) && aborted)
         rpt_telemetry(myrpt, TERM, NULL);
      pthread_exit(NULL);        
   }

   if (myrpt->p.ourcallerid && *myrpt->p.ourcallerid){
      char *name, *loc, *instr;
      instr = ast_strdup(myrpt->p.ourcallerid);
      if(instr){
         ast_callerid_parse(instr, &name, &loc);
         if(loc){
            if(mychannel->cid.cid_num)
               ast_free(mychannel->cid.cid_num);
            mychannel->cid.cid_num = ast_strdup(loc);
         }
         if(name){
            if(mychannel->cid.cid_name)
               ast_free(mychannel->cid.cid_name);
            mychannel->cid.cid_name = ast_strdup(name);
         }
         ast_free(instr);
      }
   }

   ast_copy_string(mychannel->exten, myrpt->exten, sizeof(mychannel->exten) - 1);
   ast_copy_string(mychannel->context, myrpt->patchcontext, sizeof(mychannel->context) - 1);
   
   if (myrpt->p.acctcode)
      ast_cdr_setaccount(mychannel,myrpt->p.acctcode);
   mychannel->priority = 1;
   ast_channel_undefer_dtmf(mychannel);
   if (ast_pbx_start(mychannel) < 0)
   {
      ast_log(LOG_WARNING, "Unable to start PBX!!\n");
      ast_hangup(mychannel);
      ast_hangup(genchannel);
      rpt_mutex_lock(&myrpt->lock);
      myrpt->callmode = 0;
      rpt_mutex_unlock(&myrpt->lock);
      pthread_exit(NULL);
   }
   usleep(10000);
   rpt_mutex_lock(&myrpt->lock);
   myrpt->callmode = 3;
   /* set appropriate conference for the pseudo */
   ci.chan = 0;
   ci.confno = myrpt->conf;
   ci.confmode = (myrpt->p.duplex == 2) ? DAHDI_CONF_CONFANNMON :
      (DAHDI_CONF_CONF | DAHDI_CONF_LISTENER | DAHDI_CONF_TALKER);
   /* first put the channel on the conference in announce mode */
   if (ioctl(myrpt->pchannel->fds[0],DAHDI_SETCONF,&ci) == -1)
   {
      ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
      ast_hangup(mychannel);
      ast_hangup(genchannel);
      myrpt->callmode = 0;
      pthread_exit(NULL);
   }
   /* get its channel number */
   if (ioctl(mychannel->fds[0],DAHDI_CHANNO,&res) == -1)
   {
      ast_log(LOG_WARNING, "Unable to get autopatch channel number\n");
      ast_hangup(mychannel);
      myrpt->callmode = 0;
      pthread_exit(NULL);
   }
   ci.chan = 0;
   ci.confno = res;
   ci.confmode = DAHDI_CONF_MONITOR;
   /* put vox channel monitoring on the channel  */
   if (ioctl(myrpt->voxchannel->fds[0],DAHDI_SETCONF,&ci) == -1)
   {
      ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
      ast_hangup(mychannel);
      myrpt->callmode = 0;
      pthread_exit(NULL);
   }
   while(myrpt->callmode)
   {
      if ((!mychannel->pbx) && (myrpt->callmode != 4))
      {
          /* If patch is setup for far end disconnect */
         if(myrpt->patchfarenddisconnect || (myrpt->p.duplex < 2)){ 
            if(debug)ast_log(LOG_NOTICE,"callmode=%i, patchfarenddisconnect=%i, duplex=%i\n",\
                  myrpt->callmode,myrpt->patchfarenddisconnect,myrpt->p.duplex);
            myrpt->callmode = 0;
            myrpt->macropatch=0;
            if(!myrpt->patchquiet){
               rpt_mutex_unlock(&myrpt->lock);
               rpt_telemetry(myrpt, TERM, NULL);
               rpt_mutex_lock(&myrpt->lock);
            }
         }
         else{ /* Send congestion until patch is downed by command */
            myrpt->callmode = 4;
            rpt_mutex_unlock(&myrpt->lock);
            /* start congestion tone */
            tone_zone_play_tone(genchannel->fds[0],DAHDI_TONE_CONGESTION);
            rpt_mutex_lock(&myrpt->lock);
         }
      }
      if (myrpt->mydtmf)
      {
         struct ast_frame wf = {AST_FRAME_DTMF, } ;
         wf.subclass = myrpt->mydtmf;
         rpt_mutex_unlock(&myrpt->lock);
         ast_queue_frame(mychannel,&wf);
#ifdef   NEW_ASTERISK
         ast_senddigit(genchannel,myrpt->mydtmf,0);
#else
         ast_senddigit(genchannel,myrpt->mydtmf);
#endif
         rpt_mutex_lock(&myrpt->lock);
         myrpt->mydtmf = 0;
      }
      rpt_mutex_unlock(&myrpt->lock);
      usleep(MSWAIT * 1000);
      rpt_mutex_lock(&myrpt->lock);
   }
   if(debug)
      ast_log(LOG_NOTICE, "exit channel loop\n");
   rpt_mutex_unlock(&myrpt->lock);
   tone_zone_play_tone(genchannel->fds[0],-1);
   if (mychannel->pbx) ast_softhangup(mychannel,AST_SOFTHANGUP_DEV);
   ast_hangup(genchannel);
   rpt_mutex_lock(&myrpt->lock);
   myrpt->callmode = 0;
   myrpt->macropatch=0;
   channel_revert(myrpt);
   rpt_mutex_unlock(&myrpt->lock);
   /* set appropriate conference for the pseudo */
   ci.chan = 0;
   ci.confno = myrpt->conf;
   ci.confmode = ((myrpt->p.duplex == 2) || (myrpt->p.duplex == 4)) ? DAHDI_CONF_CONFANNMON :
      (DAHDI_CONF_CONF | DAHDI_CONF_LISTENER | DAHDI_CONF_TALKER);
   /* first put the channel on the conference in announce mode */
   if (ioctl(myrpt->pchannel->fds[0],DAHDI_SETCONF,&ci) == -1)
   {
      ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
   }
   pthread_exit(NULL);
}

static void send_link_dtmf(struct rpt *myrpt,char c)
{
char  str[300];
struct   ast_frame wf;
struct   rpt_link *l;

   snprintf(str, sizeof(str), "D %s %s %d %c", myrpt->cmdnode, myrpt->name, ++(myrpt->dtmfidx), c);
   wf.frametype = AST_FRAME_TEXT;
   wf.subclass = 0;
   wf.offset = 0;
   wf.mallocd = 0;
   wf.datalen = strlen(str) + 1;
   wf.samples = 0;
   l = myrpt->links.next;
   /* first, see if our dude is there */
   while(l != &myrpt->links)
   {
      if (l->name[0] == '0') 
      {
         l = l->next;
         continue;
      }
      /* if we found it, write it and were done */
      if (!strcmp(l->name,myrpt->cmdnode))
      {
         wf.data.ptr = str;
         if (l->chan) ast_write(l->chan,&wf);
         return;
      }
      l = l->next;
   }
   l = myrpt->links.next;
   /* if not, give it to everyone */
   while(l != &myrpt->links)
   {
      wf.data.ptr = str;
      if (l->chan) ast_write(l->chan,&wf);
      l = l->next;
   }
   return;
}

static void send_link_keyquery(struct rpt *myrpt)
{
char  str[300];
struct   ast_frame wf;
struct   rpt_link *l;

   rpt_mutex_lock(&myrpt->lock);
   memset(myrpt->topkey,0,sizeof(myrpt->topkey));
   myrpt->topkeystate = 1;
   time(&myrpt->topkeytime);
   rpt_mutex_unlock(&myrpt->lock);
   snprintf(str, sizeof(str), "K? * %s 0 0", myrpt->name);
   wf.frametype = AST_FRAME_TEXT;
   wf.subclass = 0;
   wf.offset = 0;
   wf.mallocd = 0;
   wf.datalen = strlen(str) + 1;
   wf.samples = 0;
   l = myrpt->links.next;
   /* give it to everyone */
   while(l != &myrpt->links)
   {
      wf.data.ptr = str;
      if (l->chan) ast_write(l->chan,&wf);
      l = l->next;
   }
   return;
}

/* send newkey request */

static void send_newkey(struct ast_channel *chan)
{

   /* ast_safe_sleep(chan,10); */
   ast_sendtext(chan,newkeystr);
   return;
}


/* 
 * Connect a link 
 *
 * Return values:
 * -2: Attempt to connect to self 
 * -1: No such node
 *  0: Success
 *  1: No match yet
 *  2: Already connected to this node
 */

static int connect_link(struct rpt *myrpt, char* node, int mode, int perma)
{
   char *val, *s, *s1, *s2, *tele;
   char lstr[MAXLINKLIST],*strs[MAXLINKLIST];
   char tmp[300], deststr[300] = "",modechange = 0;
   char sx[320],*sy;
   struct rpt_link *l;
   int reconnects = 0;
   int i,n;
   struct dahdi_confinfo ci;  /* conference info */

   val = node_lookup(myrpt,node);
   if (!val){
      if(strlen(node) >= myrpt->longestnode)
         return -1; /* No such node */
      return 1; /* No match yet */
   }

   if(!strcmp(myrpt->name,node)) /* Do not allow connections to self */
      return -2;
      
   if(debug > 3){
      ast_log(LOG_NOTICE,"Connect attempt to node %s\n", node);
      ast_log(LOG_NOTICE,"Mode: %s\n",(mode)?"Transceive":"Monitor");
      ast_log(LOG_NOTICE,"Connection type: %s\n",(perma)?"Permalink":"Normal");
   }

   strncpy(tmp,val,sizeof(tmp) - 1);
   s = tmp;
   s1 = strsep(&s,",");
   if (!strchr(s1,':') && strchr(s1,'/') && strncasecmp(s1, "local/", 6))
   {
      sy = strchr(s1,'/');    
      *sy = 0;
      sprintf(sx,"%s:4569/%s",s1,sy + 1);
      s1 = sx;
   }
   s2 = strsep(&s,",");
   rpt_mutex_lock(&myrpt->lock);
   l = myrpt->links.next;
   /* try to find this one in queue */
   while(l != &myrpt->links){
      if (l->name[0] == '0') 
      {
         l = l->next;
         continue;
      }
   /* if found matching string */
      if (!strcmp(l->name, node))
         break;
      l = l->next;
   }
   /* if found */
   if (l != &myrpt->links){ 
   /* if already in this mode, just ignore */
      if ((l->mode) || (!l->chan)) {
         rpt_mutex_unlock(&myrpt->lock);
         return 2; /* Already linked */
      }
      reconnects = l->reconnects;
      rpt_mutex_unlock(&myrpt->lock);
      if (l->chan) ast_softhangup(l->chan, AST_SOFTHANGUP_DEV);
      l->retries = l->max_retries + 1;
      l->disced = 2;
      modechange = 1;
   } else
   {
      __mklinklist(myrpt,NULL,lstr);
      rpt_mutex_unlock(&myrpt->lock);
      n = finddelim(lstr,strs,MAXLINKLIST);
      for(i = 0; i < n; i++)
      {
         if ((*strs[i] < '0') || 
             (*strs[i] > '9')) strs[i]++;
         if (!strcmp(strs[i],node))
         {
            return 2; /* Already linked */
         }
      }
   }
   strncpy(myrpt->lastlinknode,node,MAXNODESTR - 1);
   /* establish call */
   l = ast_malloc(sizeof(struct rpt_link));
   if (!l)
   {
      ast_log(LOG_WARNING, "Unable to malloc\n");
      return -1;
   }
   /* zero the silly thing */
   memset((char *)l,0,sizeof(struct rpt_link));
   l->mode = mode;
   l->outbound = 1;
   l->thisconnected = 0;
   voxinit_link(l,1);
   strncpy(l->name, node, MAXNODESTR - 1);
   l->isremote = (s && ast_true(s));
   if (modechange) l->connected = 1;
   l->hasconnected = l->perma = perma;
#ifdef ALLOW_LOCAL_CHANNELS
   if ((strncasecmp(s1,"iax2/", 5) == 0) || (strncasecmp(s1, "local/", 6) == 0))
         strncpy(deststr, s1, sizeof(deststr));
   else
           snprintf(deststr, sizeof(deststr), "IAX2/%s", s1);
#else
   snprintf(deststr, sizeof(deststr), "IAX2/%s", s1);
#endif
   tele = strchr(deststr, '/');
   if (!tele){
      ast_log(LOG_WARNING,"link3:Dial number (%s) must be in format tech/number\n",deststr);
      ast_free(l);
      return -1;
   }
   *tele++ = 0;
   l->chan = ast_request(deststr, AST_FORMAT_SLINEAR, tele,NULL);
   if (l->chan){
      ast_set_read_format(l->chan, AST_FORMAT_SLINEAR);
      ast_set_write_format(l->chan, AST_FORMAT_SLINEAR);
#ifdef   AST_CDR_FLAG_POST_DISABLED
      if (l->chan->cdr)
         ast_set_flag(l->chan->cdr,AST_CDR_FLAG_POST_DISABLED);
#endif
#ifndef  NEW_ASTERISK
      l->chan->whentohangup = 0;
#endif
      l->chan->appl = "Apprpt";
      l->chan->data = "(Remote Rx)";
      if (debug > 3)
         ast_log(LOG_NOTICE, "rpt (remote) initiating call to %s/%s on %s\n",
      deststr, tele, l->chan->name);
      if(l->chan->cid.cid_num)
         ast_free(l->chan->cid.cid_num);
      l->chan->cid.cid_num = ast_strdup(myrpt->name);
      ast_call(l->chan,tele,999);
   }
   else {
      if(debug > 3) 
         ast_log(LOG_NOTICE, "Unable to place call to %s/%s on %s\n",
      deststr,tele,l->chan->name);
      if (myrpt->p.archivedir)
      {
         char str[100];
         sprintf(str,"LINKFAIL,%s",l->name);
         donodelog(myrpt,str);
      }
      ast_free(l);
      return -1;
   }
   /* allocate a pseudo-channel thru asterisk */
   l->pchan = ast_request("DAHDI",AST_FORMAT_SLINEAR,"pseudo",NULL);
   if (!l->pchan){
      ast_log(LOG_WARNING,"rpt connect: Sorry unable to obtain pseudo channel\n");
      ast_hangup(l->chan);
      ast_free(l);
      return -1;
   }
   ast_set_read_format(l->pchan, AST_FORMAT_SLINEAR);
   ast_set_write_format(l->pchan, AST_FORMAT_SLINEAR);
#ifdef   AST_CDR_FLAG_POST_DISABLED
   if (l->pchan->cdr)
      ast_set_flag(l->pchan->cdr,AST_CDR_FLAG_POST_DISABLED);
#endif
   /* make a conference for the tx */
   ci.chan = 0;
   ci.confno = myrpt->conf;
   ci.confmode = DAHDI_CONF_CONF | DAHDI_CONF_LISTENER | DAHDI_CONF_TALKER;
   /* first put the channel on the conference in proper mode */
   if (ioctl(l->pchan->fds[0], DAHDI_SETCONF, &ci) == -1)
   {
      ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
      ast_hangup(l->chan);
      ast_hangup(l->pchan);
      ast_free(l);
      return -1;
   }
   rpt_mutex_lock(&myrpt->lock);
   l->reconnects = reconnects;
   /* insert at end of queue */
   l->max_retries = MAX_RETRIES;
   if (perma)
      l->max_retries = MAX_RETRIES_PERM;
   if (l->isremote) l->retries = l->max_retries + 1;
   insque((struct qelem *)l,(struct qelem *)myrpt->links.next);
   __kickshort(myrpt);
   rpt_mutex_unlock(&myrpt->lock);
   if (!l->phonemode) send_newkey(l->chan);
   return 0;
}



/*
* Internet linking function 
*/

static int function_ilink(struct rpt *myrpt, char *param, char *digits, int command_source, struct rpt_link *mylink)
{

   char *val, *s, *s1, *s2;
   char tmp[300];
   char digitbuf[MAXNODESTR],*strs[MAXLINKLIST];
   char mode,perma;
   char sx[320],*sy;
   struct rpt_link *l;
   int i,r;

   if(!param)
      return DC_ERROR;
      
         
   if (myrpt->p.s[myrpt->p.sysstate_cur].txdisable || myrpt->p.s[myrpt->p.sysstate_cur].linkfundisable )
      return DC_ERROR;

   strncpy(digitbuf,digits,MAXNODESTR - 1);

   if(debug > 6)
      printf("@@@@ ilink param = %s, digitbuf = %s\n", (param)? param : "(null)", digitbuf);
      
   switch(myatoi(param)){
      case 11: /* Perm Link off */
      case 1: /* Link off */
         if ((digitbuf[0] == '0') && (myrpt->lastlinknode[0]))
            strcpy(digitbuf,myrpt->lastlinknode);
         val = node_lookup(myrpt,digitbuf);
         if (!val){
            if(strlen(digitbuf) >= myrpt->longestnode)
               return DC_ERROR;
            break;
         }
         strncpy(tmp,val,sizeof(tmp) - 1);
         s = tmp;
         s1 = strsep(&s,",");
         if (!strchr(s1,':') && strchr(s1,'/') && strncasecmp(s1, "local/", 6))
         {
            sy = strchr(s1,'/');    
            *sy = 0;
            sprintf(sx,"%s:4569/%s",s1,sy + 1);
            s1 = sx;
         }
         s2 = strsep(&s,",");
         rpt_mutex_lock(&myrpt->lock);
         l = myrpt->links.next;
         /* try to find this one in queue */
         while(l != &myrpt->links){
            if (l->name[0] == '0') 
            {
               l = l->next;
               continue;
            }
            /* if found matching string */
            if (!strcmp(l->name, digitbuf))
               break;
            l = l->next;
         }
         if (l != &myrpt->links){ /* if found */
            struct   ast_frame wf;

            /* must use perm command on perm link */
            if ((myatoi(param) < 10) && 
                (l->max_retries > MAX_RETRIES))
            {
               rpt_mutex_unlock(&myrpt->lock);
               return DC_COMPLETE;
            }
            strncpy(myrpt->lastlinknode,digitbuf,MAXNODESTR - 1);
            l->retries = l->max_retries + 1;
            l->disced = 1;
            rpt_mutex_unlock(&myrpt->lock);
            wf.frametype = AST_FRAME_TEXT;
            wf.subclass = 0;
            wf.offset = 0;
            wf.mallocd = 0;
            wf.datalen = strlen(discstr) + 1;
            wf.samples = 0;
            wf.data.ptr = discstr;
            if (l->chan)
            {
               ast_write(l->chan,&wf);
               if (ast_safe_sleep(l->chan,250) == -1) return DC_ERROR;
               ast_softhangup(l->chan,AST_SOFTHANGUP_DEV);
            }
            rpt_telemetry(myrpt, COMPLETE, NULL);
            return DC_COMPLETE;
         }
         rpt_mutex_unlock(&myrpt->lock);  
         return DC_COMPLETE;
      case 2: /* Link Monitor */
      case 3: /* Link transceive */
      case 12: /* Link Monitor permanent */
      case 13: /* Link transceive permanent */
         if ((digitbuf[0] == '0') && (myrpt->lastlinknode[0]))
            strcpy(digitbuf,myrpt->lastlinknode);
         /* Attempt connection  */
         perma = (atoi(param) > 10) ? 1 : 0;
         mode = (atoi(param) & 1) ? 1 : 0;
         r = connect_link(myrpt, digitbuf, mode, perma);
         switch(r){
            case -2: /* Attempt to connect to self */
               return DC_COMPLETE; /* Silent error */

            case 0:
               rpt_telemetry(myrpt, COMPLETE, NULL);
               return DC_COMPLETE;

            case 1:
               break;
            
            case 2:
               rpt_telemetry(myrpt, REMALREADY, NULL);
               return DC_COMPLETE;
            
            default:
               rpt_telemetry(myrpt, CONNFAIL, NULL);
               return DC_COMPLETE;
         }
         break;

      case 4: /* Enter Command Mode */
      
         /* if doesnt allow link cmd, or no links active, return */
         if (((command_source != SOURCE_RPT) && 
            (command_source != SOURCE_PHONE) &&
            (command_source != SOURCE_ALT) &&
            (command_source != SOURCE_DPHONE)) ||
             (myrpt->links.next == &myrpt->links))
            return DC_COMPLETE;
         
         /* if already in cmd mode, or selected self, fughetabahtit */
         if ((myrpt->cmdnode[0]) || (!strcmp(myrpt->name, digitbuf))){
         
            rpt_telemetry(myrpt, REMALREADY, NULL);
            return DC_COMPLETE;
         }
         if ((digitbuf[0] == '0') && (myrpt->lastlinknode[0]))
            strcpy(digitbuf,myrpt->lastlinknode);
         /* node must at least exist in list */
         val = node_lookup(myrpt,digitbuf);
         if (!val){
            if(strlen(digitbuf) >= myrpt->longestnode)
               return DC_ERROR;
            break;
         
         }
         rpt_mutex_lock(&myrpt->lock);
         strcpy(myrpt->lastlinknode,digitbuf);
         strncpy(myrpt->cmdnode, digitbuf, sizeof(myrpt->cmdnode) - 1);
         rpt_mutex_unlock(&myrpt->lock);
         rpt_telemetry(myrpt, REMGO, NULL);  
         return DC_COMPLETE;
         
      case 5: /* Status */
         rpt_telemetry(myrpt, STATUS, NULL);
         return DC_COMPLETE;

      case 15: /* Full Status */
         rpt_telemetry(myrpt, FULLSTATUS, NULL);
         return DC_COMPLETE;
         
         
      case 6: /* All Links Off, including permalinks */
                       rpt_mutex_lock(&myrpt->lock);
         myrpt->savednodes[0] = 0;
                        l = myrpt->links.next;
                        /* loop through all links */
                        while(l != &myrpt->links){
            struct   ast_frame wf;
                                if (l->name[0] == '0') /* Skip any IAXRPT monitoring */
                                {
                                        l = l->next;
                                        continue;
                                }
            /* Make a string of disconnected nodes for possible restoration */
            sprintf(tmp,"%c%c%s",(l->mode) ? 'X' : 'M',(l->perma) ? 'P':'T',l->name);
            if(strlen(tmp) + strlen(myrpt->savednodes) + 1 < MAXNODESTR){ 
               if(myrpt->savednodes[0])
                  strcat(myrpt->savednodes, ",");
               strcat(myrpt->savednodes, tmp);
            }
                              l->retries = l->max_retries + 1;
                                l->disced = 2; /* Silently disconnect */
                                rpt_mutex_unlock(&myrpt->lock);
            /* ast_log(LOG_NOTICE,"dumping link %s\n",l->name); */
                                
                                wf.frametype = AST_FRAME_TEXT;
                                wf.subclass = 0;
                                wf.offset = 0;
                                wf.mallocd = 0;
                                wf.datalen = strlen(discstr) + 1;
                                wf.samples = 0;
                                wf.data.ptr = discstr;
                                if (l->chan)
                                {
                                        ast_write(l->chan,&wf);
                                        ast_safe_sleep(l->chan,250); /* It's dead already, why check the return value? */
                                        ast_softhangup(l->chan,AST_SOFTHANGUP_DEV);
                                }
            rpt_mutex_lock(&myrpt->lock);
                                l = l->next;
                        }
         rpt_mutex_unlock(&myrpt->lock);
         if(debug > 3)
            ast_log(LOG_NOTICE,"Nodes disconnected: %s\n",myrpt->savednodes);
                        rpt_telemetry(myrpt, COMPLETE, NULL);
         return DC_COMPLETE;

      case 7: /* Identify last node which keyed us up */
         rpt_telemetry(myrpt, LASTNODEKEY, NULL);
         break;


#ifdef   _MDC_DECODE_H_
      case 8:
         myrpt->lastunit = 0xd00d; 
         mdc1200_notify(myrpt,NULL,myrpt->lastunit);
         mdc1200_send(myrpt,myrpt->lastunit);
         break;
#endif

      case 16: /* Restore links disconnected with "disconnect all links" command */
         strcpy(tmp, myrpt->savednodes); /* Make a copy */
         finddelim(tmp, strs, MAXLINKLIST); /* convert into substrings */
         for(i = 0; tmp[0] && strs[i] != NULL && i < MAXLINKLIST; i++){
            s1 = strs[i];
            mode = (s1[0] == 'X') ? 1 : 0;
            perma = (s1[1] == 'P') ? 1 : 0;
            connect_link(myrpt, s1 + 2, mode, perma); /* Try to reconnect */
         }
                        rpt_telemetry(myrpt, COMPLETE, NULL);
         break;
   
      case 200:
      case 201:
      case 202:
      case 203:
      case 204:
      case 205:
      case 206:
      case 207:
      case 208:
      case 209:
      case 210:
      case 211:
      case 212:
      case 213:
      case 214:
      case 215:
         if (((myrpt->p.propagate_dtmf) && 
              (command_source == SOURCE_LNK)) ||
             ((myrpt->p.propagate_phonedtmf) &&
            ((command_source == SOURCE_PHONE) ||
              (command_source == SOURCE_ALT) ||
                (command_source == SOURCE_DPHONE))))
               do_dtmf_local(myrpt,
                  remdtmfstr[myatoi(param) - 200]);
      default:
         return DC_ERROR;
         
   }
   
   return DC_INDETERMINATE;
}  

/*
* Autopatch up
*/

static int function_autopatchup(struct rpt *myrpt, char *param, char *digitbuf, int command_source, struct rpt_link *mylink)
{
   pthread_attr_t attr;
   int i, idx, paramlength;
   char *lparam;
   char *value = NULL;
   char *paramlist[20];

   static char *keywords[] = {
   "context",
   "dialtime",
   "farenddisconnect",
   "noct",
   "quiet",
   NULL
   };
      
   if (myrpt->p.s[myrpt->p.sysstate_cur].txdisable || myrpt->p.s[myrpt->p.sysstate_cur].autopatchdisable)
      return DC_ERROR;
      
   if(debug)
      printf("@@@@ Autopatch up\n");

   if(!myrpt->callmode){
      /* Set defaults */
      myrpt->patchnoct = 0;
      myrpt->patchdialtime = 0;
      myrpt->patchfarenddisconnect = 0;
      myrpt->patchquiet = 0;
      strncpy(myrpt->patchcontext, myrpt->p.ourcontext, MAXPATCHCONTEXT);

      if(param){
         /* Process parameter list */
         lparam = ast_strdup(param);
         if(!lparam){
            ast_log(LOG_ERROR,"App_rpt out of memory on line %d\n",__LINE__);
            return DC_ERROR;  
         }
         paramlength = finddelim(lparam, paramlist, 20);          
         for(i = 0; i < paramlength; i++){
            idx = matchkeyword(paramlist[i], &value, keywords);
            if(value)
               value = skipchars(value, "= ");
            switch(idx){

               case 1: /* context */
                  strncpy(myrpt->patchcontext, value, MAXPATCHCONTEXT - 1) ;
                  break;
                  
               case 2: /* dialtime */
                  myrpt->patchdialtime = atoi(value);
                  break;

               case 3: /* farenddisconnect */
                  myrpt->patchfarenddisconnect = atoi(value);
                  break;

               case 4:  /* noct */
                  myrpt->patchnoct = atoi(value);
                  break;

               case 5: /* quiet */
                  myrpt->patchquiet = atoi(value);
                  break;
                           
               default:
                  break;
            }
         }
      ast_free(lparam);
      }
   }
               
   rpt_mutex_lock(&myrpt->lock);

   /* if on call, force * into current audio stream */
   
   if ((myrpt->callmode == 2) || (myrpt->callmode == 3)){
      myrpt->mydtmf = myrpt->p.endchar;
   }
   if (myrpt->callmode){
      rpt_mutex_unlock(&myrpt->lock);
      return DC_COMPLETE;
   }
   myrpt->callmode = 1;
   myrpt->cidx = 0;
   myrpt->exten[myrpt->cidx] = 0;
   rpt_mutex_unlock(&myrpt->lock);
   pthread_attr_init(&attr);
   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
   ast_pthread_create(&myrpt->rpt_call_thread,&attr,rpt_call,(void *) myrpt);
   return DC_COMPLETE;
}

/*
* Autopatch down
*/

static int function_autopatchdn(struct rpt *myrpt, char *param, char *digitbuf, int command_source, struct rpt_link *mylink)
{
   if (myrpt->p.s[myrpt->p.sysstate_cur].txdisable || myrpt->p.s[myrpt->p.sysstate_cur].autopatchdisable)
      return DC_ERROR;
   
   if(debug)
      printf("@@@@ Autopatch down\n");
      
   rpt_mutex_lock(&myrpt->lock);
   
   myrpt->macropatch=0;

   if (!myrpt->callmode){
      rpt_mutex_unlock(&myrpt->lock);
      return DC_COMPLETE;
   }
   
   myrpt->callmode = 0;
   channel_revert(myrpt);
   rpt_mutex_unlock(&myrpt->lock);
   rpt_telemetry(myrpt, TERM, NULL);
   return DC_COMPLETE;
}

/*
* Status
*/

static int function_status(struct rpt *myrpt, char *param, char *digitbuf, int command_source, struct rpt_link *mylink)
{

   if (!param)
      return DC_ERROR;

   if ((myrpt->p.s[myrpt->p.sysstate_cur].txdisable) || (myrpt->p.s[myrpt->p.sysstate_cur].userfundisable))
      return DC_ERROR;

   if(debug)
      printf("@@@@ status param = %s, digitbuf = %s\n", (param)? param : "(null)", digitbuf);
   
   switch(myatoi(param)){
      case 1: /* System ID */
         rpt_telemetry(myrpt, ID1, NULL);
         return DC_COMPLETE;
      case 2: /* System Time */
         rpt_telemetry(myrpt, STATS_TIME, NULL);
         return DC_COMPLETE;
      case 3: /* app_rpt.c version */
         rpt_telemetry(myrpt, STATS_VERSION, NULL);
         return DC_COMPLETE;
      case 11: /* System ID (local only)*/
          rpt_telemetry(myrpt, ID , NULL);
            return DC_COMPLETE;
        case 12: /* System Time (local only)*/
            rpt_telemetry(myrpt, STATS_TIME_LOCAL, NULL);
            return DC_COMPLETE;
      default:
         return DC_ERROR;
   }
   return DC_INDETERMINATE;
}
/*
*  Macro-oni (without Salami)
*/
static int function_macro(struct rpt *myrpt, char *param, char *digitbuf, int command_source, struct rpt_link *mylink)
{
char  *val;
int   i;
   if (myrpt->remote)
      return DC_ERROR;

   if(debug) 
      printf("@@@@ macro-oni param = %s, digitbuf = %s\n", (param)? param : "(null)", digitbuf);
   
   if(strlen(digitbuf) < 1) /* needs 1 digit */
      return DC_INDETERMINATE;
         
   for(i = 0 ; i < digitbuf[i] ; i++) {
      if((digitbuf[i] < '0') || (digitbuf[i] > '9'))
         return DC_ERROR;
   }
   
   if (*digitbuf == '0') val = myrpt->p.startupmacro;
   else val = (char *) ast_variable_retrieve(myrpt->cfg, myrpt->p.macro, digitbuf);
   /* param was 1 for local buf */
   if (!val){
                if (strlen(digitbuf) < myrpt->macro_longest)
                        return DC_INDETERMINATE;
      rpt_telemetry(myrpt, MACRO_NOTFOUND, NULL);
      return DC_COMPLETE;
   }        
   rpt_mutex_lock(&myrpt->lock);
   if ((MAXMACRO - strlen(myrpt->macrobuf)) < strlen(val))
   {
      rpt_mutex_unlock(&myrpt->lock);
      rpt_telemetry(myrpt, MACRO_BUSY, NULL);
      return DC_ERROR;
   }
   myrpt->macrotimer = MACROTIME;
   strncat(myrpt->macrobuf,val,MAXMACRO - 1);
   rpt_mutex_unlock(&myrpt->lock);
   return DC_COMPLETE;  
}

/*
*  Playback a recording
*/

static int function_playback(struct rpt *myrpt, char *param, char *digitbuf, int command_source, struct rpt_link *mylink)
{

   if (myrpt->remote)
      return DC_ERROR;

   if(debug) 
      printf("@@@@ playback param = %s, digitbuf = %s\n", (param)? param : "(null)", digitbuf);
   
   if (ast_fileexists(param,NULL,myrpt->rxchannel->language) <= 0)
      return DC_ERROR;

   rpt_telemetry(myrpt,PLAYBACK,param);
   return DC_COMPLETE;
}

/*
* COP - Control operator
*/

static int function_cop(struct rpt *myrpt, char *param, char *digitbuf, int command_source, struct rpt_link *mylink)
{
   char string[16];
   int res;

   int i, r;

   if(!param)
      return DC_ERROR;
   
   switch(myatoi(param)){
      case 1: /* System reset */
         res = system("killall -9 asterisk");
         return DC_COMPLETE;

      case 2:
         myrpt->p.s[myrpt->p.sysstate_cur].txdisable = 0;
         rpt_telemetry(myrpt, ARB_ALPHA, (void *) "RPTENA");
         return DC_COMPLETE;
         
      case 3:
         myrpt->p.s[myrpt->p.sysstate_cur].txdisable = 1;
         return DC_COMPLETE;
         
      case 4: /* test tone on */
         if (myrpt->stopgen < 0) 
         {
            myrpt->stopgen = 1;
         }
         else 
         {
            myrpt->stopgen = 0;
            rpt_telemetry(myrpt, TEST_TONE, NULL);
         }
         return DC_COMPLETE;

      case 5: /* Disgorge variables to log for debug purposes */
         myrpt->disgorgetime = time(NULL) + 10; /* Do it 10 seconds later */
         return DC_COMPLETE;

      case 6: /* Simulate COR being activated (phone only) */
         if (command_source != SOURCE_PHONE) return DC_INDETERMINATE;
         return DC_DOKEY;  


      case 7: /* Time out timer enable */
         myrpt->p.s[myrpt->p.sysstate_cur].totdisable = 0;
         rpt_telemetry(myrpt, ARB_ALPHA, (void *) "TOTENA");
         return DC_COMPLETE;
         
      case 8: /* Time out timer disable */
         myrpt->p.s[myrpt->p.sysstate_cur].totdisable = 1;
         rpt_telemetry(myrpt, ARB_ALPHA, (void *) "TOTDIS");
         return DC_COMPLETE;

                case 9: /* Autopatch enable */
                        myrpt->p.s[myrpt->p.sysstate_cur].autopatchdisable = 0;
                        rpt_telemetry(myrpt, ARB_ALPHA, (void *) "APENA");
                        return DC_COMPLETE;

                case 10: /* Autopatch disable */
                        myrpt->p.s[myrpt->p.sysstate_cur].autopatchdisable = 1;
                        rpt_telemetry(myrpt, ARB_ALPHA, (void *) "APDIS");
                        return DC_COMPLETE;

                case 11: /* Link Enable */
                        myrpt->p.s[myrpt->p.sysstate_cur].linkfundisable = 0;
                        rpt_telemetry(myrpt, ARB_ALPHA, (void *) "LNKENA");
                        return DC_COMPLETE;

                case 12: /* Link Disable */
                        myrpt->p.s[myrpt->p.sysstate_cur].linkfundisable = 1;
                        rpt_telemetry(myrpt, ARB_ALPHA, (void *) "LNKDIS");
                        return DC_COMPLETE;

      case 13: /* Query System State */
         string[0] = string[1] = 'S';
         string[2] = myrpt->p.sysstate_cur + '0';
         string[3] = '\0';
         rpt_telemetry(myrpt, ARB_ALPHA, (void *) string);
         return DC_COMPLETE;

      case 14: /* Change System State */
         if(strlen(digitbuf) == 0)
            break;
         if((digitbuf[0] < '0') || (digitbuf[0] > '9'))
            return DC_ERROR;
         myrpt->p.sysstate_cur = digitbuf[0] - '0';
                        string[0] = string[1] = 'S';
                        string[2] = myrpt->p.sysstate_cur + '0';
                        string[3] = '\0';
                        rpt_telemetry(myrpt, ARB_ALPHA, (void *) string);
                        return DC_COMPLETE;

                case 15: /* Scheduler Enable */
                        myrpt->p.s[myrpt->p.sysstate_cur].schedulerdisable = 0;
                        rpt_telemetry(myrpt, ARB_ALPHA, (void *) "SKENA");
                        return DC_COMPLETE;

                case 16: /* Scheduler Disable */
                        myrpt->p.s[myrpt->p.sysstate_cur].schedulerdisable = 1;
                        rpt_telemetry(myrpt, ARB_ALPHA, (void *) "SKDIS");
                        return DC_COMPLETE;

                case 17: /* User functions Enable */
                        myrpt->p.s[myrpt->p.sysstate_cur].userfundisable = 0;
                        rpt_telemetry(myrpt, ARB_ALPHA, (void *) "UFENA");
                        return DC_COMPLETE;

                case 18: /* User Functions Disable */
                        myrpt->p.s[myrpt->p.sysstate_cur].userfundisable = 1;
                        rpt_telemetry(myrpt, ARB_ALPHA, (void *) "UFDIS");
                        return DC_COMPLETE;

                case 19: /* Alternate Tail Enable */
                        myrpt->p.s[myrpt->p.sysstate_cur].alternatetail = 1;
                        rpt_telemetry(myrpt, ARB_ALPHA, (void *) "ATENA");
                        return DC_COMPLETE;

                case 20: /* Alternate Tail Disable */
                        myrpt->p.s[myrpt->p.sysstate_cur].alternatetail = 0;
                        rpt_telemetry(myrpt, ARB_ALPHA, (void *) "ATDIS");
                        return DC_COMPLETE;

                case 21: /* Parrot Mode Disable */
         birdbath(myrpt);
         if (myrpt->p.parrotmode < 2)
         {
            myrpt->p.parrotmode = 0;
            rpt_telemetry(myrpt,COMPLETE,NULL);
            return DC_COMPLETE;
         }
         break;

                case 22: /* Parrot Mode Enable */
         birdbath(myrpt);
         if (myrpt->p.parrotmode < 2)
         {
            myrpt->p.parrotmode = 1;
            rpt_telemetry(myrpt,COMPLETE,NULL);
            return DC_COMPLETE;
         }
         break;
      case 23: /* flush parrot in progress */
         birdbath(myrpt);
         rpt_telemetry(myrpt,COMPLETE,NULL);
         return DC_COMPLETE;
      case 24: /* flush all telemetry */
         flush_telem(myrpt);
         rpt_telemetry(myrpt,COMPLETE,NULL);
         return DC_COMPLETE;
      case 25: /* request keying info (brief) */
         send_link_keyquery(myrpt);
         myrpt->topkeylong = 0;
         rpt_telemetry(myrpt,COMPLETE,NULL);
         return DC_COMPLETE;
      case 26: /* request keying info (full) */
         send_link_keyquery(myrpt);
         myrpt->topkeylong = 1;
         rpt_telemetry(myrpt,COMPLETE,NULL);
         return DC_COMPLETE;

      case 30: /* recall memory location on programmable radio */

         if(strlen(digitbuf) < 2) /* needs 2 digits */
            break;
         
         for(i = 0 ; i < 2 ; i++){
            if((digitbuf[i] < '0') || (digitbuf[i] > '9'))
               return DC_ERROR;
         }
       
         r = retreive_memory(myrpt, digitbuf);
         if (r < 0){
            rpt_telemetry(myrpt,MEMNOTFOUND,NULL);
            return DC_COMPLETE;
         }
         if (r > 0){
            return DC_ERROR;
         }
         if (setrem(myrpt) == -1) return DC_ERROR;
         return DC_COMPLETE;  

      case 31: 
          /* set channel. note that it's going to change channel 
             then confirm on the new channel! */
         if(strlen(digitbuf) < 2) /* needs 2 digits */
            break;
         
         for(i = 0 ; i < 2 ; i++){
            if((digitbuf[i] < '0') || (digitbuf[i] > '9'))
               return DC_ERROR;
         }
         channel_steer(myrpt,digitbuf);
         return DC_COMPLETE;  

      case 32: /* Touch Tone Pad Test */
         i = strlen(digitbuf);
         if(!i){
            if(debug > 3)
            ast_log(LOG_NOTICE,"Padtest entered");
            myrpt->inpadtest = 1;
         }
         else{
            if(debug > 3)
               ast_log(LOG_NOTICE,"Padtest len= %d digits=%s",i,digitbuf);
            if(digitbuf[i-1] != myrpt->p.endchar)
               break;
            rpt_telemetry(myrpt, ARB_ALPHA, digitbuf);
            myrpt->inpadtest = 0;
            if(debug > 3)
               ast_log(LOG_NOTICE,"Padtest exited");
            return DC_COMPLETE;
         }
   }  
   return DC_INDETERMINATE;
}
/*
* Collect digits one by one until something matches
*/
static int collect_function_digits(struct rpt *myrpt, char *digits, 
   int command_source, struct rpt_link *mylink)
{
   int i,rv;
   char *stringp,*action,*param,*functiondigits;
   char function_table_name[30] = "";
   char workstring[200];
   
   struct ast_variable *vp;
   
   if (debug > 6) ast_log(LOG_NOTICE,"digits=%s  source=%d\n",digits, command_source);

   //if(debug) 
   // printf("@@@@ Digits collected: %s, source: %d\n", digits, command_source);
   
   if (command_source == SOURCE_DPHONE) {
      if (!myrpt->p.dphone_functions) return DC_INDETERMINATE;
      strncpy(function_table_name, myrpt->p.dphone_functions, sizeof(function_table_name) - 1);
      }
   else if (command_source == SOURCE_ALT) {
      if (!myrpt->p.alt_functions) return DC_INDETERMINATE;
      strncpy(function_table_name, myrpt->p.alt_functions, sizeof(function_table_name) - 1);
      }
   else if (command_source == SOURCE_PHONE) {
      if (!myrpt->p.phone_functions) return DC_INDETERMINATE;
      strncpy(function_table_name, myrpt->p.phone_functions, sizeof(function_table_name) - 1);
      }
   else if (command_source == SOURCE_LNK)
      strncpy(function_table_name, myrpt->p.link_functions, sizeof(function_table_name) - 1);
   else
      strncpy(function_table_name, myrpt->p.functions, sizeof(function_table_name) - 1);
    /* find context for function table in rpt.conf file */
   vp = ast_variable_browse(myrpt->cfg, function_table_name);
   while(vp) {
      if(!strncasecmp(vp->name, digits, strlen(vp->name)))
         break;
      vp = vp->next;
   }  
   /* if function context not found */
   if(!vp) {
      int n;

      n = myrpt->longestfunc;
      if (command_source == SOURCE_LNK) n = myrpt->link_longestfunc;
      else 
      if (command_source == SOURCE_PHONE) n = myrpt->phone_longestfunc;
      else 
      if (command_source == SOURCE_ALT) n = myrpt->alt_longestfunc;
      else 
      if (command_source == SOURCE_DPHONE) n = myrpt->dphone_longestfunc;
      
      if(strlen(digits) >= n)
         return DC_ERROR;
      else
         return DC_INDETERMINATE;
   }  
   /* Found a match, retrieve value part and parse */
   strncpy(workstring, vp->value, sizeof(workstring) - 1 );
   stringp = workstring;
   action = strsep(&stringp, ",");
   param = stringp;
   if(debug)
      printf("@@@@ action: %s, param = %s\n",action, (param) ? param : "(null)");
   /* Look up the action */
   for(i = 0 ; i < (sizeof(function_table)/sizeof(struct function_table_tag)); i++){
      if(!strncasecmp(action, function_table[i].action, strlen(action)))
         break;
   }
   if(debug)
      printf("@@@@ table index i = %d\n",i);
   if(i == (sizeof(function_table)/sizeof(struct function_table_tag))){
      /* Error, action not in table */
      return DC_ERROR;
   }
   if(function_table[i].function == NULL){
      /* Error, function undefined */
      if(debug)
         printf("@@@@ NULL for action: %s\n",action);
      return DC_ERROR;
   }
   functiondigits = digits + strlen(vp->name);
   rv=(*function_table[i].function)(myrpt, param, functiondigits, command_source, mylink);
   if (debug > 6) ast_log(LOG_NOTICE,"rv=%i\n",rv);
   return(rv);
}


static void handle_link_data(struct rpt *myrpt, struct rpt_link *mylink,
   char *str)
{
/* XXX ATTENTION: if you change the size of these arrays you MUST
 * change the limits in corresponding sscanf() calls below. */
char  tmp[512],tmp1[512],cmd[300] = "",dest[300],src[300],c;
int   i,seq, res, ts;
struct rpt_link *l;
struct   ast_frame wf;

   wf.frametype = AST_FRAME_TEXT;
   wf.subclass = 0;
   wf.offset = 0;
   wf.mallocd = 0;
   wf.datalen = strlen(str) + 1;
   wf.samples = 0;
   /* put string in our buffer */
   strncpy(tmp,str,sizeof(tmp) - 1);

        if (!strcmp(tmp,discstr))
        {
                mylink->disced = 1;
      mylink->retries = mylink->max_retries + 1;
                ast_softhangup(mylink->chan,AST_SOFTHANGUP_DEV);
                return;
        }
        if (!strcmp(tmp,newkeystr))
        {
      mylink->newkey = 1;
                return;
        }
   if (tmp[0] == 'L')
   {
      rpt_mutex_lock(&myrpt->lock);
      strcpy(mylink->linklist,tmp + 2);
      time(&mylink->linklistreceived);
      rpt_mutex_unlock(&myrpt->lock);
      if (debug > 6) ast_log(LOG_NOTICE,"@@@@ node %s received node list %s from node %s\n",
         myrpt->name,tmp,mylink->name);
      return;
   }
   if (tmp[0] == 'K')
   {
      if (sscanf(tmp, "%299s %299s %299s %30d %30d", cmd, dest, src, &seq, &ts) != 5)
      {
         ast_log(LOG_WARNING, "Unable to parse keying string %s\n",str);
         return;
      }
      if (dest[0] == '0')
      {
         strcpy(dest,myrpt->name);
      }     
      /* if not for me, redistribute to all links */
      if (strcmp(dest,myrpt->name))
      {
         l = myrpt->links.next;
         /* see if this is one in list */
         while(l != &myrpt->links)
         {
            if (l->name[0] == '0') 
            {
               l = l->next;
               continue;
            }
            /* dont send back from where it came */
            if ((l == mylink) || (!strcmp(l->name,mylink->name)))
            {
               l = l->next;
               continue;
            }
            /* if it is, send it and we're done */
            if (!strcmp(l->name,dest))
            {
               /* send, but not to src */
               if (strcmp(l->name,src)) {
                  wf.data.ptr = str;
                  if (l->chan) ast_write(l->chan,&wf);
               }
               return;
            }
            l = l->next;
         }
      }
      /* if not for me, or is broadcast, redistribute to all links */
      if ((strcmp(dest,myrpt->name)) || (dest[0] == '*'))
      {
         l = myrpt->links.next;
         /* otherwise, send it to all of em */
         while(l != &myrpt->links)
         {
            if (l->name[0] == '0') 
            {
               l = l->next;
               continue;
            }
            /* dont send back from where it came */
            if ((l == mylink) || (!strcmp(l->name,mylink->name)))
            {
               l = l->next;
               continue;
            }
            /* send, but not to src */
            if (strcmp(l->name,src)) {
               wf.data.ptr = str;
               if (l->chan) ast_write(l->chan,&wf); 
            }
            l = l->next;
         }
      }
      /* if not for me, end here */
      if (strcmp(dest,myrpt->name) && (dest[0] != '*')) return;
      if (cmd[1] == '?')
      {
         time_t now;
         int n = 0;

         time(&now);
         if (myrpt->lastkeyedtime)
         {
            n = (int)(now - myrpt->lastkeyedtime);
         }
         sprintf(tmp1,"K %s %s %d %d",src,myrpt->name,myrpt->keyed,n);
         wf.data.ptr = tmp1;
         wf.datalen = strlen(tmp1) + 1;
         if (mylink->chan) ast_write(mylink->chan,&wf); 
         return;
      }
      if (myrpt->topkeystate != 1) return;
      rpt_mutex_lock(&myrpt->lock);
      for(i = 0; i < TOPKEYN; i++)
      {
         if (!strcmp(myrpt->topkey[i].node,src)) break;
      }
      if (i >= TOPKEYN)
      {
         for(i = 0; i < TOPKEYN; i++)
         {
            if (!myrpt->topkey[i].node[0]) break;
         }
      }
      if (i < TOPKEYN)
      {
         strncpy(myrpt->topkey[i].node,src,TOPKEYMAXSTR - 1);
         myrpt->topkey[i].timesince = ts;
         myrpt->topkey[i].keyed = seq;
      }
      rpt_mutex_unlock(&myrpt->lock);
      return;
   }
   if (tmp[0] == 'I')
   {
      /* XXX WARNING: be very careful with the limits on the folowing
       * sscanf() call, make sure they match the values defined above */
      if (sscanf(tmp,"%299s %299s %30x",cmd,src,&seq) != 3)
      {
         ast_log(LOG_WARNING, "Unable to parse ident string %s\n",str);
         return;
      }
      mdc1200_notify(myrpt,src,seq);
      strcpy(dest,"*");
   }
   else
   {
      /* XXX WARNING: be very careful with the limits on the folowing
       * sscanf() call, make sure they match the values defined above */
      if (sscanf(tmp,"%299s %299s %299s %30d %1c",cmd,dest,src,&seq,&c) != 5)
      {
         ast_log(LOG_WARNING, "Unable to parse link string %s\n",str);
         return;
      }
      if (strcmp(cmd,"D"))
      {
         ast_log(LOG_WARNING, "Unable to parse link string %s\n",str);
         return;
      }
   }
   if (dest[0] == '0')
   {
      strcpy(dest,myrpt->name);
   }     

   /* if not for me, redistribute to all links */
   if (strcmp(dest,myrpt->name))
   {
      l = myrpt->links.next;
      /* see if this is one in list */
      while(l != &myrpt->links)
      {
         if (l->name[0] == '0') 
         {
            l = l->next;
            continue;
         }
         /* dont send back from where it came */
         if ((l == mylink) || (!strcmp(l->name,mylink->name)))
         {
            l = l->next;
            continue;
         }
         /* if it is, send it and we're done */
         if (!strcmp(l->name,dest))
         {
            /* send, but not to src */
            if (strcmp(l->name,src)) {
               wf.data.ptr = str;
               if (l->chan) ast_write(l->chan,&wf);
            }
            return;
         }
         l = l->next;
      }
      l = myrpt->links.next;
      /* otherwise, send it to all of em */
      while(l != &myrpt->links)
      {
         if (l->name[0] == '0') 
         {
            l = l->next;
            continue;
         }
         /* dont send back from where it came */
         if ((l == mylink) || (!strcmp(l->name,mylink->name)))
         {
            l = l->next;
            continue;
         }
         /* send, but not to src */
         if (strcmp(l->name,src)) {
            wf.data.ptr = str;
            if (l->chan) ast_write(l->chan,&wf); 
         }
         l = l->next;
      }
      return;
   }
   if (myrpt->p.archivedir)
   {
      char dtmfstr[100];

      sprintf(dtmfstr,"DTMF,%s,%c",mylink->name,c);
      donodelog(myrpt,dtmfstr);
   }
   c = func_xlat(myrpt,c,&myrpt->p.outxlat);
   if (!c) return;
   rpt_mutex_lock(&myrpt->lock);
   if (c == myrpt->p.endchar) myrpt->stopgen = 1;
   if (myrpt->callmode == 1)
   {
      myrpt->exten[myrpt->cidx++] = c;
      myrpt->exten[myrpt->cidx] = 0;
      /* if this exists */
      if (ast_exists_extension(myrpt->pchannel,myrpt->patchcontext,myrpt->exten,1,NULL))
      {
         /* if this really it, end now */
         if (!ast_matchmore_extension(myrpt->pchannel,myrpt->patchcontext,
            myrpt->exten,1,NULL)) 
         {
            myrpt->callmode = 2;
            if(!myrpt->patchquiet)
            {
               rpt_mutex_unlock(&myrpt->lock);
               rpt_telemetry(myrpt,PROC,NULL); 
               rpt_mutex_lock(&myrpt->lock);
            }
         }
         else /* othewise, reset timer */
         {
            myrpt->calldigittimer = 1;
         }
      }
      /* if can continue, do so */
      if (!ast_canmatch_extension(myrpt->pchannel,myrpt->patchcontext,myrpt->exten,1,NULL))
      {
         /* call has failed, inform user */
         myrpt->callmode = 4;
      }
   }
   if ((!myrpt->inpadtest) &&(c == myrpt->p.funcchar))
   {
      myrpt->rem_dtmfidx = 0;
      myrpt->rem_dtmfbuf[myrpt->rem_dtmfidx] = 0;
      time(&myrpt->rem_dtmf_time);
      rpt_mutex_unlock(&myrpt->lock);
      return;
   } 
   else if (myrpt->rem_dtmfidx < 0)
   {
      if ((myrpt->callmode == 2) || (myrpt->callmode == 3))
      {
         myrpt->mydtmf = c;
      }
      if (myrpt->p.propagate_dtmf) do_dtmf_local(myrpt,c);
      if (myrpt->p.propagate_phonedtmf) do_dtmf_phone(myrpt,mylink,c);
      rpt_mutex_unlock(&myrpt->lock);
      return;
   }
   else if (((myrpt->inpadtest) || (c != myrpt->p.endchar)) && (myrpt->rem_dtmfidx >= 0))
   {
      time(&myrpt->rem_dtmf_time);
      if (myrpt->rem_dtmfidx < MAXDTMF)
      {
         myrpt->rem_dtmfbuf[myrpt->rem_dtmfidx++] = c;
         myrpt->rem_dtmfbuf[myrpt->rem_dtmfidx] = 0;
         
         rpt_mutex_unlock(&myrpt->lock);
         strncpy(cmd, myrpt->rem_dtmfbuf, sizeof(cmd) - 1);
         res = collect_function_digits(myrpt, cmd, SOURCE_LNK, mylink);
         rpt_mutex_lock(&myrpt->lock);
         
         switch(res){

            case DC_INDETERMINATE:
               break;
            
            case DC_REQ_FLUSH:
               myrpt->rem_dtmfidx = 0;
               myrpt->rem_dtmfbuf[0] = 0;
               break;
            
            
            case DC_COMPLETE:
            case DC_COMPLETEQUIET:
               myrpt->totalexecdcommands++;
               myrpt->dailyexecdcommands++;
               strncpy(myrpt->lastdtmfcommand, cmd, MAXDTMF-1);
               myrpt->lastdtmfcommand[MAXDTMF-1] = '\0';
               myrpt->rem_dtmfbuf[0] = 0;
               myrpt->rem_dtmfidx = -1;
               myrpt->rem_dtmf_time = 0;
               break;
            
            case DC_ERROR:
            default:
               myrpt->rem_dtmfbuf[0] = 0;
               myrpt->rem_dtmfidx = -1;
               myrpt->rem_dtmf_time = 0;
               break;
         }
      }

   }
   rpt_mutex_unlock(&myrpt->lock);
   return;
}

static void handle_link_phone_dtmf(struct rpt *myrpt, struct rpt_link *mylink,
   char c)
{

char  cmd[300];
int   res;

   if (myrpt->p.archivedir)
   {
      char str[100];

      sprintf(str,"DTMF(P),%s,%c",mylink->name,c);
      donodelog(myrpt,str);
   }
   rpt_mutex_lock(&myrpt->lock);

   if (mylink->phonemode == 3) /*If in simplex dumb phone mode */
   {
      if(c == myrpt->p.endchar) /* If end char */
      {
         mylink->lastrealrx = 0; /* Keying state = off */
         rpt_mutex_unlock(&myrpt->lock);
         return;
      }

      if(c == myrpt->p.funcchar) /* If lead-in char */
      {
         mylink->lastrealrx = !mylink->lastrealrx; /* Toggle keying state */
         rpt_mutex_unlock(&myrpt->lock);
         return;
      }
   }
   else
   {
      if (c == myrpt->p.endchar)
      {
         if (mylink->lastrx)
         {
            mylink->lastrealrx = 0;
            rpt_mutex_unlock(&myrpt->lock);
            return;
         }
         myrpt->stopgen = 1;
         if (myrpt->cmdnode[0])
         {
            myrpt->cmdnode[0] = 0;
            myrpt->dtmfidx = -1;
            myrpt->dtmfbuf[0] = 0;
            rpt_mutex_unlock(&myrpt->lock);
            rpt_telemetry(myrpt,COMPLETE,NULL);
            return;
         }
      }
   }
   if (myrpt->cmdnode[0])
   {
      rpt_mutex_unlock(&myrpt->lock);
      send_link_dtmf(myrpt,c);
      return;
   }
   if (myrpt->callmode == 1)
   {
      myrpt->exten[myrpt->cidx++] = c;
      myrpt->exten[myrpt->cidx] = 0;
      /* if this exists */
      if (ast_exists_extension(myrpt->pchannel,myrpt->patchcontext,myrpt->exten,1,NULL))
      {
         /* if this really it, end now */
         if (!ast_matchmore_extension(myrpt->pchannel,myrpt->patchcontext,
            myrpt->exten,1,NULL)) 
         {
            myrpt->callmode = 2;
            if(!myrpt->patchquiet)
            {
               rpt_mutex_unlock(&myrpt->lock);
               rpt_telemetry(myrpt,PROC,NULL); 
               rpt_mutex_lock(&myrpt->lock);
            }
         }
         else /* othewise, reset timer */
         {
            myrpt->calldigittimer = 1;
         }
      }
      /* if can continue, do so */
      if (!ast_canmatch_extension(myrpt->pchannel,myrpt->patchcontext,myrpt->exten,1,NULL))
      {
         /* call has failed, inform user */
         myrpt->callmode = 4;
      }
   }
   if ((myrpt->callmode == 2) || (myrpt->callmode == 3))
   {
      myrpt->mydtmf = c;
   }
   if ((!myrpt->inpadtest) && (c == myrpt->p.funcchar))
   {
      myrpt->rem_dtmfidx = 0;
      myrpt->rem_dtmfbuf[myrpt->rem_dtmfidx] = 0;
      time(&myrpt->rem_dtmf_time);
      rpt_mutex_unlock(&myrpt->lock);
      return;
   } 
   else if (((myrpt->inpadtest) || (c != myrpt->p.endchar)) && (myrpt->rem_dtmfidx >= 0))
   {
      time(&myrpt->rem_dtmf_time);
      if (myrpt->rem_dtmfidx < MAXDTMF)
      {
         myrpt->rem_dtmfbuf[myrpt->rem_dtmfidx++] = c;
         myrpt->rem_dtmfbuf[myrpt->rem_dtmfidx] = 0;
         
         rpt_mutex_unlock(&myrpt->lock);
         strncpy(cmd, myrpt->rem_dtmfbuf, sizeof(cmd) - 1);
         switch(mylink->phonemode)
         {
             case 1:
            res = collect_function_digits(myrpt, cmd, 
               SOURCE_PHONE, mylink);
            break;
             case 2:
            res = collect_function_digits(myrpt, cmd, 
               SOURCE_DPHONE,mylink);
            break;
             case 4:
            res = collect_function_digits(myrpt, cmd, 
               SOURCE_ALT,mylink);
            break;
             default:
            res = collect_function_digits(myrpt, cmd, 
               SOURCE_LNK, mylink);
            break;
         }

         rpt_mutex_lock(&myrpt->lock);
         
         switch(res){

            case DC_INDETERMINATE:
               break;
            
            case DC_DOKEY:
               mylink->lastrealrx = 1;
               break;
            
            case DC_REQ_FLUSH:
               myrpt->rem_dtmfidx = 0;
               myrpt->rem_dtmfbuf[0] = 0;
               break;
            
            
            case DC_COMPLETE:
            case DC_COMPLETEQUIET:
               myrpt->totalexecdcommands++;
               myrpt->dailyexecdcommands++;
               strncpy(myrpt->lastdtmfcommand, cmd, MAXDTMF-1);
               myrpt->lastdtmfcommand[MAXDTMF-1] = '\0';
               myrpt->rem_dtmfbuf[0] = 0;
               myrpt->rem_dtmfidx = -1;
               myrpt->rem_dtmf_time = 0;
               break;
            
            case DC_ERROR:
            default:
               myrpt->rem_dtmfbuf[0] = 0;
               myrpt->rem_dtmfidx = -1;
               myrpt->rem_dtmf_time = 0;
               break;
         }
      }

   }
   rpt_mutex_unlock(&myrpt->lock);
   return;
}

/* Doug Hall RBI-1 serial data definitions:
 *
 * Byte 0: Expansion external outputs 
 * Byte 1: 
 * Bits 0-3 are BAND as follows:
 * Bits 4-5 are POWER bits as follows:
 *    00 - Low Power
 *    01 - Hi Power
 *    02 - Med Power
 * Bits 6-7 are always set
 * Byte 2:
 * Bits 0-3 MHZ in BCD format
 * Bits 4-5 are offset as follows:
 *    00 - minus
 *    01 - plus
 *    02 - simplex
 *    03 - minus minus (whatever that is)
 * Bit 6 is the 0/5 KHZ bit
 * Bit 7 is always set
 * Byte 3:
 * Bits 0-3 are 10 KHZ in BCD format
 * Bits 4-7 are 100 KHZ in BCD format
 * Byte 4: PL Tone code and encode/decode enable bits
 * Bits 0-5 are PL tone code (comspec binary codes)
 * Bit 6 is encode enable/disable
 * Bit 7 is decode enable/disable
 */

/* take the frequency from the 10 mhz digits (and up) and convert it
   to a band number */

static int rbi_mhztoband(char *str)
{
int   i;

   i = atoi(str) / 10; /* get the 10's of mhz */
   switch(i)
   {
       case 2:
      return 10;
       case 5:
      return 11;
       case 14:
      return 2;
       case 22:
      return 3;
       case 44:
      return 4;
       case 124:
      return 0;
       case 125:
      return 1;
       case 126:
      return 8;
       case 127:
      return 5;
       case 128:
      return 6;
       case 129:
      return 7;
       default:
      break;
   }
   return -1;
}

/* take a PL frequency and turn it into a code */
static int rbi_pltocode(char *str)
{
int i;
char *s;

   s = strchr(str,'.');
   i = 0;
   if (s) i = atoi(s + 1);
   i += atoi(str) * 10;
   switch(i)
   {
       case 670:
      return 0;
       case 719:
      return 1;
       case 744:
      return 2;
       case 770:
      return 3;
       case 797:
      return 4;
       case 825:
      return 5;
       case 854:
      return 6;
       case 885:
      return 7;
       case 915:
      return 8;
       case 948:
      return 9;
       case 974:
      return 10;
       case 1000:
      return 11;
       case 1035:
      return 12;
       case 1072:
      return 13;
       case 1109:
      return 14;
       case 1148:
      return 15;
       case 1188:
      return 16;
       case 1230:
      return 17;
       case 1273:
      return 18;
       case 1318:
      return 19;
       case 1365:
      return 20;
       case 1413:
      return 21;
       case 1462:
      return 22;
       case 1514:
      return 23;
       case 1567:
      return 24;
       case 1622:
      return 25;
       case 1679:
      return 26;
       case 1738:
      return 27;
       case 1799:
      return 28;
       case 1862:
      return 29;
       case 1928:
      return 30;
       case 2035:
      return 31;
       case 2107:
      return 32;
       case 2181:
      return 33;
       case 2257:
      return 34;
       case 2336:
      return 35;
       case 2418:
      return 36;
       case 2503:
      return 37;
   }
   return -1;
}

/*
* Shift out a formatted serial bit stream
*/

static void rbi_out_parallel(struct rpt *myrpt,unsigned char *data)
    {
#ifdef __i386__
    int i,j;
    unsigned char od,d;
    static volatile long long delayvar;

    for(i = 0 ; i < 5 ; i++){
        od = *data++; 
        for(j = 0 ; j < 8 ; j++){
            d = od & 1;
            outb(d,myrpt->p.iobase);
       /* >= 15 us */
       for(delayvar = 1; delayvar < 15000; delayvar++); 
            od >>= 1;
            outb(d | 2,myrpt->p.iobase);
       /* >= 30 us */
       for(delayvar = 1; delayvar < 30000; delayvar++); 
            outb(d,myrpt->p.iobase);
       /* >= 10 us */
       for(delayvar = 1; delayvar < 10000; delayvar++); 
            }
        }
   /* >= 50 us */
        for(delayvar = 1; delayvar < 50000; delayvar++);