#!/bin/bash
##############################################################################################################
#
# Swissarmy multi-function tool for Asterisk/app_rpt by Kyle Yoksh, K0KN 10/2013
# version 1.54 for ACID - 9/30/2021 (last update for new Allstar Node list)
#
# Usage = swissarmy [0 1] [your node#] [remote node #]
# 
# This script is run by app_rpt using connpgm and discpgm. app_rpt will pass the last two variables. 
#
# Do not edit this script directly. swissarmy.conf is the configuration file, and can hold the configuration
# for all of your nodes in a single file.
#
# Place these lines in rpt.conf for each node:
#     connpgm=/home/kyle/swissarmy 1
#     discpgm=/home/kyle/swissarmy 0                
#
##############################################################################################################


SWISSARMYCONF=/etc/asterisk/swissarmy.conf
SWISSARMYTEMP=/dev/shm/x.swissarmytemp.$2
SWISSARMYTEMP2=/dev/shm/x.swissarmytemp2.$2
SWISSARMYTEMP3=/dev/shm/x.swissarmytemp3.$2
ASTNODEINFO=/dev/shm/x.astnodeinfo.$2
TEMP=/dev/shm
ECHOTEMP=/dev/shm/x.echotemp.$2

# ---------------------- DO NOT EDIT BELOW THIS LINE ---------------------------
retrycount=0
emailcount=1
LOCALNODE=$2

if [ "$1" == "" -o "$2" == "" -o "$3" == "" ] ; then
echo "Usage = swissarmy [0 1] [your node#] [remote node #]" ; exit
fi

# Exit routine
function cleanup {
  echo "Removing temp files"
rm -f $ECHOTEMP
rm -f $SWISSARMYTEMP
rm -f $SWISSARMYTEMP2
rm -f $SWISSARMYTEMP3
rm -f "$SWISSARMYTEMP2"em
rm -f "$SWISSARMYTEMP2"out
rm -f "$SWISSARMYTEMP2"n
rm -f "$SWISSARMYTEMP2"v
rm -f "$SWISSARMYTEMP2"vh
rm -f "$SWISSARMYTEMP2"vo
rm -f "$SWISSARMYTEMP2"v2
rm -f "$SWISSARMYTEMP2"x
rm -f "$SWISSARMYTEMP2"z
rm -f $TEMP/estatus$LOCALNODE.*
exit 0
}

trap cleanup EXIT

downloadnodelist ()
# 2021 routine patch
{
# Create / update local nodelist
retrycount=$((retrycount + 1))
if [ $retrycount == 10 ] ; then
echo $(date) "Error downloading nodelist" >> $LOGFILE ; echo "Error downloading nodelist -- exiting" ; exit ; fi
if ! [ -f $NODELIST ] ; then
echo "No nodelist found - downloading" ;  wget -O "$NODELIST"2 $LISTURL ; appendprivate ; fi

if [ "$(( $(date +"%s") - $(stat -c "%Y" $NODELIST) ))" -gt "3600" ] ; then
echo "Nodelist over 1 hour old - downloading new" ; wget -O "$NODELIST"2 $LISTURL ; appendprivate ; fi
}

appendprivate ()
{
# Remove lat/long fields
cut -f1,2,5,6 "$NODELIST"2 > $NODELIST
# Append private nodelist to Allstar nodelist if file exists
if [ -s "$PRIVATE_LIST" ] ; then
grep -v '^$' "$PRIVATE_LIST" > "$PRIVATE_LIST"2
cp -f "$PRIVATE_LIST"2 "$PRIVATE_LIST"
rm -f "$PRIVATE_LIST"2
echo "Private nodelist found. Adding entries from $PRIVATE_LIST to $NODELIST"
cat "$PRIVATE_LIST" >> "$NODELIST"
fi
}

checknodelist ()
{
# Check nodelist for proper header
HEADER=$(grep 'Click here for Graphical Status' $NODELIST)
if [ "$HEADER" != "" ] ; then
echo "Header check complete"
else
echo "Does not match" ; downloadnodelist
fi

# Check nodelist for proper footer
FOOTER=$(grep 'nodes reporting' $NODELIST)
if [ "$FOOTER" != "" ] ; then
echo "Footer check complete"
else
echo "Does not match" ; downloadnodelist
fi

# Remove header
if [ -f "$NODELIST" ]
then
awk 'FNR>5{print}' $NODELIST > "$NODELIST"2
fi

# Remove footer, keyed y/n and uptime
if [ -f "$NODELIST"2 ]
then
sed '/^$/d' "$NODELIST"2 > "$NODELIST"
sed '$d' < "$NODELIST" > "$NODELIST"2
cut -c1-94 "$NODELIST"2 > "$NODELIST"
rm -f "$NODELIST"2
fi

# Append private nodelist to Allstar nodelist if file exists
if [ -s "$PRIVATE_LIST" ] ; then
grep -v '^$' "$PRIVATE_LIST" > "$PRIVATE_LIST"2
cp -f "$PRIVATE_LIST"2 "$PRIVATE_LIST"
rm -f "$PRIVATE_LIST"2
echo "Private nodelist found. Adding entries from $PRIVATE_LIST to $NODELIST"
cat "$PRIVATE_LIST" >> "$NODELIST"
fi
}

