You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
766 lines
38 KiB
766 lines
38 KiB
#!/bin/bash
|
|
#
|
|
# Copyright (c) 2019-2020 by Thomas A. Early N7TAE
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
SetBooleanValue () {
|
|
local dvname
|
|
local cv
|
|
if [ -z $2 ]; then
|
|
if [ -z ${!1+x} ]; then
|
|
if [[ "$1" == module_[abc]_* ]]; then
|
|
echo matches
|
|
dvname=${1//_[abc]_/_x_}
|
|
else
|
|
echo does not match
|
|
dvname=${1}_d
|
|
fi
|
|
cv=${!dvname}
|
|
else
|
|
cv=${!1}
|
|
fi
|
|
if [[ $cv == [tT]* ]]; then
|
|
eval ${1}=false
|
|
else
|
|
eval ${1}=true
|
|
fi
|
|
elif [[ "$2" == [tT]* ]]; then
|
|
eval ${1}=true
|
|
else
|
|
eval ${1}=false
|
|
fi
|
|
}
|
|
|
|
EvaluateVar () {
|
|
if [ -z ${!1+x} ]; then
|
|
if [ -z "${!2}" ]; then
|
|
echo "'' <DEFAULT>"
|
|
else
|
|
echo "${!2} <DEFAULT>"
|
|
fi
|
|
else
|
|
if [ -z "${!1}" ]; then
|
|
echo "''"
|
|
else
|
|
echo "${!1}"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
EndMenu () {
|
|
echo
|
|
echo "u <key> to unset the value of key (revert to the default value)."
|
|
echo "q to return to the main menu"
|
|
read -p "Please input: <key> <new_value> # omit value to toggle a true/false : " key value
|
|
}
|
|
|
|
LinkMenu () {
|
|
key=''
|
|
while [[ "$key" != q* ]]; do
|
|
clear
|
|
echo
|
|
echo " Link/D-Plus Menu"
|
|
echo
|
|
echo " 'CSV' means Comma Separated Values (of callsigns)"
|
|
echo " An empty CVS means everybody has permission"
|
|
echo -n "ad : CSV of calls that can execute scripts = "; EvaluateVar link_admin{,_d}
|
|
echo -n "li : CSV of calls that can link and unlink = "; EvaluateVar link_link_unlink{,_d}
|
|
echo -n "n : CSV of calls that cannot link&unlink = "; EvaluateVar link_no_link_unlink{,_d}
|
|
if [ -n "$em" ]; then
|
|
echo -n "r : UDP port for REF linking = "; EvaluateVar link_ref_port{,_d}
|
|
echo -n "x : UDP port for XRF linking = "; EvaluateVar link_xrf_port{,_d}
|
|
echo -n "d : DCS port for XRF linking = "; EvaluateVar link_dcs_port{,_d}
|
|
echo -n "an : Announce linking = "; EvaluateVar link_announce{,_d}
|
|
echo -n "ac : Acknowledge link on each keyup = "; EvaluateVar link_acknowledge{,_d}
|
|
echo -n "m : Maximum # of dongles allowed = "; EvaluateVar link_max_dongles{,_d}
|
|
fi
|
|
echo
|
|
echo " Legacy D-Plus Repeaters and Reflectors"
|
|
echo -n "au : Authorize Legacy D-Plus Linking = "; EvaluateVar dplus_authorize{,_d}
|
|
echo -n "ap : DPlus Priority = "; EvaluateVar dplus_priority{,_d}
|
|
if [ -n "$em" ]; then
|
|
echo -n "lo : Login call for authorization server = "; EvaluateVar dplus_ref_login{,_d}
|
|
echo -n "RF : Add legacy reflectors to gateway list = "; EvaluateVar dplus_use_reflectors{,_d}
|
|
echo -n "RP : add legacy repeaters to gateway list = "; EvaluateVar dplus_use_repeaters{,_d}
|
|
fi
|
|
EndMenu
|
|
|
|
if [[ "$key" == ad* ]]; then link_admin="${value^^}"
|
|
elif [[ "$key" == li* ]]; then link_link_unlink="${value^^}"
|
|
elif [[ "$key" == n* ]]; then link_no_link_unlink="${value^^}"
|
|
elif [[ "$key" == r* ]]; then link_ref_port="$value"
|
|
elif [[ "$key" == x* ]]; then link_xrf_port="$value"
|
|
elif [[ "$key" == d* ]]; then link_dcs_port="$value"
|
|
elif [[ "$key" == an* ]]; then SetBooleanValue link_announce "$value"
|
|
elif [[ "$key" == ac* ]]; then SetBooleanValue link_acknowledge "$value"
|
|
elif [[ "$key" == m* ]]; then link_max_dongles="$value"
|
|
elif [[ "$key" == au* ]]; then SetBooleanValue dplus_authorize "$value"
|
|
elif [[ "$key" == ap* ]]; then SetBooleanValue dplus_priority "$value"
|
|
elif [[ "$key" == lo* ]]; then dplus_ref_login="${value^^}"
|
|
elif [[ "$key" == RF* ]]; then SetBooleanValue dplus_use_reflectors "$value"
|
|
elif [[ "$key" == RP* ]]; then SetBooleanValue dplus_use_repeaters "$value"
|
|
elif [[ "$key" == u* ]]; then
|
|
if [[ "$value" == ad* ]]; then unset link_admin
|
|
elif [[ "$value" == li* ]]; then unset link_link_unlink
|
|
elif [[ "$value" == n* ]]; then unset link_no_link_unlink
|
|
elif [[ "$value" == r* ]]; then unset link_ref_port
|
|
elif [[ "$value" == x* ]]; then unset link_xrf_port
|
|
elif [[ "$value" == d* ]]; then unset link_dcs_port
|
|
elif [[ "$value" == an* ]]; then unset link_announce
|
|
elif [[ "$value" == ac* ]]; then unset link_acknowledge
|
|
elif [[ "$value" == m* ]]; then unset link_max_dongles
|
|
elif [[ "$value" == au* ]]; then unset dplus_authorize
|
|
elif [[ "$value" == ap* ]]; then unset dplus_priority
|
|
elif [[ "$value" == lo* ]]; then unset dplus_ref_login
|
|
elif [[ "$value" == RF* ]]; then unset dplus_use_reflectors
|
|
elif [[ "$value" == RP* ]]; then unset dplus_use_repeaters
|
|
fi
|
|
fi
|
|
done
|
|
}
|
|
|
|
DashboardMenu () {
|
|
key=''
|
|
while [[ "$key" != q* ]]; do
|
|
clear
|
|
echo
|
|
echo " Dashboard Menu"
|
|
echo
|
|
echo -n "r : Refresh time (sec) for page = "; EvaluateVar dash_refresh{,_d}
|
|
echo -n "c : Max number of last heard entries = "; EvaluateVar dash_lastheard_count{,_d}
|
|
echo -n "o : Show Section Order = "; EvaluateVar dash_show_order{,_d}
|
|
echo
|
|
echo " The 'Show Section' is a comma separated value, e.g. 'lh,mo,sy,ip,ps,ur'"
|
|
echo " The following sections can be shown in any order. It's okay to leave out sections."
|
|
echo " Don't use spaces, just use commas. Lowercase will be set to uppercase."
|
|
echo
|
|
echo " LH is the Last Heard Section"
|
|
echo " MO is the Modules Section"
|
|
echo " SY is the System Section"
|
|
echo " IP is the IP Address Section"
|
|
echo " PS is the Processes Section"
|
|
echo " UR is the Send URCall Section"
|
|
EndMenu
|
|
|
|
if [[ "$key" == r* ]]; then dash_refresh="$value"
|
|
elif [[ "$key" == c* ]]; then dash_lastheard_count="$value"
|
|
elif [[ "$key" == o* ]]; then dash_show_order="${value^^}"
|
|
elif [[ "$key" == u* ]]; then
|
|
if [[ "$value" == r* ]]; then unset dash_refresh
|
|
elif [[ "$value" == c* ]]; then unset dash_lastheard_count
|
|
elif [[ "$value" == o* ]]; then unset dash_show_order
|
|
fi
|
|
fi
|
|
done
|
|
}
|
|
|
|
FileMenu () {
|
|
key=''
|
|
while [[ "$key" != q* ]]; do
|
|
clear
|
|
echo
|
|
if [ -z "$em" ]; then
|
|
echo " Debugging Menu"
|
|
else
|
|
echo " Debugging/Files/Timings Menu"
|
|
fi
|
|
echo
|
|
echo " Additional entries in log files (in /usr/local/var)"
|
|
echo -n "cl : Call(QSO) logging = "; EvaluateVar log_qso{,_d}
|
|
echo -n "il : IRC logging = "; EvaluateVar log_irc{,_d}
|
|
echo -n "dl : DTMF logging = "; EvaluateVar log_dtmf{,_d}
|
|
echo -n "xl : Debug logging = "; EvaluateVar log_debug{,_d}
|
|
echo " WARNING debug logging can produce large log file!"
|
|
if [ -n "$em" ]; then
|
|
echo
|
|
echo " Files and directories"
|
|
echo -n "sf : Repeater status file = "; EvaluateVar file_status{,_d}
|
|
echo -n "ed : Echo/Voicemail directory = "; EvaluateVar file_echotest{,_d}
|
|
echo -n "dd : DTMF directory = "; EvaluateVar file_dtmf{,_d}
|
|
echo -n "vf : QnetVoice filename = "; EvaluateVar file_qnvoicefile{,_d}
|
|
echo -n "gf : Gateways filename = "; EvaluateVar file_gwys{,_d}
|
|
echo -n "ad : Announce directory = "; EvaluateVar file_announce_dir{,_d}
|
|
echo
|
|
echo " Timing controls"
|
|
echo -n "et : Echo timeout (sec) = "; EvaluateVar timing_timeout_echo{,_d}
|
|
echo -n "vt : Voicemail timeout (sec) = "; EvaluateVar timing_timeout_voicemail{,_d}
|
|
echo -n "gt : G2 timeout (sec) = "; EvaluateVar timing_timeout_remote_g2{,_d}
|
|
echo -n "rt : Repeater timeout (sec) = "; EvaluateVar timing_timeout_local_rptr{,_d}
|
|
echo -n "pw : Echo play wait (sec) = "; EvaluateVar timing_play_wait{,_d}
|
|
echo -n "pd : Echo play delay (msec) = "; EvaluateVar timing_play_delay{,_d}
|
|
fi
|
|
EndMenu
|
|
|
|
if [[ "$key" == sf* ]]; then file_status="$value"
|
|
elif [[ "$key" == ed* ]]; then file_echotest="$value"
|
|
elif [[ "$key" == dd* ]]; then file_dtmf="$value"
|
|
elif [[ "$key" == vf* ]]; then file_qnvoicefile="$value"
|
|
elif [[ "$key" == gf* ]]; then file_gwys="$value"
|
|
elif [[ "$key" == ad* ]]; then file_announce_dir="$value"
|
|
elif [[ "$key" == cl* ]]; then SetBooleanValue log_qso "$value"
|
|
elif [[ "$key" == il* ]]; then SetBooleanValue log_irc "$value"
|
|
elif [[ "$key" == dl* ]]; then SetBooleanValue log_dtmf "$value"
|
|
elif [[ "$key" == xl* ]]; then SetBooleanValue log_debug "$value"
|
|
elif [[ "$key" == et* ]]; then timing_timeout_echo="$value"
|
|
elif [[ "$key" == vt* ]]; then timing_timeout_voicemail="$value"
|
|
elif [[ "$key" == gt* ]]; then timing_timeout_remote_g2="$value"
|
|
elif [[ "$key" == rt* ]]; then timing_timeout_local_rptr="$value"
|
|
elif [[ "$key" == pw* ]]; then timing_play_wait="$value"
|
|
elif [[ "$key" == pd* ]]; then timing_play_delay="$value"
|
|
elif [[ "$key" == u* ]]; then
|
|
if [[ "$value" == sf* ]]; then unset file_status
|
|
elif [[ "$value" == ed* ]]; then unset file_echotest
|
|
elif [[ "$value" == dd* ]]; then unset file_dtmf
|
|
elif [[ "$value" == vf* ]]; then unset file_qnvoicefile
|
|
elif [[ "$value" == gf* ]]; then unset file_gwys
|
|
elif [[ "$value" == ad* ]]; then unset file_announce_dir
|
|
elif [[ "$value" == cl* ]]; then unset log_qso
|
|
elif [[ "$value" == il* ]]; then unset log_irc
|
|
elif [[ "$value" == dl* ]]; then unset log_dtmf
|
|
elif [[ "$value" == xl* ]]; then unset log_debug
|
|
elif [[ "$value" == et* ]]; then unset timing_timeout_echo
|
|
elif [[ "$value" == vt* ]]; then unset timing_timeout_voicemail
|
|
elif [[ "$value" == gt* ]]; then unset timing_timeout_remote_g2
|
|
elif [[ "$value" == rt* ]]; then unset timing_timeout_local_rptr
|
|
elif [[ "$value" == pw* ]]; then unset timing_play_wait
|
|
elif [[ "$value" == pd* ]]; then unset timing_play_delay
|
|
fi
|
|
fi
|
|
done
|
|
}
|
|
|
|
IrcddbMenu () {
|
|
key=''
|
|
while [[ "$key" != q* ]]; do
|
|
clear
|
|
echo
|
|
echo " IRCDDB Menu"
|
|
echo
|
|
echo "Routes to other clients using IRC Server A will be searched first"
|
|
echo
|
|
echo "l : Login - must be a legal callsign = '${ircddb_login}'"
|
|
echo -n "ha : Hostname for IRC Server A = "; EvaluateVar ircddb0_host{,_d}
|
|
if [ -n "$em" ]; then
|
|
echo -n "oa : IRC TCP port A = "; EvaluateVar ircddb0_port{,_d}
|
|
echo -n "aa : IRC Password A = "; EvaluateVar ircddb0_password{,_d}
|
|
fi
|
|
echo -n "hb : Hostname for IRC Server B = "; EvaluateVar ircddb1_host{,_d}
|
|
if [ -n "$em" ]; then
|
|
echo -n "ob : IRC TCP port B = "; EvaluateVar ircddb1_port{,_d}
|
|
echo -n "ab : IRC Password B = "; EvaluateVar ircddb1_password{,_d}
|
|
fi
|
|
EndMenu
|
|
|
|
if [[ "$key" == l* ]]; then ircddb_login="${value^^}"
|
|
elif [[ "$key" == ha* ]]; then
|
|
if [ -z "$value"]; then
|
|
if [ -z "${ircddb1_host+x}" ]; then
|
|
ircddb0_host=''
|
|
else
|
|
echo "You cannot set an empty value for ha unless hb has its default value"
|
|
read -p "<Enter> to continue: " garbage
|
|
fi
|
|
elif [[ "$value" =~ ^([a-zA-Z0-9]+\.)+[a-zA-Z0-9]+$ ]]; then
|
|
ircddb0_host="$value"
|
|
else
|
|
clear
|
|
echo "$value is not a valid hostname"
|
|
read -p "<Enter> to continue: " garbage
|
|
fi
|
|
elif [[ "$key" == oa* ]]; then ircddb0_port="$value"
|
|
elif [[ "$key" == aa* ]]; then ircddb0_password="$value"
|
|
elif [[ "$key" == hb* ]]; then
|
|
if [[ "$value" =~ ^([a-zA-Z0-9]+\.)+[a-zA-Z0-9]+$ ]]; then
|
|
ircddb1_host="$value"
|
|
else
|
|
clear
|
|
echo "$value is not a valid hostname"
|
|
read -p "<Enter> to continue: " garbage
|
|
fi
|
|
elif [[ "$key" == ob* ]]; then ircddb1_port="$value"
|
|
elif [[ "$key" == ab* ]]; then ircddb1_password="$value"
|
|
elif [[ "$key" == u* ]]; then
|
|
if [[ "$value" == l* ]]; then unset ircddb_login
|
|
elif [[ "$value" == ha* ]]; then unset ircddb0_host
|
|
elif [[ "$value" == oa* ]]; then unset ircddb0_port
|
|
elif [[ "$value" == aa* ]]; then unset ircddb0_password
|
|
elif [[ "$value" == hb* ]]; then unset ircddb1_host
|
|
elif [[ "$value" == ob* ]]; then unset ircddb1_port
|
|
elif [[ "$value" == ab* ]]; then unset ircddb1_password
|
|
fi
|
|
fi
|
|
done
|
|
}
|
|
|
|
GateMenu () {
|
|
key=''
|
|
while [[ "$key" != q* ]]; do
|
|
clear
|
|
echo
|
|
echo " Gateway/APRS Menu"
|
|
echo
|
|
echo " Gateway Option"
|
|
if [ -n "$em" ]; then
|
|
echo -n "r : Regenerate Headers = "; EvaluateVar gateway_header_regen{,_d}
|
|
echo -n "s : Send IRC network Module Info = "; EvaluateVar gateway_send_qrgs_maps{,_d}
|
|
echo -n "i : IRC TCP local network address = "; EvaluateVar gateway_local_irc_ip{,_d}
|
|
echo -n "a : G2 port address = "; EvaluateVar gateway_ip{,_d}
|
|
echo -n "p : G2 port number = "; EvaluateVar gateway_port{,_d}
|
|
fi
|
|
echo -n "la : Latitude (-90.0 to 90.0) = "; EvaluateVar gateway_latitude{,_d}
|
|
echo -n "lo : Longitude (-180.0 to 180.0) = "; EvaluateVar gateway_longitude{,_d}
|
|
echo -n "d1 : Description #1 (20 chars max) = "; EvaluateVar gateway_desc1{,_d}
|
|
echo -n "d2 : Description #1 (20 chars max) = "; EvaluateVar gateway_desc2{,_d}
|
|
echo -n "w : URL (80 char max) = "; EvaluateVar gateway_url{,_d}
|
|
echo -n "fr : Find Route(s) = "; EvaluateVar gateway_find_route{,_d}
|
|
echo " Find Route(s) is a comma-separated list of common routing callsigns."
|
|
echo " These will be added to your local cache on boot-up."
|
|
echo
|
|
echo " APRS - Repeater/User position tracking"
|
|
echo -n "e : Enable APRS Tracking = "; EvaluateVar aprs_enable{,_d}
|
|
if [ -n "$em" ]; then
|
|
echo -n "h : APRS hostname = "; EvaluateVar aprs_host{,_d}
|
|
echo -n "ap : APRS TCP port number = "; EvaluateVar aprs_port{,_d}
|
|
echo -n "k : APRS Keep-alive interval (min) = "; EvaluateVar aprs_interval{,_d}
|
|
echo -n "af : APRS Filter (experimental) = "; EvaluateVar aprs_filter{,_d}
|
|
fi
|
|
EndMenu
|
|
|
|
if [[ "$key" == r* ]]; then SetBooleanValue gateway_header_regen "$value"
|
|
elif [[ "$key" == s* ]]; then SetBooleanValue gateway_send_qrgs_maps "$value"
|
|
elif [[ "$key" == i* ]]; then gateway_local_irc_ip="$value"
|
|
elif [[ "$key" == a* ]]; then gateway_ip="$value"
|
|
elif [[ "$key" == p* ]]; then gateway_port="$value"
|
|
elif [[ "$key" == la* ]]; then gateway_latitude="$value"
|
|
elif [[ "$key" == lo* ]]; then gateway_longitude="$value"
|
|
elif [[ "$key" == d1* ]]; then gateway_desc1="${value:0:20}"
|
|
elif [[ "$key" == d2* ]]; then gateway_desc2="${value:0:20}"
|
|
elif [[ "$key" == w* ]]; then gateway_url="${value:0:80}"
|
|
elif [[ "$key" == fr* ]]; then gateway_find_route="${value^^}"
|
|
elif [[ "$key" == e* ]]; then SetBooleanValue aprs_enable "$value"
|
|
elif [[ "$key" == h* ]]; then aprs_host="$value"
|
|
elif [[ "$key" == ap* ]]; then aprs_port="$value"
|
|
elif [[ "$key" == k* ]]; then aprs_interval="$value"
|
|
elif [[ "$key" == af* ]]; then aprs_filter="$value"
|
|
elif [[ "$key" == u* ]]; then
|
|
if [[ "$value" == r* ]]; then unset gateway_header_regen
|
|
elif [[ "$value" == s* ]]; then unset gateway_send_qrgs_maps
|
|
elif [[ "$value" == i* ]]; then unset gateway_local_irc_ip
|
|
elif [[ "$value" == a* ]]; then unset gateway_ip
|
|
elif [[ "$value" == p* ]]; then unset gateway_port
|
|
elif [[ "$value" == la* ]]; then unset gateway_latitude
|
|
elif [[ "$value" == lo* ]]; then unset gateway_longitude
|
|
elif [[ "$value" == d1* ]]; then unset gateway_desc1
|
|
elif [[ "$value" == d2* ]]; then unset gateway_desc2
|
|
elif [[ "$value" == w* ]]; then unset gateway_url
|
|
elif [[ "$value" == fr* ]]; then unset gateway_find_route
|
|
elif [[ "$value" == e* ]]; then unset aprs_enable
|
|
elif [[ "$value" == h* ]]; then unset aprs_host
|
|
elif [[ "$value" == ap* ]]; then unset aprs_port
|
|
elif [[ "$value" == k* ]]; then unset aprs_interval
|
|
elif [[ "$value" == af* ]]; then unset aprs_filter
|
|
fi
|
|
fi
|
|
done
|
|
}
|
|
|
|
ModuleMenu () {
|
|
mod=module_${1}
|
|
if [[ $1 == a ]]; then
|
|
nmod='a'
|
|
elif [[ $1 == b ]]; then
|
|
nmod='b'
|
|
else
|
|
nmod='c'
|
|
fi
|
|
clear
|
|
if [ -z ${!mod} ]; then
|
|
echo
|
|
echo " Select a Module type"
|
|
echo
|
|
echo "1 : DVAP Dongle"
|
|
echo "2 : DVRPTR V1"
|
|
echo "3 : ICOM Terminal and Access Point Mode"
|
|
echo "4 : MMDVM Modem (like DVMega or ZUMspot) D-Star ONLY!"
|
|
echo "5 : MMDVMHost-based Sytem - Requires MMDVMHost"
|
|
echo
|
|
echo " Anything else will return without selecting"
|
|
echo
|
|
echo -n "Select Module Type : "
|
|
read key unused
|
|
if [[ "$key" == 1 ]]; then eval ${mod}=dvap
|
|
elif [[ "$key" == 2 ]]; then eval ${mod}=dvrptr
|
|
elif [[ "$key" == 3 ]]; then eval ${mod}=itap
|
|
elif [[ "$key" == 4 ]]; then eval ${mod}=mmdvmmodem
|
|
elif [[ "$key" == 5 ]]; then eval ${mod}=mmdvmhost
|
|
else return
|
|
fi
|
|
fi
|
|
key=''
|
|
while [[ "$key" != q* ]]; do
|
|
clear
|
|
echo
|
|
echo " Module ${1^^} Menu ($mod=${!mod})"
|
|
echo
|
|
echo -n "ls : Link at startup (must be 8 chars) = "; EvaluateVar {${mod},module_x}_link_at_start
|
|
if [ -n "$em" ]; then
|
|
echo -n "ar : Auto relink in the case of a timeout = "; EvaluateVar {${mod},module_x}_auto_link
|
|
fi
|
|
echo -n "cs : Callsign (uses ircddb_login if empty) = "; EvaluateVar {${mod},module_x}_callsign
|
|
echo -n "ra : Range (in meters, 1 mile=1609.344 meters) = "; EvaluateVar {${mod},module_x}_range
|
|
echo -n "ag : Above ground level (in meters) = "; EvaluateVar {${mod},module_x}_agl
|
|
if [ -n "$em" ]; then
|
|
echo -n "in : Inactivity for this many minutes unlinks = "; EvaluateVar {${mod},module_x}_inactivity
|
|
echo -n "ac : Send acknowledgment on each transmission = "; EvaluateVar {${mod},module_x}_acknowledge
|
|
echo -n "ad : acknowledgment delay (in msec) = "; EvaluateVar {${mod},module_x}_ack_delay
|
|
echo -n "pw : in msec, packet wait time (test for timeout) = "; EvaluateVar {${mod},module_x}_packet_wait
|
|
echo -n "hf : is an HF module = "; EvaluateVar {${mod},module_x}_is_hf
|
|
fi
|
|
if [[ "${!mod}" == 'dvap' ]]; then
|
|
echo -n "fr : Frequency in MHz = "; EvaluateVar {${mod},dvap}_frequency
|
|
echo -n "of : Offset in Hz = "; EvaluateVar {${mod},dvap}_offset
|
|
echo -n "po : Power (in dBm from -12 to 10) = "; EvaluateVar {${mod},dvap}_power
|
|
echo -n "sq : Squelch (in dBm from -128 to -45) = "; EvaluateVar {${mod},dvap}_squelch
|
|
echo " You MUST specify either a serial number or a device path!"
|
|
echo -n "dv : Device path (/dev/ttyUSBx) = "; EvaluateVar {${mod},dvap}_device
|
|
echo -n "sn : Serial # (visible through the case) = "; EvaluateVar {${mod},dvap}_serial_number
|
|
elif [[ "${!mod}" == 'dvrptr' ]]; then
|
|
echo -n "tx : Transmit frequency, in MHz = "; EvaluateVar {${mod},dvrptr}_tx_frequency
|
|
echo -n "rx : Receive frequency, in MHz = "; EvaluateVar {${mod},dvrtpr}_rx_frequency
|
|
echo -n "sn : Serial # (run once and look in log) = "; EvaluateVar {${mod},dvrptr}_serial_number
|
|
echo -n "rn : Callsign to turn RF on = "; EvaluateVar {${mod},dvrptr}_rf_on
|
|
echo -n "rf : Callsign to turn RF off = "; EvaluateVar {${mod},dvrptr}_rf_off
|
|
echo -n "rl : Receiver level = "; EvaluateVar {${mod},dvrptr}_rx_level
|
|
echo -n "du : Is duplex = "; EvaluateVar {${mod},dvrptr}_duplex
|
|
echo -n "td : Transmitter delay (in msec) for tx/rx switch = "; EvaluateVar {${mod},dvrptr}_tx_delay
|
|
echo -n "rq : # of 2 sec interval before system reset = "; EvaluateVar {${mod},dvrptr}_rqst_count
|
|
echo -n "ir : Inverse phase of receiver = "; EvaluateVar {${mod},dvrptr}_rx_invert
|
|
echo -n "it : Inverse phase of transmitter = "; EvaluateVar {${mod},dvrptr}_tx_invert
|
|
elif [[ "${!mod}" == 'itap' ]]; then
|
|
echo -n "fr : Frequency in MHz = "; EvaluateVar {${mod},itap}_frequency
|
|
echo -n "dv : USB device path = "; EvaluateVar {${mod},itap}_device
|
|
echo -n "ap : Set to true if using Access Point Mode = "; EvaluateVar {${mod},itap}_ap_mode
|
|
elif [[ "${!mod}" == 'mmdvmhost' ]]; then
|
|
echo -n "tx : Transmit frequency, in MHz = "; EvaluateVar {${mod},mmdvmhost}_tx_frequency
|
|
echo -n "rx : Receive frequency, in MHz = "; EvaluateVar {${mod},mmdvmhost}_rx_frequency
|
|
echo -n "ip : Internal IP address = "; EvaluateVar {${mod},mmdvmhost}_internal_ip
|
|
echo -n "gp : Gateway port number = "; EvaluateVar {${mod},mmdvmhost}_gateway_port
|
|
echo -n "lp : Local port number = "; EvaluateVar {${mod},mmdvmhost}_local_port
|
|
elif [[ "${!mod}" == 'mmdvmmodem' ]]; then
|
|
echo -n "dv : Device path = "; EvaluateVar {${mod},mmdvmmodem}_device
|
|
echo -n "tx : Transmit frequency, in MHz = "; EvaluateVar {${mod},mmdvmmodem}_tx_frequency
|
|
echo -n "rx : Receive frequency, in MHz = "; EvaluateVar {${mod},mmdvmmodem}_rx_frequency
|
|
echo -n "to : Transmit offset, in MHz = "; EvaluateVar {${mod},mmdvmmodem}_tx_offset
|
|
echo -n "r0 : Receive offset, in MHz = "; EvaluateVar {${mod},mmdvmmodem}_rx_offset
|
|
echo -n "du : Is duplex = "; EvaluateVar {${mod},mmdvmmodem}_duplex
|
|
if [ -n "$em" ]; then
|
|
echo -n "it : Transmit invert = "; EvaluateVar {${mod},mmdvmmodem}_tx_invert
|
|
echo -n "ir : Receive invert = "; EvaluateVar {${mod},mmdvmmodem}_rx_invert
|
|
echo -n "pi : PTT invert = "; EvaluateVar {${mod},mmdvmmodem}_ptt_invert
|
|
echo -n "td : Transmit delay (in msec) for tx/rx switch = "; EvaluateVar {${mod},mmdvmmodem}_tx_delay
|
|
echo -n "tl : Transmit level (0-255) = "; EvaluateVar {${mod},mmdvmmodem}_tx_level
|
|
echo -n "rl : Receive level (0-255) = "; EvaluateVar {${mod},mmdvmmodem}_rx_level
|
|
fi
|
|
fi
|
|
echo "xx : Delete this module"
|
|
EndMenu
|
|
|
|
if [[ "$key" == ls* ]]; then
|
|
value="${value:0:8}"
|
|
eval ${mod}_link_at_start="'${value^^}'"
|
|
elif [[ "$key" == ac* ]]; then SetBooleanValue ${mod}_acknowledge "$value"
|
|
elif [[ "$key" == ad* ]]; then eval ${mod}_ack_delay="$value"
|
|
elif [[ "$key" == ap* ]]; then SetBooleanValue ${mod}_ap_mode "$value"
|
|
elif [[ "$key" == ag* ]]; then eval ${mod}_agl="$value"
|
|
elif [[ "$key" == ar* ]]; then SetBooleanValue ${mod}_auto_link "$value"
|
|
elif [[ "$key" == cs* ]]; then eval ${mod}_callsign="${value^^}"
|
|
elif [[ "$key" == du* ]]; then SetBooleanValue ${mod}_duplex "$value"
|
|
elif [[ "$key" == dv* ]]; then
|
|
eval ${mod}_device="$value"
|
|
unset ${mod}_serial_number
|
|
elif [[ "$key" == fr* ]]; then eval ${mod}_frequency="$value"
|
|
elif [[ "$key" == gp* ]]; then eval ${mod}_gateway_port="$value"
|
|
elif [[ "$key" == hf* ]]; then SetBooleanValue ${mod}_is_hf "$value"
|
|
elif [[ "$key" == in* ]]; then eval ${mod}_inactivity="$value"
|
|
elif [[ "$key" == ir* ]]; then SetBooleanValue ${mod}_rx_invert "$value"
|
|
elif [[ "$key" == ip* ]]; then eval ${mod}_internal_ip="$value"
|
|
elif [[ "$key" == it* ]]; then SetBooleanValue ${mod}_tx_invert "$value"
|
|
elif [[ "$key" == lp* ]]; then eval ${mod}_local_port="$value"
|
|
elif [[ "$key" == of* ]]; then eval ${mod}_offset="$value"
|
|
elif [[ "$key" == pi* ]]; then SetBooleanValue ${mod}_ptt_invert="$value"
|
|
elif [[ "$key" == po* ]]; then eval ${mod}_power="$value"
|
|
elif [[ "$key" == pw* ]]; then eval ${mod}_packet_wait="$value"
|
|
elif [[ "$key" == ra* ]]; then eval ${mod}_range="$value"
|
|
elif [[ "$key" == rf* ]]; then eval ${mod}_rf_off="$value"
|
|
elif [[ "$key" == rl* ]]; then eval ${mod}_rx_level="$value"
|
|
elif [[ "$key" == rn* ]]; then eval ${mod}_rf_on="$value"
|
|
elif [[ "$key" == ro* ]]; then eval ${mod}_rx_offset="$value"
|
|
elif [[ "$key" == rq* ]]; then eval ${mod}_rqst_count="$value"
|
|
elif [[ "$key" == rx* ]]; then eval ${mod}_rx_frequency="$value"
|
|
elif [[ "$key" == sn* ]]; then
|
|
eval ${mod}_serial_number="${value^^}"
|
|
unset {$mod}_device
|
|
elif [[ "$key" == sq* ]]; then eval ${mod}_squelch="$value"
|
|
elif [[ "$key" == td* ]]; then eval ${mod}_tx_delay="$value"
|
|
elif [[ "$key" == tl* ]]; then eval ${mod}_tx_level="$value"
|
|
elif [[ "$key" == to* ]]; then eval ${mod}_tx_offset="$value"
|
|
elif [[ "$key" == tx* ]]; then eval ${mod}_tx_frequency="$value"
|
|
elif [[ "$key" == xx* ]]; then
|
|
unset ${mod}_{link_at_start,callsign,{,rx_,tx_}frequency,offset,range,agl}
|
|
unset ${mod}_{inactivity,packet_wait,acknowledge,ack_delay,power,squelch,serial_number,rf_o{n,ff},{r,t}x_level}
|
|
unset ${mod}_{duplex,tx_delay,rqst_count,{tx,rx,ptt}_invert,device,internal_ip,{gateway,local}_port}
|
|
unset ${mod}_{tx_offset,rx_offset,auto_link,ap_mode}
|
|
unset ${mod}
|
|
return
|
|
elif [[ "$key" == u* ]]; then
|
|
if [[ "$value" == ac* ]]; then unset ${mod}_acknowledge
|
|
elif [[ "$value" == ad* ]]; then unset ${mod}_ack_delay
|
|
elif [[ "$value" == ap* ]]; then unset ${mod}_ap_mode
|
|
elif [[ "$value" == ar* ]]; then unset ${mod}_auto_link
|
|
elif [[ "$value" == ag* ]]; then unset ${mod}_agl
|
|
elif [[ "$value" == cs* ]]; then unset ${mod}_callsign
|
|
elif [[ "$value" == du* ]]; then unset ${mod}_duplex
|
|
elif [[ "$value" == dv* ]]; then unset ${mod}_device
|
|
elif [[ "$value" == fr* ]]; then unset ${mod}_frequency
|
|
elif [[ "$value" == gp* ]]; then unset ${mod}_gateway_port
|
|
elif [[ "$value" == in* ]]; then unset ${mod}_inactivity
|
|
elif [[ "$value" == ir* ]]; then unset ${mod}_rx_invert
|
|
elif [[ "$value" == ip* ]]; then unset ${mod}_internal_ip
|
|
elif [[ "$value" == it* ]]; then unset ${mod}_tx_invert
|
|
elif [[ "$value" == lp* ]]; then unset ${mod}_local_port
|
|
elif [[ "$value" == ls* ]]; then unset ${mod}_link_at_start
|
|
elif [[ "$value" == of* ]]; then unset ${mod}_offset
|
|
elif [[ "$value" == pi* ]]; then unset ${mod}_ppt_invert
|
|
elif [[ "$value" == po* ]]; then unset ${mod}_power
|
|
elif [[ "$value" == pw* ]]; then unset ${mod}_packet_wait
|
|
elif [[ "$value" == ra* ]]; then unset ${mod}_range
|
|
elif [[ "$value" == rf* ]]; then unset ${mod}_rf_off
|
|
elif [[ "$value" == rl* ]]; then unset ${mod}_rx_level
|
|
elif [[ "$value" == rn* ]]; then unset ${mod}_rf_on
|
|
elif [[ "$value" == ro* ]]; then unset ${mod}_rx_offset
|
|
elif [[ "$value" == rq* ]]; then unset ${mod}_rqst_count
|
|
elif [[ "$value" == rx* ]]; then unset ${mod}_rx_frequency
|
|
elif [[ "$value" == sn* ]]; then unset ${mod}_serial_number
|
|
elif [[ "$value" == sq* ]]; then unset ${mod}_squelch
|
|
elif [[ "$value" == td* ]]; then unset ${mod}_tx_delay
|
|
elif [[ "$value" == tl* ]]; then unset ${mod}_tx_level
|
|
elif [[ "$value" == to* ]]; then unset ${mod}_tx_offset
|
|
elif [[ "$value" == tx* ]]; then unset ${mod}_tx_frequency
|
|
fi
|
|
fi
|
|
done
|
|
}
|
|
|
|
WriteCFGFile () {
|
|
local m p q outFile
|
|
if [ -z "$ircddb_login" ]; then
|
|
echo "You MUST set your ircddb login callsign (in the ircddb section)!"
|
|
read -p "Press <Enter> to continue: " ans
|
|
return
|
|
fi
|
|
outFile='./qn.cfg'
|
|
echo "# Created on `date`" > $outFile
|
|
# ircddb_ section
|
|
echo "ircddb_login='$ircddb_login'" >> $outFile
|
|
[ -z "${ircddb0_host+x}" ] || echo "ircddb0_host='${ircddb0_host}'" >> $outFile
|
|
[ -z "${ircddb0_port+x}" ] || echo "ircddb0_port=${ircddb0_port}" >> $outFile
|
|
[ -z "${ircddb0_password+x}" ] || echo "ircddb0_password='${ircddb0_password}'" >> $outFile
|
|
[ -z "${ircddb1_host+x}" ] || echo "ircddb1_host='${ircddb1_host}'" >> $outFile
|
|
[ -z "${ircddb1_port+x}" ] || echo "ircddb1_port=${ircddb1_port}" >> $outFile
|
|
[ -z "${ircddb1_password+x}" ] || echo "ircddb1_password='${ircddb1_password}'" >> $outFile
|
|
|
|
# module_?_ section
|
|
for m in a b c
|
|
do
|
|
p="module_$m"
|
|
if [ -n "${!p}" ]; then
|
|
echo "${p}=${!p}" >> $outFile
|
|
q=${p}_link_at_start; [ -z ${!q+x} ] || echo "${q}='${!q}'" >> $outFile
|
|
q=${p}_auto_link; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_callsign; [ -z ${!q+x} ] || echo "${q}='${!q}'" >> $outFile
|
|
q=${p}_offset; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_range; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_agl; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_inactivity; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_packet_wait; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_acknowledge; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_ack_delay; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_is_hf; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
if [[ "${!p}" == "dvap" ]]; then
|
|
q=${p}_frequency; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_power; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_squelch; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_serial_number; [ -z ${!q+x} ] || echo "${q}='${!q}'" >> $outFile
|
|
elif [[ "${!p}" == "dvrptr" ]]; then
|
|
q=${p}_tx_frequency; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_rx_frequency; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_serial_number; [ -z ${!q+x} ] || echo "${q}='${!q}'" >> $outFile
|
|
q=${p}_rf_on; [ -z ${!q+x} ] || echo "${q}='${!q}'" >> $outFile
|
|
q=${p}_rf_off; [ -z ${!q+x} ] || echo "${q}='${!q}'" >> $outFile
|
|
q=${p}_rx_level; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_duplex; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_tx_delay; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_rqst_count; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_tx_invert; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_rx_invert; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
elif [[ "${!p}" == "itap" ]]; then
|
|
q=${p}_frequency; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_device; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_ap_mode; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
elif [[ "${!p}" == "mmdvmhost" ]]; then
|
|
q=${p}_tx_frequency; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_rx_frequency; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_internal_ip; [ -z ${!q+x} ] || echo "${q}='${!q}'" >> $outFile
|
|
q=${p}_gateway_port; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_local_port; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
elif [[ "${!p}" == "mmdvmmodem" ]]; then
|
|
q=${p}_tx_frequency; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_rx_frequency; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_tx_offset; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_rx_offset; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_duplex; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_rx_level; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_tx_level; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_tx_invert; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_rx_invert; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_ptt_invert; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_tx_delay; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
q=${p}_device; [ -z ${!q+x} ] || echo "${q}=${!q}" >> $outFile
|
|
fi
|
|
fi
|
|
done
|
|
# gateway_section
|
|
[ -z "${gateway_header_regen+x}" ] || echo "gateway_header_regen=${gateway_header_regen}" >> $outFile
|
|
[ -z "${gateway_send_qrgs_maps+x}" ] || echo "gateway_send_qrgs_maps=${gateway_send_qrgs_maps}" >> $outFile
|
|
[ -z "${gateway_local_irc_ip+x}" ] || echo "gateway_local_irc_ip='${gateway_local_irc_ip}'" >> $outFile
|
|
[ -z "${gateway_port+x}" ] || echo "gateway_port=${gateway_port}" >> $outFile
|
|
[ -z "${gateway_ip+x}" ] || echo "gateway_ip=${gateway_ip}" >> $outFile
|
|
[ -z "${gateway_latitude+x}" ] || echo "gateway_latitude=${gateway_latitude}" >> $outFile
|
|
[ -z "${gateway_longitude+x}" ] || echo "gateway_longitude=${gateway_longitude}" >> $outFile
|
|
[ -z "${gateway_desc1+x}" ] || echo "gateway_desc1='${gateway_desc1}'" >> $outFile
|
|
[ -z "${gateway_desc2+x}" ] || echo "gateway_desc2='${gateway_desc2}'" >> $outFile
|
|
[ -z "${gateway_url+x}" ] || echo "gateway_url='${gateway_url}'" >> $outFile
|
|
[ -z "${gateway_find_route+x}" ] || echo "gateway_find_route='${gateway_find_route}'" >> $outFile
|
|
# arps_ section
|
|
[ -z "${aprs_enable+x}" ] || echo "aprs_enable=${aprs_enable}" >> $outFile
|
|
[ -z "${aprs_host+x}" ] || echo "aprs_host='${aprs_host}'" >> $outFile
|
|
[ -z "${aprs_port+x}" ] || echo "aprs_port=${aprs_port}" >> $outFile
|
|
[ -z "${aprs_interval+x}" ] || echo "aprs_interval=${aprs_interval}" >> $outFile
|
|
[ -z "${aprs_filter+x}" ] || echo "aprs_filter='${aprs_filter}'" >> $outFile
|
|
# link_ section
|
|
[ -z "${link_admin+x}" ] || echo "link_admin='${link_admin}'" >> $outFile
|
|
[ -z "${link_link_unlink+x}" ] || echo "link_link_unlink='${link_link_unlink}'" >> $outFile
|
|
[ -z "${link_no_link_unlink+x}" ] || echo "link_no_link_unlink='${link_no_link_unlink}'" >> $outFile
|
|
[ -z "${link_ref_port+x}" ] || echo "link_ref_port=${link_ref_port}" >> $outFile
|
|
[ -z "${link_xrf_port+x}" ] || echo "link_xrf_port=${link_xrf_port}" >> $outFile
|
|
[ -z "${link_dcs_port+x}" ] || echo "link_dcs_port=${link_dcs_port}" >> $outFile
|
|
[ -z "${link_announce+x}" ] || echo "link_announce=${link_announce}" >> $outFile
|
|
[ -z "${link_acknowledge+x}" ] || echo "link_acknowledge=${link_acknowledge}" >> $outFile
|
|
[ -z "${link_max_dongles+x}" ] || echo "link_max_dongles=${link_max_dongles}" >> $outFile
|
|
# log_ section
|
|
[ -z "${log_qso+x}" ] || echo "log_qso=${log_qso}" >> $outFile
|
|
[ -z "${log_irc+x}" ] || echo "log_irc=${log_irc}" >> $outFile
|
|
[ -z "${log_dtmf+x}" ] || echo "log_dtmf=${log_dtmf}" >> $outFile
|
|
[ -z "${log_debug+x}" ] || echo "log_debug=${log_debug}" >> $outFile
|
|
# dplus_ section
|
|
[ -z "${dplus_authorize+x}" ] || echo "dplus_authorize=${dplus_authorize}" >> $outFile
|
|
[ -z "${dplus_priority+x}" ] || echo "dplus_priority=${dplus_priority}" >> $outFile
|
|
[ -z "${dplus_ref_login+x}" ] || echo "dplus_ref_login='${dplus_ref_login}'" >> $outFile
|
|
[ -z "${dplus_use_repeaters+x}" ] || echo "dplus_use_repeaters=${dplus_use_repeaters}" >> $outFile
|
|
[ -z "${dplus_use_reflectors+x}" ] || echo "dplus_use_reflectors=${dplus_use_reflectors}" >> $outFile
|
|
# file_ section
|
|
[ -z "${file_gwys+x}" ] || echo "file_gwys='${file_gwys}'" >> $outFile
|
|
[ -z "${file_dtmf+x}" ] || echo "file_dtmf='${file_dtmf}'" >> $outFile
|
|
[ -z "${file_status+x}" ] || echo "file_status='${file_status}'" >> $outFile
|
|
[ -z "${file_echotest+x}" ] || echo "file_echotest='${file_echotest}'" >> $outFile
|
|
[ -z "${file_qnvoicefile+x}" ] || echo "file_qnvoicefile='${file_qnvoicefile}'" >> $outFile
|
|
[ -z "${file_announce_dir+x}" ] || echo "file_announce_dir='${file_announce_dir}'" >> $outFile
|
|
# timing_ section
|
|
[ -z "${timing_timeout_echo+x}" ] || echo "timing_timeout_echo=${timing_timeout_echo}" >> $outFile
|
|
[ -z "${timing_timeout_remote_g2+x}" ] || echo "timing_timeout_remote_g2=${timing_timeout_remote_g2}" >> $outFile
|
|
[ -z "${timing_timeout_voicemail+x}" ] || echo "timing_timeout_voicemail=${timing_timeout_voicemail}" >> $outFile
|
|
[ -z "${timing_timeout_local_rptr+x}" ] || echo "timing_timeout_local_rptr=${timing_timeout_local_rptr}" >> $outFile
|
|
[ -z "${timing_play_wait+x}" ] || echo "timing_play_wait=${timing_play_wait}" >> $outFile
|
|
[ -z "${timing_play_delay+x}" ] || echo "timing_play_delay=${timing_play_delay}" >> $outFile
|
|
# dash_ section
|
|
[ -z "${dash_refresh+x}" ] || echo "dash_refresh=${dash_refresh}" >> $outFile
|
|
[ -z "${dash_lastheard_count+x}" ] || echo "dash_lastheard_count=${dash_lastheard_count}" >> $outFile
|
|
[ -z "${dash_show_order+x}" ] || echo "dash_show_order='${dash_show_order}'" >> $outFile
|
|
clear
|
|
cat $outFile
|
|
echo
|
|
read -p "File written! Press <Enter> to continue: " ans
|
|
}
|
|
|
|
# Execution starts here!
|
|
# source files
|
|
if [ -e ./defaults ]; then
|
|
source ./defaults
|
|
else
|
|
echo 'Error: ./defaults not found!'
|
|
exit 1
|
|
fi
|
|
if [ -e ./qn.cfg ]; then
|
|
source ./qn.cfg
|
|
else
|
|
echo 'No configuration file found...'
|
|
sleep 1
|
|
fi
|
|
|
|
# process arguments
|
|
if [[ "$1" == ex* ]]; then
|
|
em="expertMode"
|
|
fi
|
|
|
|
# main loop
|
|
while [[ "$ans" != q* ]]
|
|
do
|
|
clear
|
|
echo
|
|
echo " QnConfig Main Menu V#210409"
|
|
echo
|
|
echo -n "a : Module A - "; if [ -z $module_a ]; then echo "<EMPTY>"; else echo "${module_a^^}"; fi
|
|
echo -n "b : Module B - "; if [ -z $module_b ]; then echo "<EMPTY>"; else echo "${module_b^^}"; fi
|
|
echo -n "c : Module C - "; if [ -z $module_c ]; then echo "<EMPTY>"; else echo "${module_c^^}"; fi
|
|
echo "i : IRCDDB Menu - login = '${ircddb_login}'"
|
|
echo "g : Gateway/APRS Menu - location info and route cache"
|
|
echo "l : Link/D-Plus Menu - linking access"
|
|
echo "D : Dashboard Menu - Dashboard customization"
|
|
if [ -n "$em" ]; then
|
|
echo "d : Debugging/Files/Timings - miscellaneous parameters"
|
|
else
|
|
echo "d : Debugging - additional log entries"
|
|
fi
|
|
echo
|
|
if [ -n $module_a ] || [ -n $module_b ] || [ -n $module_c ] && [ -n $ircddb_login ]; then
|
|
echo "w : Write qn.cfg configuration file (overwrites any existing file)"
|
|
echo
|
|
fi
|
|
read -p "q to quit: " ans
|
|
|
|
if [[ "$ans" == a* ]]; then ModuleMenu a
|
|
elif [[ "$ans" == b* ]]; then ModuleMenu b
|
|
elif [[ "$ans" == c* ]]; then ModuleMenu c
|
|
elif [[ "$ans" == D* ]]; then DashboardMenu
|
|
elif [[ "$ans" == i* ]]; then IrcddbMenu
|
|
elif [[ "$ans" == g* ]]; then GateMenu
|
|
elif [[ "$ans" == l* ]]; then LinkMenu
|
|
elif [[ "$ans" == d* ]]; then FileMenu
|
|
elif [[ "$ans" == w* ]]; then WriteCFGFile
|
|
fi
|
|
done
|
|
[ -e qn.cfg ] && cat qn.cfg
|
|
exit 0
|