Sat Nov 1 06:28:20 2008

Asterisk developer's documentation

---

app_rpt.c

Go to the documentation of this file.

/* #define OLD_ASTERISK */
#define  OLDKEY
/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2002-2007, 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.73 09/04/07
 * 
 * \author Jim Dixon, WB6NIL <jim@lambdatel.com>
 *
 * \note Serious contributions by Steve RoDgers, WA6ZFT <hwstar@rodgers.sdcoxmail.com>
 * 
 * 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
 *  2 - Give Time of Day
 *  3 - Give software Version
 *
 * 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 
 *
 * 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)
 *
 *
 * '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 */

#define  MAXDTMF 32
#define  MAXMACRO 2048
#define  MAXLINKLIST 512
#define  LINKLISTTIME 10000
#define  LINKLISTSHORTTIME 200
#define  MACROTIME 100
#define  MACROPTIME 500
#define  DTMF_TIMEOUT 3
#define  KENWOOD_RETRIES 5

#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  START_DELAY 2

#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  FUNCCHAR '*'
#define  ENDCHAR '#'
#define  EXTNODEFILE "/var/lib/asterisk/rpt_extnodes"

#define  DEFAULT_IOBASE 0x378

#define  DEFAULT_CIV_ADDR 0x58

#define  MAXCONNECTTIME 5000

#define MAXNODESTR 300

#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  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,
   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,
   TIMEOUT_WARNING, ACT_TIMEOUT_WARNING, LINKUNKEY, UNAUTHTX};


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};

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

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: 146244 $")

#include <signal.h>
#include <stdio.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>
#include <sys/io.h>
#include <sys/vfs.h>
#include <math.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <termios.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/dahdi_compat.h"
#include "asterisk/tonezone_compat.h"

/* 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.73  09/04/2007";

static char *app = "Rpt";

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

static char *descrip = 
"  Rpt(nodename[|options]):  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";

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!!";
static char *remote_rig_ft897="ft897";
static char *remote_rig_rbi="rbi";
static char *remote_rig_kenwood="kenwood";
static char *remote_rig_ic706="ic706";

#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 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  name[MAXNODESTR]; /* identifier (routing) string */
   char  lasttx;
   char  lastrx;
   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   ast_frame *lastf1,*lastf2;
   struct   rpt_chan_stat chan_stat[NRPTSTAT];
} ;

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];
   int   submode;
   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;
};

static struct rpt
{
   ast_mutex_t lock;
   ast_mutex_t remlock;
   struct ast_config *cfg;
   char reload;

   char *name;
   char *rxchanname;
   char *txchanname;
   char *remote;
   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 *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  *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];
   } p;
   struct rpt_link links;
   int unkeytocttimer;
   char keyed;
   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];
   struct ast_channel *rxchannel,*txchannel, *monchannel;
   struct ast_channel *pchannel,*txpchannel, *zaprxchannel, *zaptxchannel;
   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 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 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;
   char  loginuser[50];
   char  loginlevel[10];
   long  authtelltimer;
   long  authtimer;
   int iofd;
   time_t start_time,last_activity_time;
#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
} 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);

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;
   }