emailoutput ()
{

# Email output
if [ "$SHOW_MULTIMESSAGE_NUMBER" = 1 ] ; then
SUBJECT="$SUBJECT $emailcount/$NUMFILES"
fi
#
if [ -s "$TEMP"/estatus$LOCALNODE.a"$SPLITVAR" ] ; then
mail -s "$SUBJECT $TIME_DATE" $SENDTO -- -f $SENDAS < "$TEMP"/estatus$LOCALNODE.a"$SPLITVAR"
rm -f "$TEMP"/estatus$LOCALNODE.a"$SPLITVAR"
echo "Message estatus$LOCALNODE.a"$SPLITVAR" sent."
fi
#
incrementoutput
}

incrementoutput ()
{
SPLITVAR2=$(echo "$SPLITVAR" | tr "0-9a-z" "1-9a-z_")
if [ -s $TEMP/estatus$LOCALNODE.a$SPLITVAR2 ] ; then
SPLITVAR=$SPLITVAR2
charcount2=$(stat -c %s $TEMP/estatus$LOCALNODE.a$SPLITVAR)
fi
if [ -z $charcount2 ] ; then 
charcount2=0
fi
if [ -s "$TEMP"/estatus$LOCALNODE.a"$SPLITVAR" -a "$charcount2" -lt "$TEXTMINCHARS" ] ; then
rm -f "$TEMP"/estatus$LOCALNODE.a"$SPLITVAR"
fi
#
emailcount=$((emailcount + 1))
if [ "$emailcount" = "$MULTIMESSAGE_LIMIT" ] ; then
echo "Multimessage limit of $emailcount reached - truncating output"
echo $(date) "Multimessage limit of $emailcount reached - truncating output" >> $LOGFILE
rm -f "$TEMP"/estatus$LOCALNODE.a*
fi
#
if [ -s "$TEMP"/estatus$LOCALNODE.a"$SPLITVAR" -a "$emailcount" -lt 27 ] ; then
echo "Multimessage delay of $MULTIMESSAGE_DELAY seconds" ; sleep $MULTIMESSAGE_DELAY
SUBJECT="continued"
emailoutput
fi
}

# Read node configuration from swissarmy.conf
sed -n "/:$2:/,/\\\\|^$\\|*$2*/p" $SWISSARMYCONF > $SWISSARMYTEMP

if ! [ -s $SWISSARMYTEMP ]
then
echo "Node $2 is not defined in $SWISSARMYCONF -- Exiting"
exit
fi

rm -f "$SWISSARMYTEMP3"
rm -f "$SWISSARMYTEMP2"em
rm -f "$SWISSARMYTEMP2"n
rm -f "$SWISSARMYTEMP2"v
rm -f "$SWISSARMYTEMP2"vh
rm -f "$SWISSARMYTEMP2"x
rm -f $TEMP/estatus$2.*

# Read config into variables

