root/ubuntu-based-kiosk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d544c5a7027138be97b804307c77dbf8fc99d80b
ubuntu-based-kiosk/setup_intercom.sh
T
Claude d544c5a702 Fix talkkonnect x86_64 build failure with Opus patch 
Critical fixes to resolve "[ERROR] Binary not executable after build":

1. **Opus x86_64 Compatibility Patch**
   - Added gopus library patch to use system libopus for x86_64
   - The embedded Opus source in gopus is ARM-optimized and incomplete for x86_64
   - Now uses pkg-config to link against system libopus library

2. **Vendored Dependencies**
   - Added `go mod vendor` to create vendored dependencies
   - Build now uses `-mod=vendor` flag to ensure patched gopus is used

3. **Enhanced Build Process**
   - Set CGO_CFLAGS and CGO_LDFLAGS for proper Opus compilation
   - Build in cmd/talkkonnect directory (correct location)
   - Added build-essential and pkg-config to dependencies

4. **Improved XML Configuration**
   - Updated to modern talkkonnect/xml document type
   - Added critical voicetargets section to prevent crashes
   - Added proper global settings structure
   - Created .config/talkkonnect directory for logs

5. **Additional Dependencies**
   - Added libopus0, libopusfile-dev for complete Opus support
   - Added build-essential and pkg-config for compilation

This integrates the working approach from talkkonnect_complete_install.sh
into the setup_intercom.sh script.
2025-11-22 23:24:03 +00:00

1155 lines
37 KiB
Bash
Executable File
Raw Blame History