PATTERN="SENDTO"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
SENDTO=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="SENDAS"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
SENDAS=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="PRIVATE_LIST"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
PRIVATE_LIST=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="NODELIST"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
NODELIST=$(echo "${PATTERNX/$PATTERN=/}")
if [ -z $NODELIST ] ; then
echo "Nodelist variable is not defined for node $2 in $SWISSARMYCONF -- Exiting"
exit
fi
#
PATTERN="LISTURL"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
LISTURL=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ALLSTARRPTEXTNODES"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ALLSTARRPTEXTNODES=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ECHOLOOKUP"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ECHOLOOKUP=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="SOUNDS"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
SOUNDS=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="LOGFILE"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
LOGFILE=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="BANLIST"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
BANLIST=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="BANLIST_DENY_ALERT"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
BANLIST_DENY_ALERT=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="BANLIST_DENY_EMAIL"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
BANLIST_DENY_EMAIL=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="BANDELAY"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
BANDELAY=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ACCEPTLIST"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ACCEPTLIST=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ACCEPTLIST_DENY_ALERT"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ACCEPTLIST_DENY_ALERT=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ACCEPTLIST_DENY_EMAIL"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ACCEPTLIST_DENY_EMAIL=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="SUBJECT"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
SUBJECT=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="DISABLE"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
DISABLE=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="NODENO_ACTIONFILE"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
NODENO_ACTIONFILE=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="CALLSIGN_ACTIONFILE"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
CALLSIGN_ACTIONFILE=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="GLOBALINFO"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
GLOBALINFO=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="VERBOSE"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
VERBOSE=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ANNOUNCENUMBER"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ANNOUNCENUMBER=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="WEBTX_TEXT"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
WEBTX_TEXT=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="CUSTOMWELCOME_LOCAL"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
CUSTOMWELCOME_LOCAL=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="CUSTOMWELCOME_GLOBAL"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
CUSTOMWELCOME_GLOBAL=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ANNOUNCEMESSAGE"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ANNOUNCEMESSAGE=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ANNOUNCE_EXT"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ANNOUNCE_EXT=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="SWISSARMYRANDOMSLEEP"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
SWISSARMYRANDOMSLEEP=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ALLSTAR_CONN_ALERTS"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ALLSTAR_CONN_ALERTS=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ALLSTAR_DISC_ALERTS"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ALLSTAR_DISC_ALERTS=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ECHO_CONN_ALERTS"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ECHO_CONN_ALERTS=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ECHO_DISC_ALERTS"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ECHO_DISC_ALERTS=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="TEXTMINCHARS"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
TEXTMINCHARS=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="TEXTMAXCHARS"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
TEXTMAXCHARS=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="SHOW_MULTIMESSAGE_NUMBER"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
SHOW_MULTIMESSAGE_NUMBER=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="MULTIMESSAGE_LIMIT"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
MULTIMESSAGE_LIMIT=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="MULTIMESSAGE_DELAY"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
MULTIMESSAGE_DELAY=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ECHOLINK_WELCOME"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ECHOLINK_WELCOME=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ECHOLINK_CONN_CMD"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ECHOLINK_CONN_CMD=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ECHOLINK_DISC_CMD"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ECHOLINK_DISC_CMD=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ALLSTAR_CONN_CMD"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ALLSTAR_CONN_CMD=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ALLSTAR_DISC_CMD"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ALLSTAR_DISC_CMD=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="EXTENSION_CONN_CMD"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
EXTENSION_CONN_CMD=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="EXTENSION_DISC_CMD"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
EXTENSION_DISC_CMD=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ASTKICK"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ASTKICK=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ASTKICK2"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ASTKICK2=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="ALLSTAR_BAN_CMD"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
ALLSTAR_BAN_CMD=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="EXIT_CMD"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
EXIT_CMD=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="SHOW_DATE_TIME"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
SHOW_DATE_TIME=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="TOTALCOUNT_ALERT"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
TOTALCOUNT_ALERT=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="TOTALCOUNT_EMAIL"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
TOTALCOUNT_EMAIL=$(echo "${PATTERNX/$PATTERN=/}")
#
PATTERN="TOTALCOUNT_ACTION"
PATTERNX=$(grep -i "$PATTERN=" $SWISSARMYTEMP)
TOTALCOUNT_ACTION=$(echo "${PATTERNX/$PATTERN=/}")
#
# Define variables if not found in config file

if [ -z $BANDELAY ]
then BANDELAY=10
fi

if [ -z $TEXTMAXCHARS ]
then TEXTMAXCHARS=150000
fi

if [ -z $TEXTMINCHARS ]
then TEXTMINCHARS=2
fi

if [ -z $SHOW_MULTIMESSAGE_NUMBER ]
then SHOW_MULTIMESSAGE_NUMBER=0
fi

if [ -z $MULTIMESSAGE_LIMIT ]
then MULTIMESSAGE_LIMIT=4
fi

if [ -z $MULTIMESSAGE_DELAY ]
then MULTIMESSAGE_DELAY=7
fi

if [ -z $TOTALCOUNT_ALERT ]
then TOTALCOUNT_ALERT=10000
fi

if [ "$SHOW_DATE_TIME" = 1 ]
then TIME_DATE=$(date)
fi

if [ -z $ACCEPTLIST_DENY_EMAIL ]
then ACCEPTLIST_DENY_EMAIL=$SENDTO
fi

if [ -z $BANLIST_DENY_EMAIL ]
then BANLIST_DENY_EMAIL=$SENDTO
fi

if [ -z $TOTALCOUNT_EMAIL ]
then TOTALCOUNT_EMAIL=$SENDTO
fi

# Delete nodelist if zero bytes
if ! [ -s $NODELIST ] ; then rm -f $NODELIST ; fi

# Run Check/download nodelist routine
downloadnodelist

#############################

if [ $1 == 1 ] ; then
STATUS="Connected" ; TOFROM="to"
fi
if [ $1 == 0 ] ; then
STATUS="Disconnected" ; TOFROM="from"
fi

if [ -n "$SWISSARMYRANDOMSLEEP" ] ; then
SWISSARMYSLEEP=$[ ( $RANDOM % $SWISSARMYRANDOMSLEEP )  + 1 ]
echo "Random sleep period $SWISSARMYSLEEP" ; sleep $SWISSARMYSLEEP
fi

# Get list of all connected nodes
asterisk -rx "rpt nodes $2" > $SWISSARMYTEMP2

if ! [ -f $SWISSARMYTEMP2 ] ; then
touch $SWISSARMYTEMP2
fi

if grep -q "<NONE>" $SWISSARMYTEMP2 ; then
rm -f $SWISSARMYTEMP2
touch $SWISSARMYTEMP2
fi

# Test if callsign or node number
if [ "$3" -eq "$3" ] 2>/dev/null; then
TYPE=""
else
TYPE="Callsign"
NODENO=$3
fi

# Count number of digits for remote station
COUNT=$(echo $3 | wc -m)
COUNT=$(( $COUNT - 1 ))
#
if [ "$TYPE" != "Callsign" -a "$COUNT" == 7 ] ; then
TYPE="Echolink" 
fi
#
if [ "$TYPE" != "Callsign" -a "$COUNT" == 3 ] ; then
TYPE="Extension" 
NODENO=$3
fi

# Get extended node info
if [ -s "$ECHOLOOKUP" -a "$COUNT" == 7 -a "$TYPE" != "Callsign" ] ; then
NODENO=$(echo $3 | cut -c 2-)
$ECHOLOOKUP nodename $3 > $ECHOTEMP
ECHOINFO=$(<$ECHOTEMP)
echo "" ; echo "Echolink info $ECHOINFO"
fi
if [[ "$ECHOINFO" =~ "Error" ]]
then
ECHOINFO=""
fi

# Determine if node is Allstar type
if [ "$TYPE" != "Callsign" -a "$COUNT" -ge "4" -a "$COUNT" -lt "7" ] ; then
TYPE="Allstar" ; NODENO=$3
grep -w $NODENO $NODELIST > $ASTNODEINFO
################### ASTNODEINFO=$(grep -w ^$NODENO $NODELIST)
fi

# Extract Allstar callsign from nodelist - field 2
if [ "$TYPE" = "Allstar" ] ; then
ALLSTARCALL=$(cut -f2 "$ASTNODEINFO")
fi

# Extract IP address from Allstar nodelist
if [ -s "$ALLSTARRPTEXTNODES" -a "$TYPE" = "Allstar" ] ; then
grep -F "$NODENO=radio" "$ALLSTARRPTEXTNODES" > "$SWISSARMYTEMP3"
ALLSTARNODEIP=$(cut -f2 -d"," "$SWISSARMYTEMP3")
echo "$TYPE $NODENO IP address: $ALLSTARNODEIP"
fi

# If off-grid node or not yet in nodelist
if [ -z "$ALLSTARCALL" ] ; then
ALLSTARCALL="0"
fi

# Node logging
ASNODE=$(grep ^$3 "$NODELIST")
echo $(date) "---" $2 $STATUS $TOFROM $TYPE $3 "-------" $ASNODE $ECHOINFO $ALLSTARNODEIP >> $LOGFILE

# Check callsign against banlist if so configured
if [ -s "$BANLIST" -a "$TYPE" = "Allstar" -a "$STATUS" = "Connected" ] ; then
echo "Check the banlist for $ALLSTARCALL"
BANRESULTS=$(grep -i ^$ALLSTARCALL $BANLIST)
BANRESULTS2=$(grep -i ^$3 $BANLIST)
fi

# Check node number's callsign against accept list if so configured
if [ -s "$ACCEPTLIST" -a "$TYPE" = "Allstar" -a "$STATUS" = "Connected" ] ; then
echo "Check the accept list for $ALLSTARCALL"
ACCEPTRESULTS=$(grep -i ^$ALLSTARCALL $ACCEPTLIST)
fi

# Check callsign against accept list if so configured
if [ -s "$ACCEPTLIST" -a "$TYPE" = "Callsign" -a "$STATUS" = "Connected" ] ; then
echo "Check the accept list for $NODENO"
ACCEPTRESULTS=$(grep -i ^$NODENO $ACCEPTLIST)
fi

# Check extension against accept list if so configured
if [ -s "$ACCEPTLIST" -a "$TYPE" = "Extension" -a "$STATUS" = "Connected" ] ; then
echo "Check the accept list for $NODENO"
ACCEPTRESULTS=$(grep -i ^$3 $ACCEPTLIST)
fi