#!/bin/bash
################################################################################
### UBK Mumble/Talkkonnect Intercom Setup ###
### Standalone Installation and Management Script ###
################################################################################
#
# This script provides a complete push-to-talk (PTT) intercom solution using:
# - Murmur: The Mumble server (can run on one kiosk)
# - talkkonnect: A headless Mumble client for push-to-talk communication
#
# Use Cases:
# 1. Server + Client (All-in-one): One kiosk acts as both server and client
# 2. Client Only: Connect to an existing Mumble server
# 3. Server Only: Set up a kiosk as the intercom server
#
# Other kiosks or devices can connect using:
# - talkkonnect (Linux)
# - Mumble desktop client (Windows/Mac/Linux)
# - Mumble mobile app (iOS/Android)
#
################################################################################
VERSION="1.0.0"
KIOSK_USER="${KIOSK_USER:-kiosk}"
################################################################################
### HELPER FUNCTIONS
################################################################################
log_error() {
echo "[ERROR] $*" >&2
}
log_success() {
echo "✓ $*"
}
log_warning() {
echo "⚠ $*"
}
pause() {
read -r -p "Press Enter to continue..."
}
get_ip_address() {
hostname -I | awk '{print $1}' || echo "No IP"
}
################################################################################
### STATUS CHECK FUNCTIONS
################################################################################
check_murmur_status() {
local installed=false
local running=false
if systemctl list-unit-files | grep -q "mumble-server.service"; then
installed=true
if systemctl is-active --quiet mumble-server; then
running=true
fi
fi
echo "$installed:$running"
}
check_talkkonnect_status() {
local installed=false
local running=false
if command -v talkkonnect &>/dev/null || [[ -f "$HOME/go/bin/talkkonnect" ]]; then
installed=true
if systemctl is-active --quiet talkkonnect; then
running=true
fi
fi
echo "$installed:$running"
}
################################################################################
### MURMUR SERVER INSTALLATION
################################################################################
install_murmur_server() {
echo
echo "═══════════════════════════════════════════════════════════════"
echo " INSTALLING MURMUR SERVER"
echo "═══════════════════════════════════════════════════════════════"
echo
echo "[1/5] Installing mumble-server package..."
sudo apt update
sudo apt install -y mumble-server
echo "[2/5] Getting configuration details..."
read -r -s -p "SuperUser password: " superuser_pass
echo
read -r -s -p "Server password (clients need this): " server_pass
echo
read -r -p "Welcome text [Welcome to Kiosk Intercom]: " welcome_text
welcome_text="${welcome_text:-Welcome to Kiosk Intercom}"
echo "[3/5] Creating configuration..."
local config_file="/etc/mumble-server.ini"
# Create config if it doesn't exist
if [[ ! -f "$config_file" ]]; then
sudo tee "$config_file" > /dev/null <<'MURMURCONF'
# Murmur configuration file
# Database location
database=/var/lib/mumble-server/mumble-server.sqlite
# Network settings
port=64738
host=0.0.0.0
# Logging
logfile=/var/log/mumble-server/mumble-server.log
# Limits
users=10
bandwidth=72000
# Welcome message
welcometext=Welcome
# Server password
serverpassword=
# Allow pings
allowping=true
# Enable HTML
allowhtml=true
MURMURCONF
log_success "Config file created"
fi
# Update configuration
sudo sed -i "s|^welcometext=.*|welcometext=$welcome_text|" "$config_file"
sudo sed -i "s|^port=.*|port=64738|" "$config_file"
sudo sed -i "s|^users=.*|users=10|" "$config_file"
sudo sed -i "s|^bandwidth=.*|bandwidth=72000|" "$config_file"
if [[ -n "$server_pass" ]]; then
sudo sed -i "s|^serverpassword=.*|serverpassword=$server_pass|" "$config_file"
fi
echo "[4/5] Setting SuperUser password..."
# Stop service before setting password
sudo systemctl stop mumble-server 2>/dev/null || true
sleep 2
# Set SuperUser password
echo "$superuser_pass" | sudo murmurd -ini "$config_file" -supw - 2>/dev/null || {
log_warning "Could not set SuperUser password via murmurd command"
echo "You can set it later with: sudo murmurd -ini $config_file -supw YOUR_PASSWORD"
}
echo "[5/5] Starting service..."
sudo systemctl enable mumble-server
sudo systemctl start mumble-server
# Configure firewall
sudo ufw allow 64738/tcp comment 'Mumble/Murmur' 2>/dev/null || true
sudo ufw allow 64738/udp comment 'Mumble/Murmur' 2>/dev/null || true
sleep 3
local server_ip=$(get_ip_address)
log_success "Murmur server installed"
echo
echo "═══════════════════════════════════════════════════════════════"
echo " Server: $server_ip:64738"
echo " SuperUser: SuperUser / $superuser_pass"
[[ -n "$server_pass" ]] && echo " Password: $server_pass"
echo
echo "Connect with Mumble app:"
echo " Server: $server_ip"
echo " Port: 64738"
[[ -n "$server_pass" ]] && echo " Password: $server_pass"
echo "═══════════════════════════════════════════════════════════════"
pause
}
################################################################################
### TALKKONNECT CLIENT INSTALLATION
################################################################################
install_talkkonnect_with_config() {
local server_addr="$1"
local server_port="$2"
local tk_user="$3"
local tk_pass="$4"
local tk_channel="$5"
echo
echo "═══════════════════════════════════════════════════════════════"
echo " INSTALLING TALKKONNECT CLIENT"
echo "═══════════════════════════════════════════════════════════════"
echo
echo "[1/4] Installing Go..."
if ! command -v go &>/dev/null; then
wget -q https://golang.org/dl/go1.23.4.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.23.4.linux-amd64.tar.gz
rm go1.23.4.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin
echo 'export PATH=$PATH:/usr/local/go/bin' | sudo tee /etc/profile.d/go.sh
log_success "Go installed"
else
log_success "Go already installed"
fi
echo "[2/4] Installing audio dependencies..."
sudo apt install -y libopenal-dev libopus-dev libopus0 libopusfile-dev alsa-utils portaudio19-dev git build-essential pkg-config
echo "[3/4] Cloning and building talkkonnect..."
local tk_src="/tmp/talkkonnect-src"
rm -rf "$tk_src"
git clone https://github.com/talkkonnect/talkkonnect.git "$tk_src"
echo "Building (this takes 5-10 minutes)..."
# Build as kiosk user with proper environment
sudo -u "$KIOSK_USER" bash -c "
export PATH=/usr/local/go/bin:\$PATH
export HOME=/home/$KIOSK_USER
export GOPATH=/home/$KIOSK_USER/go
export CGO_ENABLED=1
mkdir -p /home/$KIOSK_USER/go/bin
cd '$tk_src' || exit 1
echo 'Creating vendored dependencies...'
go mod vendor
# Apply critical x86_64 Opus patch
echo 'Applying x86_64 Opus compatibility patch...'
if [[ -f vendor/github.com/talkkonnect/gopus/opus_nonshared.go ]]; then
cp vendor/github.com/talkkonnect/gopus/opus_nonshared.go \
vendor/github.com/talkkonnect/gopus/opus_nonshared.go.backup
cat > vendor/github.com/talkkonnect/gopus/opus_nonshared.go << 'EOFOPUS'
// +build amd64,cgo 386,cgo
package gopus
// #cgo pkg-config: opus
// #cgo LDFLAGS: -lm
//
// #include <stdio.h>
// #include <stdlib.h>
// #include <opus.h>
//
// enum {
// gopus_ok = OPUS_OK,
// gopus_bad_arg = OPUS_BAD_ARG,
// gopus_small_buffer = OPUS_BUFFER_TOO_SMALL,
// gopus_internal = OPUS_INTERNAL_ERROR,
// gopus_invalid_packet = OPUS_INVALID_PACKET,
// gopus_unimplemented = OPUS_UNIMPLEMENTED,
// gopus_invalid_state = OPUS_INVALID_STATE,
// gopus_alloc_fail = OPUS_ALLOC_FAIL,
// };
//
// enum {
// gopus_application_voip = OPUS_APPLICATION_VOIP,
// gopus_application_audio = OPUS_APPLICATION_AUDIO,
// gopus_restricted_lowdelay = OPUS_APPLICATION_RESTRICTED_LOWDELAY,
// gopus_bitrate_max = OPUS_BITRATE_MAX,
// };
//
// void gopus_setvbr(OpusEncoder *encoder, int vbr) {
// opus_encoder_ctl(encoder, OPUS_SET_VBR(vbr));
// }
//
// void gopus_setbitrate(OpusEncoder *encoder, int bitrate) {
// opus_encoder_ctl(encoder, OPUS_SET_BITRATE(bitrate));
// }
//
// opus_int32 gopus_bitrate(OpusEncoder *encoder) {
// opus_int32 bitrate;
// opus_encoder_ctl(encoder, OPUS_GET_BITRATE(&bitrate));
// return bitrate;
// }
//
// void gopus_setapplication(OpusEncoder *encoder, int application) {
// opus_encoder_ctl(encoder, OPUS_SET_APPLICATION(application));
// }
//
// opus_int32 gopus_application(OpusEncoder *encoder) {
// opus_int32 application;
// opus_encoder_ctl(encoder, OPUS_GET_APPLICATION(&application));
// return application;
// }
//
// void gopus_encoder_resetstate(OpusEncoder *encoder) {
// opus_encoder_ctl(encoder, OPUS_RESET_STATE);
// }
//
// void gopus_decoder_resetstate(OpusDecoder *decoder) {
// opus_decoder_ctl(decoder, OPUS_RESET_STATE);
// }
import \"C\"
import (
\"errors\"
\"unsafe\"
)
type Application int
const (
Voip Application = C.gopus_application_voip
Audio Application = C.gopus_application_audio
RestrictedLowDelay Application = C.gopus_restricted_lowdelay
)
const (
BitrateMaximum = C.gopus_bitrate_max
)
type Encoder struct {
data []byte
cEncoder *C.struct_OpusEncoder
}
func NewEncoder(sampleRate, channels int, application Application) (*Encoder, error) {
encoder := &Encoder{}
encoder.data = make([]byte, int(C.opus_encoder_get_size(C.int(channels))))
encoder.cEncoder = (*C.struct_OpusEncoder)(unsafe.Pointer(&encoder.data[0]))
ret := C.opus_encoder_init(encoder.cEncoder, C.opus_int32(sampleRate), C.int(channels), C.int(application))
if err := getErr(ret); err != nil {
return nil, err
}
return encoder, nil
}
func (e *Encoder) Encode(pcm []int16, frameSize, maxDataBytes int) ([]byte, error) {
pcmPtr := (*C.opus_int16)(unsafe.Pointer(&pcm[0]))
data := make([]byte, maxDataBytes)
dataPtr := (*C.uchar)(unsafe.Pointer(&data[0]))
encodedC := C.opus_encode(e.cEncoder, pcmPtr, C.int(frameSize), dataPtr, C.opus_int32(len(data)))
encoded := int(encodedC)
if encoded < 0 {
return nil, getErr(C.int(encodedC))
}
return data[0:encoded], nil
}
func (e *Encoder) SetVbr(vbr bool) {
var cVbr C.int
if vbr {
cVbr = 1
} else {
cVbr = 0
}
C.gopus_setvbr(e.cEncoder, cVbr)
}
func (e *Encoder) SetBitrate(bitrate int) {
C.gopus_setbitrate(e.cEncoder, C.int(bitrate))
}
func (e *Encoder) Bitrate() int {
return int(C.gopus_bitrate(e.cEncoder))
}
func (e *Encoder) SetApplication(application Application) {
C.gopus_setapplication(e.cEncoder, C.int(application))
}
func (e *Encoder) Application() Application {
return Application(C.gopus_application(e.cEncoder))
}
func (e *Encoder) ResetState() {
C.gopus_encoder_resetstate(e.cEncoder)
}
type Decoder struct {
data []byte
cDecoder *C.struct_OpusDecoder
channels int
}
func NewDecoder(sampleRate, channels int) (*Decoder, error) {
decoder := &Decoder{}
decoder.data = make([]byte, int(C.opus_decoder_get_size(C.int(channels))))
decoder.cDecoder = (*C.struct_OpusDecoder)(unsafe.Pointer(&decoder.data[0]))
ret := C.opus_decoder_init(decoder.cDecoder, C.opus_int32(sampleRate), C.int(channels))
if err := getErr(ret); err != nil {
return nil, err
}
decoder.channels = channels
return decoder, nil
}
func (d *Decoder) Decode(data []byte, frameSize int, fec bool) ([]int16, error) {
var dataPtr *C.uchar
if len(data) > 0 {
dataPtr = (*C.uchar)(unsafe.Pointer(&data[0]))
}
dataLen := C.opus_int32(len(data))
output := make([]int16, d.channels*frameSize)
outputPtr := (*C.opus_int16)(unsafe.Pointer(&output[0]))
var cFec C.int
if fec {
cFec = 1
} else {
cFec = 0
}
cRet := C.opus_decode(d.cDecoder, dataPtr, dataLen, outputPtr, C.int(frameSize), cFec)
ret := int(cRet)
if ret < 0 {
return nil, getErr(cRet)
}
return output[:ret*d.channels], nil
}
func (d *Decoder) ResetState() {
C.gopus_decoder_resetstate(d.cDecoder)
}
func GetSamplesPerFrame(data []byte, samplingRate int) (int, error) {
dataPtr := (*C.uchar)(unsafe.Pointer(&data[0]))
cSamplingRate := C.opus_int32(samplingRate)
cRet := C.opus_packet_get_samples_per_frame(dataPtr, cSamplingRate)
return int(cRet), nil
}
func CountFrames(data []byte) (int, error) {
dataPtr := (*C.uchar)(unsafe.Pointer(&data[0]))
cLen := C.opus_int32(len(data))
cRet := C.opus_packet_get_nb_frames(dataPtr, cLen)
if err := getErr(cRet); err != nil {
return 0, err
}
return int(cRet), nil
}
var (
ErrBadArgument = errors.New(\"bad argument\")
ErrSmallBuffer = errors.New(\"buffer is too small\")
ErrInternal = errors.New(\"internal error\")
ErrInvalidPacket = errors.New(\"invalid packet\")
ErrUnimplemented = errors.New(\"unimplemented\")
ErrInvalidState = errors.New(\"invalid state\")
ErrAllocFail = errors.New(\"allocation failed\")
ErrUnknown = errors.New(\"unknown error\")
)
func getErr(code C.int) error {
switch code {
case C.gopus_ok:
return nil
case C.gopus_bad_arg:
return ErrBadArgument
case C.gopus_small_buffer:
return ErrSmallBuffer
case C.gopus_internal:
return ErrInternal
case C.gopus_invalid_packet:
return ErrInvalidPacket
case C.gopus_unimplemented:
return ErrUnimplemented
case C.gopus_invalid_state:
return ErrInvalidState
case C.gopus_alloc_fail:
return ErrAllocFail
default:
return ErrUnknown
}
}
EOFOPUS
echo 'Opus patch applied'
else
echo 'Warning: gopus not found in vendor directory'
fi
# Set CGO flags for Opus
export CGO_CFLAGS=\"\$(pkg-config --cflags opus)\"
export CGO_LDFLAGS=\"\$(pkg-config --libs opus) -lm\"
# Build in the cmd/talkkonnect directory with vendored dependencies
cd cmd/talkkonnect || exit 1
echo 'Compiling with vendored dependencies...'
go build -mod=vendor -v -o /home/$KIOSK_USER/go/bin/talkkonnect . 2>&1 | tail -20
if [[ -f /home/$KIOSK_USER/go/bin/talkkonnect ]]; then
chmod +x /home/$KIOSK_USER/go/bin/talkkonnect
echo 'Build successful'
exit 0
else
echo 'Build failed - binary not created'
exit 1
fi
"
local build_result=$?
rm -rf "$tk_src"
if [[ $build_result -ne 0 ]]; then
log_error "Build failed"
echo
echo "Troubleshooting:"
echo " 1. Check Go version: go version"
echo " 2. Ensure build tools: sudo apt install build-essential"
echo " 3. Check logs above for specific errors"
pause
return 1
fi
# Verify binary
if [[ ! -x "/home/$KIOSK_USER/go/bin/talkkonnect" ]]; then
log_error "Binary not executable after build"
pause
return 1
fi
log_success "talkkonnect built successfully"
echo "[4/4] Creating configuration..."
# Create config directory for logs
sudo -u "$KIOSK_USER" mkdir -p /home/$KIOSK_USER/.config/talkkonnect
sudo -u "$KIOSK_USER" tee /home/$KIOSK_USER/talkkonnect.xml > /dev/null <<TKXML
<?xml version="1.0" encoding="UTF-8"?>
<document type="talkkonnect/xml">
<global>
<software>
<settings outputdevice="default"
logfilenameandpath="/home/$KIOSK_USER/.config/talkkonnect/talkkonnect.log"
logging="both"
daemonize="false"
cancelconnect="false"
simplexwithvox="false"
nextserverindex="0"/>
<autoprovisioning enabled="false"/>
</software>
<hardware>
<settings targetboard="pc"
voiceactivitytimersecs="200"/>
<io>
<pins enabled="false"/>
</io>
</hardware>
</global>
<accounts>
<account name="default" default="true">
<serverandport>$server_addr:$server_port</serverandport>
<username>$tk_user</username>
<password>$tk_pass</password>
<insecure>true</insecure>
<register>false</register>
<certificate></certificate>
<channel>$tk_channel</channel>
<ident></ident>
<tokens enabled="false"></tokens>
<voicetargets enabled="false">
<id id="1" iscurrent="false" name="default">
<channels></channels>
<users></users>
</id>
</voicetargets>
</account>
</accounts>
<beacon enabled="false"/>
<audio>
<input>
<settings enabled="true"
device="default"
samplerate="48000"
channels="1"
codec="opus"
framespersecond="50"/>
</input>
<output>
<settings enabled="true"
device="default"
samplerate="48000"
channels="1"/>
</output>
</audio>
<ptt enabled="false">
<usbkeyboard enabled="false"/>
</ptt>
<voiceactivity enabled="true">
<settings threshold="0.3"
holdtimems="1000"
holdtimeoutms="2000"/>
</voiceactivity>
<sounds enabled="false"/>
<txtts enabled="false"/>
<smtp enabled="false"/>
<api enabled="false"/>
<printxml enabled="false"/>
</document>
TKXML
# Create systemd service
sudo tee /etc/systemd/system/talkkonnect.service > /dev/null <<EOF
[Unit]
Description=talkkonnect Mumble Client
After=network.target sound.target pipewire.service
Wants=pipewire.service
[Service]
Type=simple
User=$KIOSK_USER
Environment="PATH=/usr/local/go/bin:/usr/bin:/bin"
Environment="HOME=/home/$KIOSK_USER"
Environment="GOPATH=/home/$KIOSK_USER/go"
WorkingDirectory=/home/$KIOSK_USER
ExecStartPre=/bin/sleep 10
ExecStart=/home/$KIOSK_USER/go/bin/talkkonnect -config /home/$KIOSK_USER/talkkonnect.xml
Restart=always
RestartSec=10
StandardOutput=journal
StandardError=journal
[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable talkkonnect
sudo systemctl start talkkonnect
sleep 3
log_success "talkkonnect installed"
echo "═══════════════════════════════════════════════════════════════"
echo " Server: $server_addr:$server_port"
echo " PTT Key: Spacebar"
echo "═══════════════════════════════════════════════════════════════"
# Show status
echo
if systemctl is-active --quiet talkkonnect; then
log_success "Service started successfully"
else
log_warning "Service may have issues - check logs:"
echo " sudo journalctl -u talkkonnect -n 50"
fi
pause
}
install_talkkonnect_only() {
echo
echo "═══════════════════════════════════════════════════════════════"
echo " TALKKONNECT - CONNECT TO EXISTING SERVER"
echo "═══════════════════════════════════════════════════════════════"
echo
echo "Enter Murmur/Mumble server details:"
read -r -p "Server address (IP or domain): " server_addr
read -r -p "Port [64738]: " server_port
server_port="${server_port:-64738}"
read -r -p "Username: " tk_user
read -r -s -p "Password: " tk_pass
echo
read -r -p "Channel [Root]: " tk_channel
tk_channel="${tk_channel:-Root}"
install_talkkonnect_with_config "$server_addr" "$server_port" "$tk_user" "$tk_pass" "$tk_channel"
}
install_murmur_and_talkkonnect() {
echo
echo "═══════════════════════════════════════════════════════════════"
echo " ALL-IN-ONE: SERVER + CLIENT"
echo "═══════════════════════════════════════════════════════════════"
echo
echo "Installing Murmur server..."
install_murmur_server
echo
echo "Now installing talkkonnect client..."
echo "Configuring to connect to local server..."
# Auto-configure for local server
AUTO_SERVER="127.0.0.1"
AUTO_PORT="64738"
read -r -p "Username for talkkonnect [kiosk]: " tk_user
tk_user="${tk_user:-kiosk}"
read -r -s -p "Server password: " tk_pass
echo
install_talkkonnect_with_config "$AUTO_SERVER" "$AUTO_PORT" "$tk_user" "$tk_pass" "Root"
}
################################################################################
### SERVICE MANAGEMENT
################################################################################
toggle_murmur_service() {
echo
if systemctl is-active --quiet mumble-server; then
echo "Stopping Murmur server..."
sudo systemctl stop mumble-server
log_success "Murmur stopped"
else
echo "Starting Murmur server..."
sudo systemctl start mumble-server
sleep 2
if systemctl is-active --quiet mumble-server; then
log_success "Murmur started"
else
log_error "Failed to start - check logs: sudo journalctl -u mumble-server"
fi
fi
pause
}
toggle_talkkonnect_service() {
echo
if systemctl is-active --quiet talkkonnect; then
echo "Stopping talkkonnect..."
sudo systemctl stop talkkonnect
log_success "talkkonnect stopped"
else
echo "Starting talkkonnect..."
sudo systemctl start talkkonnect
sleep 2
if systemctl is-active --quiet talkkonnect; then
log_success "talkkonnect started"
else
log_error "Failed to start - check logs: sudo journalctl -u talkkonnect"
fi
fi
pause
}
################################################################################
### RECONFIGURATION
################################################################################
reconfigure_murmur() {
echo
echo "Reconfigure Murmur Server:"
echo " 1. Change welcome text"
echo " 2. Change server password"
echo " 3. Change SuperUser password"
echo " 4. Change port"
echo " 0. Cancel"
read -r -p "Choose: " reconfig_choice
local config_file="/etc/mumble-server.ini"
case "$reconfig_choice" in
1)
read -r -p "New welcome text: " new_welcome
sudo sed -i "s|^welcometext=.*|welcometext=$new_welcome|" "$config_file"
sudo systemctl restart mumble-server
log_success "Welcome text updated"
;;
2)
read -r -s -p "New server password (blank=none): " new_pass
echo
sudo sed -i "s|^serverpassword=.*|serverpassword=$new_pass|" "$config_file"
sudo systemctl restart mumble-server
log_success "Server password updated"
;;
3)
read -r -s -p "New SuperUser password: " su_pass
echo
sudo systemctl stop mumble-server
echo "$su_pass" | sudo murmurd -ini "$config_file" -supw - 2>/dev/null
sudo systemctl start mumble-server
log_success "SuperUser password updated"
;;
4)
read -r -p "New port [64738]: " new_port
new_port="${new_port:-64738}"
sudo sed -i "s|^port=.*|port=$new_port|" "$config_file"
sudo systemctl restart mumble-server
log_success "Port updated to $new_port"
;;
esac
pause
}
reconfigure_talkkonnect() {
echo
echo "Reconfigure talkkonnect:"
echo " 1. Change server"
echo " 2. Change credentials"
echo " 3. Change channel"
echo " 0. Cancel"
read -r -p "Choose: " reconfig_choice
case "$reconfig_choice" in
1)
read -r -p "Server address: " new_server
read -r -p "Port [64738]: " new_port
new_port="${new_port:-64738}"
sudo -u "$KIOSK_USER" sed -i "s|<server>.*</server>|<server>$new_server</server>|" /home/$KIOSK_USER/talkkonnect.xml
sudo -u "$KIOSK_USER" sed -i "s|<port>.*</port>|<port>$new_port</port>|" /home/$KIOSK_USER/talkkonnect.xml
sudo systemctl restart talkkonnect
log_success "Server updated"
;;
2)
read -r -p "Username: " new_user
read -r -s -p "Password: " new_pass
echo
sudo -u "$KIOSK_USER" sed -i "s|<username>.*</username>|<username>$new_user</username>|" /home/$KIOSK_USER/talkkonnect.xml
sudo -u "$KIOSK_USER" sed -i "s|<password>.*</password>|<password>$new_pass</password>|" /home/$KIOSK_USER/talkkonnect.xml
sudo systemctl restart talkkonnect
log_success "Credentials updated"
;;
3)
read -r -p "Channel: " new_channel
sudo -u "$KIOSK_USER" sed -i "s|<channel>.*</channel>|<channel>$new_channel</channel>|" /home/$KIOSK_USER/talkkonnect.xml
sudo systemctl restart talkkonnect
log_success "Channel updated"
;;
esac
pause
}
################################################################################
### LOGS AND DIAGNOSTICS
################################################################################
view_talkkonnect_logs() {
echo
echo "Recent talkkonnect logs:"
echo "═══════════════════════════════════════════════════════════════"
sudo journalctl -u talkkonnect -n 50 --no-pager
echo
pause
}
view_murmur_logs() {
echo
echo "Recent Murmur server logs:"
echo "═══════════════════════════════════════════════════════════════"
sudo journalctl -u mumble-server -n 50 --no-pager
echo
pause
}
################################################################################
### UNINSTALLATION
################################################################################
uninstall_murmur() {
echo
read -r -p "Uninstall Murmur server? (yes/no): " confirm
[[ "$confirm" != "yes" ]] && return
echo "Uninstalling..."
sudo systemctl stop mumble-server 2>/dev/null || true
sudo systemctl disable mumble-server 2>/dev/null || true
sudo apt remove -y mumble-server 2>/dev/null || true
read -r -p "Remove configuration and database? (y/n): " remove_data
if [[ "$remove_data" =~ ^[Yy]$ ]]; then
sudo rm -rf /var/lib/mumble-server
sudo rm -f /etc/mumble-server.ini
log_success "Murmur and data removed"
else
log_success "Murmur removed (data preserved)"
fi
pause
}
uninstall_talkkonnect() {
echo
read -r -p "Uninstall talkkonnect? (yes/no): " confirm
[[ "$confirm" != "yes" ]] && return
echo "Uninstalling..."
sudo systemctl stop talkkonnect 2>/dev/null || true
sudo systemctl disable talkkonnect 2>/dev/null || true
sudo rm -f /etc/systemd/system/talkkonnect.service
sudo rm -f /home/$KIOSK_USER/talkkonnect.xml
sudo rm -f /home/$KIOSK_USER/go/bin/talkkonnect
sudo systemctl daemon-reload
log_success "talkkonnect uninstalled"
pause
}
################################################################################
### MAIN MENU
################################################################################
show_status() {
local murmur_status=$(check_murmur_status)
local murmur_installed=$(echo "$murmur_status" | cut -d: -f1)
local murmur_running=$(echo "$murmur_status" | cut -d: -f2)
local tk_status=$(check_talkkonnect_status)
local tk_installed=$(echo "$tk_status" | cut -d: -f1)
local tk_running=$(echo "$tk_status" | cut -d: -f2)
echo
echo "═══════════════════════════════════════════════════════════════"
echo " INTERCOM STATUS"
echo "═══════════════════════════════════════════════════════════════"
echo
# Murmur status
if [[ "$murmur_installed" == "true" ]]; then
echo "Murmur Server: ✓ Installed"
if [[ "$murmur_running" == "true" ]]; then
echo " Status: Running"
local server_ip=$(get_ip_address)
echo " Address: $server_ip:64738"
else
echo " Status: Stopped"
fi
echo
else
echo "Murmur Server: Not installed"
echo
fi
# talkkonnect status
if [[ "$tk_installed" == "true" ]]; then
echo "talkkonnect Client: ✓ Installed"
if [[ "$tk_running" == "true" ]]; then
echo " Status: Running"
if [[ -f /home/$KIOSK_USER/talkkonnect.xml ]]; then
local server=$(grep "serveraddress" /home/$KIOSK_USER/talkkonnect.xml 2>/dev/null | sed 's/.*<server>\(.*\)<\/server>/\1/' || echo "Unknown")
echo " Server: $server"
fi
else
echo " Status: Stopped"
fi
echo
else
echo "talkkonnect Client: Not installed"
echo
fi
}
main_menu() {
while true; do
clear
echo "═══════════════════════════════════════════════════════════════"
echo " UBK INTERCOM SETUP v${VERSION}"
echo " Mumble/Talkkonnect Push-to-Talk System"
echo "═══════════════════════════════════════════════════════════════"
show_status
local murmur_status=$(check_murmur_status)
local murmur_installed=$(echo "$murmur_status" | cut -d: -f1)
local murmur_running=$(echo "$murmur_status" | cut -d: -f2)
local tk_status=$(check_talkkonnect_status)
local tk_installed=$(echo "$tk_status" | cut -d: -f1)
local tk_running=$(echo "$tk_status" | cut -d: -f2)
echo "═══════════════════════════════════════════════════════════════"
echo " INSTALLATION OPTIONS"
echo "═══════════════════════════════════════════════════════════════"
local menu_num=1
# Installation options (shown when nothing installed)
if [[ "$murmur_installed" == "false" && "$tk_installed" == "false" ]]; then
echo " $menu_num. Install All-in-One (Server + Client)"
local opt_all_in_one=$menu_num
((menu_num++))
echo " $menu_num. Install Murmur Server Only"
local opt_server_only=$menu_num
((menu_num++))
echo " $menu_num. Install talkkonnect Client Only"
local opt_client_only=$menu_num
((menu_num++))
else
# Murmur management options
if [[ "$murmur_installed" == "true" ]]; then
echo
echo "Murmur Server:"
if [[ "$murmur_running" == "true" ]]; then
echo " $menu_num. Stop Murmur"
else
echo " $menu_num. Start Murmur"
fi
local opt_murmur_toggle=$menu_num
((menu_num++))
echo " $menu_num. Reconfigure Murmur"
local opt_murmur_reconfig=$menu_num
((menu_num++))
echo " $menu_num. View Murmur Logs"
local opt_murmur_logs=$menu_num
((menu_num++))
echo " $menu_num. Uninstall Murmur"
local opt_murmur_uninstall=$menu_num
((menu_num++))
else
echo
echo " $menu_num. Install Murmur Server"
local opt_install_murmur=$menu_num
((menu_num++))
fi
# talkkonnect management options
if [[ "$tk_installed" == "true" ]]; then
echo
echo "talkkonnect Client:"
if [[ "$tk_running" == "true" ]]; then
echo " $menu_num. Stop talkkonnect"
else
echo " $menu_num. Start talkkonnect"
fi
local opt_tk_toggle=$menu_num
((menu_num++))
echo " $menu_num. Reconfigure talkkonnect"
local opt_tk_reconfig=$menu_num
((menu_num++))
echo " $menu_num. View talkkonnect Logs"
local opt_tk_logs=$menu_num
((menu_num++))
echo " $menu_num. Uninstall talkkonnect"
local opt_tk_uninstall=$menu_num
((menu_num++))
else
echo
echo " $menu_num. Install talkkonnect Client"
local opt_install_tk=$menu_num
((menu_num++))
fi
fi
echo
echo "═══════════════════════════════════════════════════════════════"
echo " 0. Exit"
echo "═══════════════════════════════════════════════════════════════"
echo
read -r -p "Choose [0-$((menu_num-1))]: " choice
# Handle menu selection
case "$choice" in
0)
echo "Exiting..."
exit 0
;;
${opt_all_in_one:-})
install_murmur_and_talkkonnect
;;
${opt_server_only:-})
install_murmur_server
;;
${opt_client_only:-})
install_talkkonnect_only
;;
${opt_install_murmur:-})
install_murmur_server
;;
${opt_install_tk:-})
install_talkkonnect_only
;;
${opt_murmur_toggle:-})
toggle_murmur_service
;;
${opt_murmur_reconfig:-})
reconfigure_murmur
;;
${opt_murmur_logs:-})
view_murmur_logs
;;
${opt_murmur_uninstall:-})
uninstall_murmur
;;
${opt_tk_toggle:-})
toggle_talkkonnect_service
;;
${opt_tk_reconfig:-})
reconfigure_talkkonnect
;;
${opt_tk_logs:-})
view_talkkonnect_logs
;;
${opt_tk_uninstall:-})
uninstall_talkkonnect
;;
*)
echo "Invalid choice"
sleep 1
;;
esac
done
}
################################################################################
### ENTRY POINT
################################################################################
# Check if running as root
if [[ $EUID -eq 0 ]]; then
log_error "This script should not be run as root"
echo "Please run as: ./setup_intercom.sh"
exit 1
fi
# Check if kiosk user exists
if ! id "$KIOSK_USER" &>/dev/null; then
log_warning "User '$KIOSK_USER' does not exist"
read -r -p "Enter the username to use for installation: " KIOSK_USER
if ! id "$KIOSK_USER" &>/dev/null; then
log_error "User '$KIOSK_USER' not found"
exit 1
fi
fi
# Run main menu
main_menu
Reference in New Issue View Git Blame Copy Permalink