# Remove banner and blank lines
cat "$SWISSARMYTEMP2" | grep -v "*" > "$SWISSARMYTEMP2"z

if [ -f "$SWISSARMYTEMP2"z ] ; then
sed '/^$/d' "$SWISSARMYTEMP2"z > $SWISSARMYTEMP2
fi

# Count number of connected nodes
TOTALCOUNT=($( wc -w $SWISSARMYTEMP2))
echo "Total connected nodes: $TOTALCOUNT"

# Announce total number of connected stations
if [ "$ANNOUNCENUMBER" == "1" -a "$STATUS" = "Connected" -o "$ANNOUNCENUMBER" == "1" -a "$STATUS" = "Disconnected" ]
then
echo "Announce $TOTALCOUNT connected stations"
fi
#
if [ "$ANNOUNCENUMBER" == "1" -a $TOTALCOUNT -lt 21 ]
then
asterisk -rx "rpt localplay $2 /var/lib/asterisk/sounds/digits/$TOTALCOUNT"
fi
#
if [ "$ANNOUNCENUMBER" == "1" -a $TOTALCOUNT -gt 20 ]
then
asterisk -rx "rpt localplay $2 $SOUNDS/20plus"
fi
#
if [ "$TOTALCOUNT" -gt "$TOTALCOUNT_ALERT" ] ; then
echo "Sending alert email to $TOTALCOUNT_EMAIL - $TOTALCOUNT nodes connected to $2"
echo "$2 $STATUS $TOFROM $TYPE $3 -- $TOTALCOUNT nodes connected to $2" > "$TEMP"/maxstations.$2
echo " " >> "$TEMP"/maxstations.$2
echo "Alerts will be sent when connected stations exceed $TOTALCOUNT_ALERT stations" >> "$TEMP"/maxstations.$2
echo $(date) "ALERT - $TOTALCOUNT nodes connected to $2 - sent alert email to $TOTALCOUNT_EMAIL" >> $LOGFILE
mail -s "ALERT - $TOTALCOUNT stations connected to Node $2" $TOTALCOUNT_EMAIL -- -f $SENDAS < "$TEMP"/maxstations.$2
fi
#
if [ "$TOTALCOUNT" -gt "$TOTALCOUNT_ALERT" -a -n "$TOTALCOUNT_ACTION" ] ; then
echo "$(date) ALERT - Issuing action file command $TOTALCOUNT_ACTION" >> $LOGFILE
eval $TOTALCOUNT_ACTION
fi
#
# Assemble standard output
echo "$2 $STATUS $TOFROM $TYPE $NODENO [$TOTALCOUNT]" > "$SWISSARMYTEMP2"out
if [[ "$TYPE" == "Echolink" ]]
then
echo "$ECHOINFO" >> "$SWISSARMYTEMP2"out
fi
#
if [[ "$TYPE" == "Allstar" ]]
then
echo $ASNODE >> "$SWISSARMYTEMP2"out
fi

if [ -z "$SUBJECT" ]
then SUBJECT="$2 $STATUS $TOFROM $TYPE $3 [$TOTALCOUNT] $ASNODE $ECHOINFO"
fi

# Logic routines

# If announcemessage exists, play audio file. 
if [ -s "$ANNOUNCEMESSAGE"."$ANNOUNCE_EXT" -a "$STATUS" = "Connected" ] ; then
echo "$2 $3 $STATUS - Play custom announce message audio file $ANNOUNCEMESSAGE.$ANNOUNCE_EXT"
echo $(date) $2 $3 $STATUS "- play custom announce audio file $ANNOUNCEMESSAGE.$ANNOUNCE_EXT" >> $LOGFILE
sleep 10
asterisk -rx "rpt playback $2 $ANNOUNCEMESSAGE"
fi

# If Echolink station connects, play audio file
if [ -n $"ECHOLINK_WELCOME" -a "$TYPE" = "Echolink" -a "$STATUS" = "Connected" ]
then
echo "$2 $3 $STATUS - Play Echolink welcome audio file"
echo $(date) $2 $3 $STATUS "- play Echolink welcome audio file" >> $LOGFILE
sleep 10
asterisk -rx "rpt playback $2 $ECHOLINK_WELCOME"
fi

# If Echolink station connects, execute command
if [ -n "$ECHOLINK_CONN_CMD" -a "$TYPE" = "Echolink" -a "$STATUS" = "Connected" ]
then
echo "$2 $3 $STATUS - issue command on Echolink connect"
echo $(date) $2 $3 $STATUS "- issue command on Echolink connect" >> $LOGFILE
eval $ECHOLINK_CONN_CMD
fi

# If Echolink station disconnects, execute command
if [ -n "$ECHOLINK_DISC_CMD" -a "$TYPE" = "Echolink" -a "$STATUS" = "Disconnected" ]
then
echo "$2 $3 $STATUS - issue command on Echolink disconnect"
echo $(date) $2 $3 $STATUS "- issue command on Echolink disconnect" >> $LOGFILE
eval $ECHOLINK_DISC_CMD
fi

# If Allstar station connects, execute command if so configured
if [ -n "$ALLSTAR_CONN_CMD" -a "$TYPE" = "Allstar" -a "$STATUS" = "Connected" ]
then
echo "$2 $3 $STATUS - issue command on Allstar connect"
echo $(date) $2 $3 $STATUS "- issue command on Allstar connect" >> $LOGFILE
eval $ALLSTAR_CONN_CMD
fi

# If Allstar station disconnects, execute command if so configured
if [ -n "$ALLSTAR_DISC_CMD" -a "$TYPE" = "Allstar" -a "$STATUS" = "Disconnected" ]
then
echo "$2 $3 $STATUS - issue command on Allstar disconnect"
echo $(date) $2 $3 $STATUS "- issue command on Allstar disconnect" >> $LOGFILE
eval $ALLSTAR_DISC_CMD
fi

# If Extension connects, execute command
if [ -n "$EXTENSION_CONN_CMD" -a "$TYPE" = "Extension" -a "$STATUS" = "Connected" ]
then
echo "$2 $3 $STATUS - issue command on Extension connect"
echo $(date) $2 $3 $STATUS "- issue command on Extension connect" >> $LOGFILE
eval $EXTENSION_CONN_CMD
fi

# If Extension disconnects, execute command if so configured
if [ -n "$EXTENSION_DISC_CMD" -a "$TYPE" = "Extension" -a "$STATUS" = "Disconnected" ]
then
echo "$2 $3 $STATUS - issue command on Extension disconnect"
echo $(date) $2 $3 $STATUS "- issue command on Extension disconnect" >> $LOGFILE
eval $EXTENSION_DISC_CMD
fi

# Check node number action file for custom connect or disconnect actions
if [ -s "$NODENO_ACTIONFILE" -a "$TYPE" = "Allstar" -a "$STATUS" = "Disconnected" ] ; then
DISCONNECT_ACTION=$(grep -i "$3,d" "$NODENO_ACTIONFILE")
fi

if [ -s "$NODENO_ACTIONFILE" -a "$TYPE" = "Allstar" -a "$STATUS" = "Connected" ] ; then
CONNECT_ACTION=$(grep -i "$3,c" "$NODENO_ACTIONFILE")
fi

if [ -n "$CONNECT_ACTION" ] ; then
EXEC_CMD=$(echo "$CONNECT_ACTION" | cut -d, -f 3)
echo "Executing command per NODENO - $3 $STATUS $TOFROM node $2 - $EXEC_CMD"
echo $(date) $2 $3 $STATUS "- Command per $NODENO_ACTIONFILE - $EXEC_CMD" >> $LOGFILE
eval $EXEC_CMD
CONNECT_ACTION=""
EXEC_CMD=""
fi

if [ -n "$DISCONNECT_ACTION" ] ; then
EXEC_CMD=$(echo "$DISCONNECT_ACTION" | cut -d, -f 3)
echo "Executing command per NODENO - $3 $STATUS $TOFROM node $2 - $EXEC_CMD"
echo $(date) $2 $3 $STATUS "- Command per $NODENO_ACTIONFILE - $EXEC_CMD" >> $LOGFILE
eval $EXEC_CMD
DISCONNECT_ACTION=""
EXEC_CMD=""
fi

# Check Callsign action file for custom connect or disconnect actions
if [ -s "$CALLSIGN_ACTIONFILE" -a "$TYPE" = "Allstar" -a "$STATUS" = "Disconnected" ] ; then
DISCONNECT_ACTION=$(grep -i "$ALLSTARCALL,d" "$CALLSIGN_ACTIONFILE")
fi

if [ -s "$CALLSIGN_ACTIONFILE" -a "$TYPE" = "Callsign" -a "$STATUS" = "Disconnected" ] ; then
DISCONNECT_ACTION=$(grep -i "$3,d" "$CALLSIGN_ACTIONFILE")
fi

if [ -s "$CALLSIGN_ACTIONFILE" -a "$TYPE" = "Allstar" -a "$STATUS" = "Connected" ] ; then
CONNECT_ACTION=$(grep -i "$ALLSTARCALL,c" "$CALLSIGN_ACTIONFILE")
fi

if [ -s "$CALLSIGN_ACTIONFILE" -a "$STATUS" = "Connected" -a "$TYPE" = "Callsign" ] ; then
CONNECT_ACTION=$(grep -i "$3,c" "$CALLSIGN_ACTIONFILE")
fi

if [ -n "$CONNECT_ACTION" ] ; then
EXEC_CMD=$(echo "$CONNECT_ACTION" | cut -d, -f 3)
echo "Executing command per CALLSIGN - $2 $STATUS $TOFROM $TYPE $3 - $EXEC_CMD"
echo $(date) $2 $3 $STATUS "- Command per $CALLSIGN_ACTIONFILE - $EXEC_CMD" >> $LOGFILE
eval $EXEC_CMD
CONNECT_ACTION=""
EXEC_CMD=""
fi

if [ -n "$DISCONNECT_ACTION" ] ; then
EXEC_CMD=$(echo "$DISCONNECT_ACTION" | cut -d, -f 3)
echo "Executing command per CALLSIGN - $2 $STATUS $TOFROM $TYPE $3 - $EXEC_CMD"
echo $(date) $2 $3 $STATUS "- Command per $CALLSIGN_ACTIONFILE - $EXEC_CMD" >> $LOGFILE
eval $EXEC_CMD
DISCONNECT_ACTION=""
EXEC_CMD=""
fi
#
if [ -s "$BANLIST" -a "$BANRESULTS" = "$ALLSTARCALL" -a "$STATUS" = "Connected" ] ; then
echo "$ALLSTARCALL in banned list - disconnecting"
echo $(date) $2 $3 $STATUS "$ALLSTARCALL in banned list - KICKED" >> $LOGFILE
echo "$ALLSTARCALL in banned list - KICKED" > $TEMP/denied.$LOCALNODE
asterisk -rx "rpt playback $2 $ASTKICK"
echo "sleeping $BANDELAY"
sleep $BANDELAY
asterisk -rx "rpt fun $2 *1$3"
if [ "$BANLIST_DENY_ALERT" = 1 ] ; then
echo "Sending alert email to $BANLIST_DENY_EMAIL due to banned station"
echo "$(date) Sending deny alert email to $BANLIST_DENY_EMAIL" >> $LOGFILE
mail -s "$LOCALNODE ban alert" $BANLIST_DENY_EMAIL -- -f $SENDAS < "$TEMP"/denied.$LOCALNODE
fi
eval $ALLSTAR_BAN_CMD
fi

if [ -s "$BANLIST" -a "$BANRESULTS2" = "$3" -a "$STATUS" = "Connected" ] ; then
echo "Node number $3 in banned list - disconnecting"
echo $(date) $2 $3 $STATUS "$3 in banned list - KICKED" >> $LOGFILE
echo "$3 in banned list - KICKED" > $TEMP/denied.$LOCALNODE
asterisk -rx "rpt playback $2 $ASTKICK"
echo "sleeping $BANDELAY"
sleep $BANDELAY
asterisk -rx "rpt fun $2 *1$3"
if [ "$BANLIST_DENY_ALERT" = 1 ] ; then
echo "Sending alert email to $BANLIST_DENY_EMAIL due to banned station"
echo "$(date) Sending deny alert email to $BANLIST_DENY_EMAIL" >> $LOGFILE
mail -s "$LOCALNODE ban alert" $BANLIST_DENY_EMAIL -- -f $SENDAS < "$TEMP"/denied.$LOCALNODE
fi
eval $ALLSTAR_BAN_CMD
fi

if [ -s "$ACCEPTLIST" -a "$STATUS" = "Connected" -a -z "$ACCEPTRESULTS" ] ; then
echo "$NODENO / $ALLSTARCALL NOT in accept list - disconnecting"
echo $(date) $2 $3 $STATUS "$NODENO / $ALLSTARCALL NOT in accept list - KICKED" >> $LOGFILE
echo "$NODENO / $ALLSTARCALL NOT in accept list - KICKED" > $TEMP/denied.$LOCALNODE
asterisk -rx "rpt playback $2 $ASTKICK2"
echo "sleeping $BANDELAY"
sleep $BANDELAY
asterisk -rx "rpt fun $2 *1$3"
if [ "$ACCEPTLIST_DENY_ALERT" = 1 ] ; then
echo "Sending alert email to $ACCEPTLIST_DENY_EMAIL due to unaccepted station"
echo "$(date) Sending deny alert email to $ACCEPTLIST_DENY_EMAIL" >> $LOGFILE
mail -s "$LOCALNODE deny alert" $ACCEPTLIST_DENY_EMAIL -- -f $SENDAS < "$TEMP"/denied.$LOCALNODE
fi
eval $ALLSTAR_NOTACCEPTED_CMD
fi

# Additional info for Global, non-verbose results
if [ "$GLOBALINFO" == "1" -a "$VERBOSE" != "1" ] ; then
cat $SWISSARMYTEMP2 >> "$SWISSARMYTEMP2"out
fi

# Produce extra output for these features
if [ "$GLOBALINFO" == "1" -a "$VERBOSE" = "1" ] ; then
PARSEALLSTAR=$(cat $SWISSARMYTEMP2 | tr "," "\n")
for x in $PARSEALLSTAR
do
echo "${x:1:${#x}-1}" >> "$SWISSARMYTEMP2"v
done
fi

if ! [ -f "$SWISSARMYTEMP2"v ] ; then 
touch "$SWISSARMYTEMP2"v 
fi

if ! [ -f "$SWISSARMYTEMP2"n ] ; then
touch "$SWISSARMYTEMP2"n
fi

# Get nodelist details for globally connected node numbers
if [ -s "$SWISSARMYTEMP2"v ] ; then
while read line; do
if [ "$line" -eq "$line" ] 2>/dev/null; then
grep ^$line "$NODELIST" >> "$SWISSARMYTEMP2"n || echo "" >> "$SWISSARMYTEMP2"n
else
line="$line Callsign"
fi
done < "$SWISSARMYTEMP2"v
fi

# Global node info
if [ -s "$SWISSARMYTEMP2"v ] ; then
echo "----------" >> "$SWISSARMYTEMP2"out
cat "$SWISSARMYTEMP2"n | tr -s ' ' >> "$SWISSARMYTEMP2"out
fi

# Global
if [ -s "$SWISSARMYTEMP2"vo ] ; then
cat "$SWISSARMYTEMP2"vo >> "$SWISSARMYTEMP2"out
fi

# Send Asterisk Text to all showing nodes connects/disconnects - if node number
if [ "$WEBTX_TEXT" == "1" -a "$TYPE" != "Callsign" -a "$STATUS" = "Connected" -o "$STATUS" = "Disconnected" ] ; then
asterisk -rx "rpt sendall $2 $STATUS $TOFROM $TYPE $ASNODE $ECHOINFO [$TOTALCOUNT]"
fi

# Send Asterisk Text to all showing nodes connects/disconnects - if callsign
if [ "$WEBTX_TEXT" == "1" -a "$TYPE" = "Callsign" -a "$STATUS" = "Connected" -o "$STATUS" = "Disconnected" ] ; then
asterisk -rx "rpt sendall $2 $STATUS $TOFROM $TYPE $ASNODE $3 $ECHOINFO [$TOTALCOUNT]"
fi

echo "sleeping 1 second" ; sleep 1

# count number of characters in message, and split into multiple 
# messages if necessary - useful if sending text messages

charcount=($(wc -m "$SWISSARMYTEMP2"out))
echo "charcount is $charcount"

# Issue exit command if so configured
if ! [ -z "$EXIT_CMD" ] ; then
echo "Issuing exit command: $EXIT_CMD"
eval $EXIT_CMD
fi

# Exit without emailing if disable file found
if [ -f $DISABLE ]
then
echo "Operation is disabled"
trap - EXIT
cleanup
fi

if [ "$ALLSTAR_CONN_ALERTS" = "0" -a "$STATUS" = "Connected" -a "$TYPE" = "Allstar" ] ; then
echo "Allstar connect alerts disabled for node $2"
trap - EXIT
cleanup
fi

if [ "$ALLSTAR_DISC_ALERTS" = "0" -a "$STATUS" = "Disconnected" -a "$TYPE" = "Allstar" ] ; then
echo "Allstar disconnect alerts disabled for node $2"
trap - EXIT
cleanup
fi

if [ "$ECHO_CONN_ALERTS" = "0" -a "$STATUS" = "Connected" -a "$TYPE" = "Echolink" ] ; then
echo "Echolink connect alerts disabled for node $2"
trap - EXIT
cleanup
fi

if [ "$ECHO_DISC_ALERTS" = "0" -a "$STATUS" = "Disconnected" -a "$TYPE" = "Echolink" ] ; then
echo "Echolink disconnect alerts disabled for node $2"
trap - EXIT
cleanup
fi

# Split into multiple messages if necessary
split -b $TEXTMAXCHARS --verbose "$SWISSARMYTEMP2"out "$TEMP/estatus$2."

NUMFILES=$(ls -l "$TEMP"/estatus$2.* | wc -l)
echo "Message split into $NUMFILES messages"

#
SPLITVAR="a"
emailoutput

# Done
trap - EXIT
cleanup
exit 0