1108 lines
42 KiB
Bash
Executable File
1108 lines
42 KiB
Bash
Executable File
#!/bin/sh
|
|
# Updated QuecProfiles daemon with enhanced SA/NSA NR5G band management and TTL support
|
|
# Including profile application functions and fixed comparison logic
|
|
|
|
# Configuration
|
|
QUEUE_DIR="/tmp/at_queue"
|
|
TOKEN_FILE="$QUEUE_DIR/token"
|
|
TRACK_FILE="/tmp/quecprofiles_active"
|
|
CHECK_TRIGGER="/tmp/quecprofiles_check"
|
|
STATUS_FILE="/tmp/quecprofiles_status.json"
|
|
APPLIED_FLAG="/tmp/quecprofiles_applied"
|
|
DEBUG_LOG="/tmp/quecprofiles_debug.log"
|
|
DETAILED_LOG="/tmp/quecprofiles_detailed.log"
|
|
DEFAULT_CHECK_INTERVAL=60 # Default check interval in seconds
|
|
COMMAND_TIMEOUT=10 # Default timeout for AT commands in seconds
|
|
QUEUE_PRIORITY=3 # Medium-high priority (1 is highest for cell scan)
|
|
MAX_TOKEN_WAIT=15 # Maximum seconds to wait for token acquisition
|
|
|
|
# Initialize log file
|
|
echo "$(date) - Starting QuecProfiles daemon with SA/NSA NR5G and TTL support (PID: $$)" >"$DEBUG_LOG"
|
|
echo "$(date) - Starting QuecProfiles daemon with SA/NSA NR5G and TTL support (PID: $$)" >"$DETAILED_LOG"
|
|
chmod 644 "$DEBUG_LOG" "$DETAILED_LOG"
|
|
|
|
# Function to log messages
|
|
log_message() {
|
|
local message="$1"
|
|
local level="${2:-info}"
|
|
local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
|
|
|
|
# Log to system log
|
|
logger -t quecprofiles_daemon -p "daemon.$level" "$message"
|
|
|
|
# Log to debug file
|
|
echo "[$timestamp] [$level] $message" >>"$DEBUG_LOG"
|
|
|
|
# For detailed logs or errors
|
|
if [ "$level" = "error" ] || [ "$level" = "debug" ]; then
|
|
echo "[$timestamp] [$level] $message" >>"$DETAILED_LOG"
|
|
fi
|
|
}
|
|
|
|
# Function to update track file with status - IMPROVED VERSION
|
|
update_track() {
|
|
local status="$1"
|
|
local message="$2"
|
|
local profile="${3:-unknown}"
|
|
local progress="${4:-0}"
|
|
|
|
# Create JSON status
|
|
cat >"$STATUS_FILE" <<EOF
|
|
{
|
|
"status": "$status",
|
|
"message": "$message",
|
|
"profile": "$profile",
|
|
"progress": $progress,
|
|
"timestamp": "$(date +%s)"
|
|
}
|
|
EOF
|
|
|
|
# Create simple track file for easy checking
|
|
if [ "$status" = "idle" ]; then
|
|
rm -f "$TRACK_FILE"
|
|
else
|
|
echo "$status:$profile:$progress" >"$TRACK_FILE"
|
|
chmod 644 "$TRACK_FILE"
|
|
fi
|
|
|
|
log_message "Status updated: $status - $message ($progress%)"
|
|
}
|
|
|
|
# Function to find profile by ICCID in UCI
|
|
find_profile_by_iccid() {
|
|
local iccid="$1"
|
|
local profile_indices
|
|
|
|
log_message "Looking for profile with ICCID: $iccid" "info"
|
|
|
|
# Get all profile indices
|
|
profile_indices=$(uci show quecprofiles | grep -o '@profile\[[0-9]\+\]' | sort -u)
|
|
|
|
# Exit early if no profiles found
|
|
if [ -z "$profile_indices" ]; then
|
|
log_message "No profiles configured in the system" "info"
|
|
return 1
|
|
fi
|
|
|
|
for profile_index in $profile_indices; do
|
|
local current_iccid=$(uci -q get quecprofiles.$profile_index.iccid)
|
|
if [ "$current_iccid" = "$iccid" ]; then
|
|
log_message "Found matching profile: $profile_index" "info"
|
|
echo "$profile_index"
|
|
return 0
|
|
fi
|
|
done
|
|
|
|
log_message "No matching profile found for ICCID: $iccid" "info"
|
|
return 1
|
|
}
|
|
|
|
# Function to normalize and compare values - handles format differences
|
|
compare_values() {
|
|
local current="$1"
|
|
local desired="$2"
|
|
local type="$3"
|
|
|
|
# Skip empty values
|
|
if [ -z "$desired" ]; then
|
|
log_message "Desired value for $type is empty, skipping comparison" "debug"
|
|
return 1 # No change needed
|
|
fi
|
|
|
|
# Normalize values for comparison
|
|
local norm_current
|
|
local norm_desired
|
|
|
|
# Different normalization based on type
|
|
case "$type" in
|
|
"apn")
|
|
# APN comparison is case-insensitive
|
|
norm_current=$(echo "$current" | tr '[:upper:]' '[:lower:]')
|
|
norm_desired=$(echo "$desired" | tr '[:upper:]' '[:lower:]')
|
|
;;
|
|
"mode")
|
|
# Network mode - normalize format and sort parts
|
|
norm_current=$(echo "$current" | tr '[:upper:]' '[:lower:]' | tr ':' ',' | tr -d ' ' | tr ',' '\n' | sort | tr '\n' ',' | sed 's/,$//')
|
|
norm_desired=$(echo "$desired" | tr '[:upper:]' '[:lower:]' | tr ':' ',' | tr -d ' ' | tr ',' '\n' | sort | tr '\n' ',' | sed 's/,$//')
|
|
;;
|
|
"bands")
|
|
# Bands - sort numbers for consistent comparison
|
|
norm_current=$(echo "$current" | tr ',' '\n' | sort -n | tr '\n' ',' | sed 's/,$//')
|
|
norm_desired=$(echo "$desired" | tr ',' '\n' | sort -n | tr '\n' ',' | sed 's/,$//')
|
|
;;
|
|
*)
|
|
# Default comparison
|
|
norm_current="$current"
|
|
norm_desired="$desired"
|
|
;;
|
|
esac
|
|
|
|
log_message "Comparing $type - Current: '$norm_current', Desired: '$norm_desired'" "debug"
|
|
|
|
# Check if values are equivalent after normalization
|
|
if [ "$norm_current" = "$norm_desired" ]; then
|
|
log_message "$type values match after normalization" "debug"
|
|
return 1 # No change needed
|
|
else
|
|
log_message "$type values differ after normalization - change needed" "debug"
|
|
return 0 # Change needed
|
|
fi
|
|
}
|
|
|
|
# Function to check if profile is already applied
|
|
is_profile_applied() {
|
|
local iccid="$1"
|
|
local profile_name="$2"
|
|
|
|
# Check if applied flag exists and matches current profile
|
|
if [ -f "$APPLIED_FLAG" ]; then
|
|
local applied_data=$(cat "$APPLIED_FLAG" 2>/dev/null)
|
|
local applied_iccid=$(echo "$applied_data" | cut -d':' -f1)
|
|
local applied_name=$(echo "$applied_data" | cut -d':' -f2)
|
|
local applied_time=$(echo "$applied_data" | cut -d':' -f3)
|
|
|
|
# Check if the applied profile matches current one
|
|
if [ "$applied_iccid" = "$iccid" ] && [ "$applied_name" = "$profile_name" ]; then
|
|
log_message "Profile '$profile_name' already applied at $(date -d @$applied_time)" "info"
|
|
return 0 # Profile already applied
|
|
fi
|
|
fi
|
|
|
|
# No matching applied profile found
|
|
return 1
|
|
}
|
|
|
|
# Function to mark profile as applied
|
|
mark_profile_applied() {
|
|
local iccid="$1"
|
|
local profile_name="$2"
|
|
|
|
# Save profile application data
|
|
echo "$iccid:$profile_name:$(date +%s)" >"$APPLIED_FLAG"
|
|
chmod 644 "$APPLIED_FLAG"
|
|
log_message "Marked profile '$profile_name' as applied for ICCID $iccid" "info"
|
|
}
|
|
|
|
# Enhanced JSON string escaping function
|
|
escape_json() {
|
|
printf '%s' "$1" | sed 's/\\/\\\\/g' | sed 's/"/\\"/g' | tr -d '\n' | sed 's/\r//g'
|
|
}
|
|
|
|
# Function to acquire token directly with retries
|
|
acquire_token() {
|
|
local lock_id="QUECPROFILES_$(date +%s)_$$"
|
|
local priority="$QUEUE_PRIORITY"
|
|
local max_attempts=$MAX_TOKEN_WAIT
|
|
local attempt=0
|
|
|
|
log_message "Attempting to acquire AT queue token with priority $priority" "debug"
|
|
|
|
while [ $attempt -lt $max_attempts ]; do
|
|
# Check if token file exists
|
|
if [ -f "$TOKEN_FILE" ]; then
|
|
local current_holder=$(cat "$TOKEN_FILE" | jsonfilter -e '@.id' 2>/dev/null)
|
|
local current_priority=$(cat "$TOKEN_FILE" | jsonfilter -e '@.priority' 2>/dev/null)
|
|
local timestamp=$(cat "$TOKEN_FILE" | jsonfilter -e '@.timestamp' 2>/dev/null)
|
|
local current_time=$(date +%s)
|
|
|
|
# Check for expired token (> 30 seconds old)
|
|
if [ $((current_time - timestamp)) -gt 30 ] || [ -z "$current_holder" ]; then
|
|
# Remove expired token
|
|
log_message "Found expired token from $current_holder, removing" "debug"
|
|
rm -f "$TOKEN_FILE" 2>/dev/null
|
|
elif [ $priority -lt $current_priority ]; then
|
|
# Preempt lower priority token
|
|
log_message "Preempting token from $current_holder (priority: $current_priority)" "debug"
|
|
rm -f "$TOKEN_FILE" 2>/dev/null
|
|
else
|
|
# Try again - higher priority token exists
|
|
log_message "Token held by $current_holder with priority $current_priority, retrying..." "debug"
|
|
sleep 0.5
|
|
attempt=$((attempt + 1))
|
|
continue
|
|
fi
|
|
fi
|
|
|
|
# Try to create token file
|
|
echo "{\"id\":\"$lock_id\",\"priority\":$priority,\"timestamp\":$(date +%s)}" >"$TOKEN_FILE" 2>/dev/null
|
|
chmod 644 "$TOKEN_FILE" 2>/dev/null
|
|
|
|
# Verify we got the token
|
|
local holder=$(cat "$TOKEN_FILE" 2>/dev/null | jsonfilter -e '@.id' 2>/dev/null)
|
|
if [ "$holder" = "$lock_id" ]; then
|
|
log_message "Successfully acquired token with ID $lock_id" "debug"
|
|
echo "$lock_id"
|
|
return 0
|
|
fi
|
|
|
|
sleep 0.5
|
|
attempt=$((attempt + 1))
|
|
done
|
|
|
|
log_message "Failed to acquire token after $max_attempts attempts" "error"
|
|
return 1
|
|
}
|
|
|
|
# Function to release token
|
|
release_token() {
|
|
local lock_id="$1"
|
|
|
|
if [ -f "$TOKEN_FILE" ]; then
|
|
local current_holder=$(cat "$TOKEN_FILE" | jsonfilter -e '@.id' 2>/dev/null)
|
|
if [ "$current_holder" = "$lock_id" ]; then
|
|
rm -f "$TOKEN_FILE" 2>/dev/null
|
|
log_message "Released token $lock_id" "debug"
|
|
return 0
|
|
fi
|
|
log_message "Token held by $current_holder, not by us ($lock_id)" "warn"
|
|
else
|
|
log_message "Token file doesn't exist, nothing to release" "debug"
|
|
fi
|
|
return 1
|
|
}
|
|
|
|
# Function to execute AT command with proper error handling
|
|
execute_at_command() {
|
|
local cmd="$1"
|
|
local timeout="${2:-$COMMAND_TIMEOUT}"
|
|
local token_id="$3"
|
|
|
|
if [ -z "$token_id" ]; then
|
|
log_message "No valid token provided for command: $cmd" "error"
|
|
return 1
|
|
fi
|
|
|
|
log_message "Executing AT command: $cmd (timeout: ${timeout}s)" "debug"
|
|
|
|
# Execute the command with proper timeout
|
|
local output=""
|
|
local status=1
|
|
|
|
# Check if sms_tool exists
|
|
if which sms_tool >/dev/null 2>&1; then
|
|
output=$(sms_tool at "$cmd" -t "$timeout" 2>&1)
|
|
status=$?
|
|
log_message "AT command executed, status: $status" "debug"
|
|
else
|
|
log_message "sms_tool not found, cannot execute AT command" "error"
|
|
return 1
|
|
fi
|
|
|
|
# Log command output for debugging
|
|
echo "Command: $cmd" >>"$DETAILED_LOG"
|
|
echo "Output: $output" >>"$DETAILED_LOG"
|
|
echo "Status: $status" >>"$DETAILED_LOG"
|
|
|
|
if [ $status -ne 0 ]; then
|
|
log_message "AT command failed: $cmd (exit code: $status)" "error"
|
|
return 1
|
|
fi
|
|
|
|
echo "$output"
|
|
return 0
|
|
}
|
|
|
|
# Function to fetch all modem data at once with a single token
|
|
fetch_modem_data() {
|
|
local token_id=""
|
|
local result=1
|
|
local modem_data=""
|
|
|
|
log_message "Fetching all modem data at once" "info"
|
|
|
|
# Define commands to execute
|
|
local COMMANDS="AT+ICCID AT+CGDCONT? AT+QNWPREFCFG=\"mode_pref\" AT+QNWPREFCFG=\"lte_band\" AT+QNWPREFCFG=\"nsa_nr5g_band\" AT+QNWPREFCFG=\"nr5g_band\" AT+CGSN"
|
|
|
|
# Get token
|
|
token_id=$(acquire_token)
|
|
if [ -z "$token_id" ]; then
|
|
log_message "Failed to acquire token for fetching modem data" "error"
|
|
return 1
|
|
fi
|
|
|
|
# Execute each command and combine outputs
|
|
for cmd in $COMMANDS; do
|
|
log_message "Executing command: $cmd" "debug"
|
|
local output=$(execute_at_command "$cmd" 5 "$token_id")
|
|
local status=$?
|
|
|
|
if [ $status -eq 0 ]; then
|
|
# Append to modem_data
|
|
modem_data="${modem_data}====COMMAND_START:${cmd}====\n${output}\n====COMMAND_END====\n\n"
|
|
else
|
|
log_message "Command failed: $cmd" "warn"
|
|
fi
|
|
done
|
|
|
|
# Release token
|
|
release_token "$token_id"
|
|
|
|
if [ -n "$modem_data" ]; then
|
|
# Save output to DETAILED_LOG for debugging
|
|
echo -e "MODEM DATA:\n$modem_data" >>"$DETAILED_LOG"
|
|
echo "$modem_data"
|
|
return 0
|
|
else
|
|
log_message "No modem data fetched" "error"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Function to extract ICCID from modem data
|
|
extract_iccid() {
|
|
local modem_data="$1"
|
|
local iccid=""
|
|
|
|
# Extract section containing ICCID command response
|
|
local iccid_section=$(echo -e "$modem_data" | sed -n '/====COMMAND_START:AT+ICCID====/,/====COMMAND_END====/p')
|
|
|
|
# Try to extract ICCID (look for 10-20 digit number)
|
|
iccid=$(echo "$iccid_section" | grep -o '[0-9]\{10,20\}' | head -n 1)
|
|
|
|
if [ -z "$iccid" ]; then
|
|
log_message "Failed to extract ICCID from modem data" "error"
|
|
return 1
|
|
fi
|
|
|
|
log_message "Extracted ICCID: $iccid" "info"
|
|
echo "$iccid"
|
|
return 0
|
|
}
|
|
|
|
# Function to extract APN from modem data
|
|
extract_apn() {
|
|
local modem_data="$1"
|
|
local apn=""
|
|
|
|
# Extract section containing CGDCONT command response
|
|
local apn_section=$(echo -e "$modem_data" | sed -n '/====COMMAND_START:AT+CGDCONT?====/,/====COMMAND_END====/p')
|
|
|
|
# Try to extract APN from the response - look for context 1
|
|
apn=$(echo "$apn_section" | grep -o '+CGDCONT: 1,[^,]*,"[^"]*"' | cut -d'"' -f2)
|
|
|
|
if [ -z "$apn" ]; then
|
|
# Try alternative pattern
|
|
apn=$(echo "$apn_section" | grep -o '+CGDCONT: 1,[^,]*,[^,]*' | cut -d',' -f3 | tr -d '"')
|
|
|
|
if [ -z "$apn" ]; then
|
|
log_message "Failed to extract APN from modem data" "error"
|
|
return 1
|
|
fi
|
|
fi
|
|
|
|
log_message "Extracted APN: $apn" "info"
|
|
echo "$apn"
|
|
return 0
|
|
}
|
|
|
|
# Function to extract network mode from modem data
|
|
extract_network_mode() {
|
|
local modem_data="$1"
|
|
local mode=""
|
|
|
|
# Extract section containing mode_pref command response
|
|
local mode_section=$(echo -e "$modem_data" | sed -n '/====COMMAND_START:AT+QNWPREFCFG="mode_pref"====/,/====COMMAND_END====/p')
|
|
|
|
# Try to extract mode from the response
|
|
mode=$(echo "$mode_section" | grep -o '+QNWPREFCFG:.*' | cut -d'"' -f3)
|
|
|
|
if [ -z "$mode" ]; then
|
|
log_message "Failed to extract network mode from modem data" "error"
|
|
return 1
|
|
fi
|
|
|
|
# Clean up the value - remove leading comma if present
|
|
mode=$(echo "$mode" | sed 's/^,//')
|
|
|
|
log_message "Extracted network mode: $mode" "info"
|
|
echo "$mode"
|
|
return 0
|
|
}
|
|
|
|
# Function to extract LTE bands from modem data
|
|
extract_lte_bands() {
|
|
local modem_data="$1"
|
|
local bands=""
|
|
|
|
# Extract section containing lte_band command response
|
|
local bands_section=$(echo -e "$modem_data" | sed -n '/====COMMAND_START:AT+QNWPREFCFG="lte_band"====/,/====COMMAND_END====/p')
|
|
|
|
# Try to extract bands from the response
|
|
bands=$(echo "$bands_section" | grep -o '+QNWPREFCFG:.*' | cut -d'"' -f3)
|
|
|
|
if [ -z "$bands" ]; then
|
|
log_message "Failed to extract LTE bands from modem data" "error"
|
|
return 1
|
|
fi
|
|
|
|
# Convert colon-separated to comma-separated and remove leading comma if present
|
|
bands=$(echo "$bands" | tr ':' ',' | sed 's/^,//')
|
|
|
|
log_message "Extracted LTE bands: $bands" "info"
|
|
echo "$bands"
|
|
return 0
|
|
}
|
|
|
|
# Updated: Function to extract both SA and NSA NR5G bands from modem data
|
|
extract_nr5g_bands() {
|
|
local modem_data="$1"
|
|
local bands_type="$2" # "sa" or "nsa"
|
|
|
|
local section_type=""
|
|
if [ "$bands_type" = "sa" ]; then
|
|
section_type="nr5g_band"
|
|
else
|
|
section_type="nsa_nr5g_band"
|
|
fi
|
|
|
|
# Extract sections containing NR5G band command responses
|
|
local bands_section=$(echo -e "$modem_data" | sed -n "/====COMMAND_START:AT+QNWPREFCFG=\"$section_type\"====/,/====COMMAND_END====/p")
|
|
|
|
# Try to extract bands
|
|
local bands=$(echo "$bands_section" | grep -o '+QNWPREFCFG:.*' | cut -d'"' -f3)
|
|
|
|
if [ -n "$bands" ]; then
|
|
# Clean up the value - convert colon-separated to comma-separated and remove leading comma
|
|
bands=$(echo "$bands" | tr ':' ',' | sed 's/^,//')
|
|
log_message "Extracted $bands_type NR5G bands: $bands" "info"
|
|
echo "$bands"
|
|
return 0
|
|
fi
|
|
|
|
log_message "Failed to extract $bands_type NR5G bands from modem data" "warn"
|
|
return 1
|
|
}
|
|
|
|
# Function to extract IMEI from modem data
|
|
extract_imei() {
|
|
local modem_data="$1"
|
|
local imei=""
|
|
|
|
# Extract section containing CGSN command response
|
|
local imei_section=$(echo -e "$modem_data" | sed -n '/====COMMAND_START:AT+CGSN====/,/====COMMAND_END====/p')
|
|
|
|
# Try to extract IMEI (look for 15 digit number)
|
|
imei=$(echo "$imei_section" | grep -o '[0-9]\{15\}' | head -n 1)
|
|
|
|
if [ -z "$imei" ]; then
|
|
log_message "Failed to extract IMEI from modem data" "error"
|
|
return 1
|
|
fi
|
|
|
|
log_message "Extracted IMEI: $imei" "info"
|
|
echo "$imei"
|
|
return 0
|
|
}
|
|
|
|
# Function to setup TTL configuration persistence
|
|
setup_ttl_persistence() {
|
|
if [ ! -f "/etc/data/lanUtils.sh" ]; then
|
|
log_message "lanUtils.sh not found, TTL changes might not persist across reboots" "warn"
|
|
return 1
|
|
fi
|
|
|
|
# Backup the original script if not already done
|
|
if [ ! -f "/etc/data/lanUtils.sh.bak" ]; then
|
|
cp "/etc/data/lanUtils.sh" "/etc/data/lanUtils.sh.bak"
|
|
fi
|
|
|
|
# Add the local ttl_firewall_file line if it's not already present
|
|
if ! grep -q "local ttl_firewall_file" "/etc/data/lanUtils.sh"; then
|
|
sed -i '/local tcpmss_firewall_filev6/a \ local ttl_firewall_file=/etc/firewall.user.ttl' "/etc/data/lanUtils.sh"
|
|
fi
|
|
|
|
# Add the condition to include the ttl_firewall_file if it's not already present
|
|
if ! grep -q "if \[ -f \"\$ttl_firewall_file\" \]; then" "/etc/data/lanUtils.sh"; then
|
|
sed -i '/if \[ -f "\$tcpmss_firewall_filev6" \]; then/i \ if [ -f "\$ttl_firewall_file" ]; then\n cat \$ttl_firewall_file >> \$firewall_file\n fi' "/etc/data/lanUtils.sh"
|
|
fi
|
|
|
|
log_message "TTL persistence setup completed" "info"
|
|
return 0
|
|
}
|
|
|
|
# Function to apply TTL settings
|
|
apply_ttl_settings() {
|
|
local ttl="$1"
|
|
local current_ttl="$2"
|
|
local token_id="$3"
|
|
local profile_name="$4"
|
|
|
|
# If TTL is not set, default to 0 (disabled)
|
|
ttl="${ttl:-0}"
|
|
current_ttl="${current_ttl:-0}"
|
|
|
|
# Check if change is needed
|
|
if [ "$ttl" = "$current_ttl" ]; then
|
|
log_message "TTL already set to $ttl, no change needed" "debug"
|
|
return 0
|
|
fi
|
|
|
|
update_track "applying" "Setting TTL from '$current_ttl' to '$ttl'" "$profile_name" "85"
|
|
log_message "Changing TTL from '$current_ttl' to '$ttl'" "info"
|
|
|
|
# Create TTL file directory if it doesn't exist
|
|
mkdir -p /etc
|
|
|
|
if [ "$ttl" = "0" ]; then
|
|
# Clear existing rules
|
|
iptables -t mangle -D POSTROUTING -o rmnet+ -j TTL --ttl-set "$current_ttl" 2>/dev/null
|
|
ip6tables -t mangle -D POSTROUTING -o rmnet+ -j HL --hl-set "$current_ttl" 2>/dev/null
|
|
>"/etc/firewall.user.ttl"
|
|
log_message "TTL settings cleared" "info"
|
|
else
|
|
# Clear existing rules
|
|
if [ "$current_ttl" != "0" ]; then
|
|
iptables -t mangle -D POSTROUTING -o rmnet+ -j TTL --ttl-set "$current_ttl" 2>/dev/null
|
|
ip6tables -t mangle -D POSTROUTING -o rmnet+ -j HL --hl-set "$current_ttl" 2>/dev/null
|
|
fi
|
|
|
|
# Set new rules
|
|
echo "iptables -t mangle -A POSTROUTING -o rmnet+ -j TTL --ttl-set $ttl" >"/etc/firewall.user.ttl"
|
|
echo "ip6tables -t mangle -A POSTROUTING -o rmnet+ -j HL --hl-set $ttl" >>"/etc/firewall.user.ttl"
|
|
|
|
# Apply the rules
|
|
iptables -t mangle -A POSTROUTING -o rmnet+ -j TTL --ttl-set "$ttl"
|
|
ip6tables -t mangle -A POSTROUTING -o rmnet+ -j HL --hl-set "$ttl"
|
|
|
|
log_message "TTL changed successfully to $ttl" "info"
|
|
fi
|
|
|
|
# Setup persistence
|
|
setup_ttl_persistence
|
|
|
|
return 0
|
|
}
|
|
|
|
# Function to get current TTL value
|
|
get_current_ttl() {
|
|
local current_ttl=0
|
|
|
|
if [ -f "/etc/firewall.user.ttl" ]; then
|
|
current_ttl=$(grep 'iptables -t mangle -A POSTROUTING' "/etc/firewall.user.ttl" | awk '{for(i=1;i<=NF;i++){if($i=="--ttl-set"){print $(i+1)}}}')
|
|
if ! [[ "$current_ttl" =~ ^[0-9]+$ ]]; then
|
|
current_ttl=0
|
|
fi
|
|
fi
|
|
|
|
log_message "Current TTL value: $current_ttl" "debug"
|
|
echo "$current_ttl"
|
|
return 0
|
|
}
|
|
|
|
# Updated function to apply profile settings with separate SA/NSA NR5G bands and TTL support
|
|
apply_profile_settings() {
|
|
local profile_name="$1"
|
|
local network_type="$2"
|
|
local lte_bands="$3"
|
|
local sa_nr5g_bands="$4"
|
|
local nsa_nr5g_bands="$5"
|
|
local apn="$6"
|
|
local pdp_type="$7"
|
|
local imei="$8"
|
|
local ttl="$9"
|
|
local current_apn="${10}"
|
|
local current_mode="${11}"
|
|
local current_lte_bands="${12}"
|
|
local current_sa_nr5g_bands="${13}"
|
|
local current_nsa_nr5g_bands="${14}"
|
|
local current_imei="${15}"
|
|
local iccid="${16}"
|
|
local mobile_provider="${17}"
|
|
|
|
# Set TTL to 0 (disabled) if not specified
|
|
ttl="${ttl:-0}"
|
|
|
|
log_message "Applying profile '$profile_name' with settings:" "info"
|
|
log_message "- Network type: $network_type" "info"
|
|
log_message "- LTE bands: $lte_bands" "info"
|
|
log_message "- SA NR5G bands: $sa_nr5g_bands" "info"
|
|
log_message "- NSA NR5G bands: $nsa_nr5g_bands" "info"
|
|
log_message "- APN: $apn ($pdp_type)" "info"
|
|
log_message "- IMEI: $imei" "info"
|
|
log_message "- TTL: $ttl" "info"
|
|
log_message "- Mobile Provider: $mobile_provider" "info"
|
|
|
|
# Check if any changes are needed using improved comparison
|
|
local needs_apn_change=0
|
|
local needs_mode_change=0
|
|
local needs_lte_bands_change=0
|
|
local needs_sa_nr5g_bands_change=0
|
|
local needs_nsa_nr5g_bands_change=0
|
|
local needs_imei_change=0
|
|
local needs_ttl_change=0
|
|
local changes_needed=0
|
|
local requires_reboot=0
|
|
local change_for_reboot=""
|
|
|
|
# Use normalized comparison
|
|
compare_values "$current_apn" "$apn" "apn" && needs_apn_change=1 && changes_needed=1
|
|
compare_values "$current_mode" "$network_type" "mode" && needs_mode_change=1 && changes_needed=1
|
|
compare_values "$current_lte_bands" "$lte_bands" "bands" && needs_lte_bands_change=1 && changes_needed=1
|
|
compare_values "$current_sa_nr5g_bands" "$sa_nr5g_bands" "bands" && needs_sa_nr5g_bands_change=1 && changes_needed=1
|
|
compare_values "$current_nsa_nr5g_bands" "$nsa_nr5g_bands" "bands" && needs_nsa_nr5g_bands_change=1 && changes_needed=1
|
|
|
|
# Get current TTL value
|
|
local current_ttl=$(get_current_ttl)
|
|
|
|
# Compare TTL values
|
|
if [ "$current_ttl" != "$ttl" ]; then
|
|
needs_ttl_change=1
|
|
changes_needed=1
|
|
fi
|
|
|
|
# IMEI is a special case - only change if explicitly specified
|
|
if [ -n "$imei" ]; then
|
|
compare_values "$current_imei" "$imei" "imei" && needs_imei_change=1 && changes_needed=1 && requires_reboot=1
|
|
fi
|
|
|
|
if [ $changes_needed -eq 0 ]; then
|
|
log_message "No changes needed for profile '$profile_name', settings already correct" "info"
|
|
mark_profile_applied "$iccid" "$profile_name"
|
|
update_track "success" "Profile already correctly applied" "$profile_name" "100"
|
|
return 0
|
|
fi
|
|
|
|
# Get token for applying settings
|
|
local token_id=$(acquire_token)
|
|
if [ -z "$token_id" ]; then
|
|
log_message "Failed to acquire token for applying profile settings" "error"
|
|
update_track "error" "Failed to acquire token" "$profile_name" "0"
|
|
return 1
|
|
fi
|
|
|
|
local apply_success=1
|
|
local changes_made=0
|
|
|
|
# Apply APN change first (most important)
|
|
if [ $needs_apn_change -eq 1 ]; then
|
|
update_track "applying" "Setting APN from '$current_apn' to '$apn'" "$profile_name" "20"
|
|
log_message "Changing APN from '$current_apn' to '$apn' ($pdp_type)" "info"
|
|
|
|
# Set APN using AT command
|
|
local apn_cmd="AT+CGDCONT=1,\"$pdp_type\",\"$apn\""
|
|
local output=$(execute_at_command "$apn_cmd" 10 "$token_id")
|
|
|
|
if [ $? -eq 0 ]; then
|
|
changes_made=1
|
|
log_message "APN changed successfully to $apn ($pdp_type)" "info"
|
|
|
|
# Verify APN setting - fetch APN again to confirm
|
|
local verify_output=$(execute_at_command "AT+CGDCONT?" 5 "$token_id")
|
|
if echo "$verify_output" | grep -q "\"$apn\""; then
|
|
log_message "APN change verified successfully" "info"
|
|
update_track "applying" "APN set successfully" "$profile_name" "30"
|
|
else
|
|
log_message "APN change could not be verified, continuing anyway" "warn"
|
|
fi
|
|
else
|
|
log_message "Failed to change APN to $apn" "error"
|
|
update_track "error" "Failed to set APN" "$profile_name" "20"
|
|
apply_success=0
|
|
fi
|
|
fi
|
|
|
|
# Apply network mode change
|
|
if [ $needs_mode_change -eq 1 ] && [ $apply_success -eq 1 ]; then
|
|
update_track "applying" "Setting network mode from '$current_mode' to '$network_type'" "$profile_name" "40"
|
|
log_message "Changing network mode from '$current_mode' to '$network_type'" "info"
|
|
|
|
# Format network mode for AT command (may already be in correct format)
|
|
local mode_cmd="AT+QNWPREFCFG=\"mode_pref\",$network_type"
|
|
local output=$(execute_at_command "$mode_cmd" 10 "$token_id")
|
|
|
|
if [ $? -eq 0 ]; then
|
|
changes_made=1
|
|
log_message "Network mode changed successfully to $network_type" "info"
|
|
update_track "applying" "Network mode set successfully" "$profile_name" "50"
|
|
|
|
# If mode includes NR5G, ensure it's enabled
|
|
if echo "$network_type" | grep -q "NR5G"; then
|
|
log_message "Ensuring NR5G is enabled" "debug"
|
|
local nr5g_cmd="AT+QNWPREFCFG=\"nr5g_disable_mode\",0"
|
|
execute_at_command "$nr5g_cmd" 5 "$token_id"
|
|
fi
|
|
else
|
|
log_message "Failed to change network mode to $network_type" "error"
|
|
update_track "applying" "Failed to set network mode, continuing" "$profile_name" "45"
|
|
fi
|
|
fi
|
|
|
|
# Apply LTE bands change
|
|
if [ $needs_lte_bands_change -eq 1 ] && [ $apply_success -eq 1 ] && [ -n "$lte_bands" ]; then
|
|
update_track "applying" "Setting LTE bands from '$current_lte_bands' to '$lte_bands'" "$profile_name" "60"
|
|
log_message "Changing LTE bands from '$current_lte_bands' to '$lte_bands'" "info"
|
|
|
|
# Convert comma-separated to colon-separated for AT command
|
|
local bands_formatted=$(echo "$lte_bands" | tr ',' ':')
|
|
local bands_cmd="AT+QNWPREFCFG=\"lte_band\",$bands_formatted"
|
|
local output=$(execute_at_command "$bands_cmd" 10 "$token_id")
|
|
|
|
if [ $? -eq 0 ]; then
|
|
changes_made=1
|
|
log_message "LTE bands changed successfully to $lte_bands" "info"
|
|
update_track "applying" "LTE bands set successfully" "$profile_name" "70"
|
|
else
|
|
log_message "Failed to change LTE bands to $lte_bands" "error"
|
|
update_track "applying" "Failed to set LTE bands, continuing" "$profile_name" "65"
|
|
fi
|
|
fi
|
|
|
|
# Apply NSA NR5G bands change
|
|
if [ $needs_nsa_nr5g_bands_change -eq 1 ] && [ $apply_success -eq 1 ] && [ -n "$nsa_nr5g_bands" ]; then
|
|
update_track "applying" "Setting NSA NR5G bands from '$current_nsa_nr5g_bands' to '$nsa_nr5g_bands'" "$profile_name" "75"
|
|
log_message "Changing NSA NR5G bands from '$current_nsa_nr5g_bands' to '$nsa_nr5g_bands'" "info"
|
|
|
|
# Convert comma-separated to colon-separated for AT command
|
|
local bands_formatted=$(echo "$nsa_nr5g_bands" | tr ',' ':')
|
|
local nsa_cmd="AT+QNWPREFCFG=\"nsa_nr5g_band\",$bands_formatted"
|
|
local output=$(execute_at_command "$nsa_cmd" 10 "$token_id")
|
|
|
|
if [ $? -eq 0 ]; then
|
|
changes_made=1
|
|
log_message "NSA NR5G bands changed successfully to $nsa_nr5g_bands" "info"
|
|
update_track "applying" "NSA NR5G bands set successfully" "$profile_name" "80"
|
|
else
|
|
log_message "Failed to change NSA NR5G bands to $nsa_nr5g_bands" "error"
|
|
update_track "applying" "Failed to set NSA NR5G bands, continuing" "$profile_name" "75"
|
|
fi
|
|
fi
|
|
|
|
# Apply SA NR5G bands change
|
|
if [ $needs_sa_nr5g_bands_change -eq 1 ] && [ $apply_success -eq 1 ] && [ -n "$sa_nr5g_bands" ]; then
|
|
update_track "applying" "Setting SA NR5G bands from '$current_sa_nr5g_bands' to '$sa_nr5g_bands'" "$profile_name" "85"
|
|
log_message "Changing SA NR5G bands from '$current_sa_nr5g_bands' to '$sa_nr5g_bands'" "info"
|
|
|
|
# Convert comma-separated to colon-separated for AT command
|
|
local bands_formatted=$(echo "$sa_nr5g_bands" | tr ',' ':')
|
|
local sa_cmd="AT+QNWPREFCFG=\"nr5g_band\",$bands_formatted"
|
|
local output=$(execute_at_command "$sa_cmd" 10 "$token_id")
|
|
|
|
if [ $? -eq 0 ]; then
|
|
changes_made=1
|
|
log_message "SA NR5G bands changed successfully to $sa_nr5g_bands" "info"
|
|
update_track "applying" "SA NR5G bands set successfully" "$profile_name" "90"
|
|
else
|
|
log_message "Failed to change SA NR5G bands to $sa_nr5g_bands" "error"
|
|
update_track "applying" "Failed to set SA NR5G bands, continuing" "$profile_name" "85"
|
|
fi
|
|
fi
|
|
|
|
# Apply TTL change if needed
|
|
if [ $needs_ttl_change -eq 1 ] && [ $apply_success -eq 1 ]; then
|
|
apply_ttl_settings "$ttl" "$current_ttl" "$token_id" "$profile_name"
|
|
if [ $? -eq 0 ]; then
|
|
changes_made=1
|
|
log_message "TTL settings applied successfully" "info"
|
|
fi
|
|
fi
|
|
|
|
# Apply IMEI change (requires reboot)
|
|
if [ $needs_imei_change -eq 1 ] && [ $apply_success -eq 1 ] && [ -n "$imei" ]; then
|
|
update_track "applying" "Setting IMEI from '$current_imei' to '$imei'" "$profile_name" "95"
|
|
log_message "Changing IMEI from '$current_imei' to '$imei'" "info"
|
|
|
|
local imei_cmd="AT+EGMR=1,7,\"$imei\""
|
|
local output=$(execute_at_command "$imei_cmd" 10 "$token_id")
|
|
|
|
if [ $? -eq 0 ]; then
|
|
changes_made=1
|
|
requires_reboot=1
|
|
change_for_reboot="IMEI"
|
|
log_message "IMEI changed successfully to $imei (device will reboot)" "info"
|
|
update_track "rebooting" "IMEI changed, device will reboot" "$profile_name" "95"
|
|
else
|
|
log_message "Failed to change IMEI to $imei" "error"
|
|
update_track "applying" "Failed to set IMEI, continuing" "$profile_name" "90"
|
|
requires_reboot=0
|
|
fi
|
|
fi
|
|
|
|
# Apply unique rule setup for Verizon, but also handle "Other" Mobile Providers because of MPDN_rule shenanigans
|
|
# Probably requires reboot
|
|
output_check=$(execute_at_command "AT+QMAP=\"mpdn_rule\"")
|
|
sleep 1 # Short delay to ensure command is processed
|
|
qmap_rule0=$(echo "$output_check" | grep '+QMAP: "MPDN_rule",0,')
|
|
qmap_ippt_rule0=$(echo "$qmap_rule0" | cut -d',' -f5)
|
|
if [ $apply_success -eq 1 ] && [ -n "$mobile_provider" ]; then
|
|
if [ "$mobile_provider" = "Verizon" ]; then
|
|
# If Verizon, data call should be set to rule 3, AT+QMAP="mpdn_rule",0,3,0,0,1
|
|
if echo "$qmap_rule0" | awk -F',' '{exit !($2==0 && $3==3 && $6==1)}'; then
|
|
log_message "Verizon rule already set correctly, no changes needed" "info"
|
|
else
|
|
log_message "Setting Verizon data call mpdn_rule to 3" "info"
|
|
update_track "applying" "Setting Verizon data call rule to 3" "$profile_name" "100"
|
|
verizon_cmd="AT+QMAP=\"mpdn_rule\",0,3,0,$qmap_ippt_rule0,1"
|
|
execute_at_command "$verizon_cmd" 10 "$token_id" >/dev/null
|
|
sleep 1 # Short delay to ensure command is processed
|
|
fi
|
|
elif [ "$mobile_provider" = "Other" ]; then
|
|
# Check if MPDN_rule 0 is already set to all zeros
|
|
if echo "$qmap_rule0" | awk -F',' '{exit !($2==0 && $3==0 && $6==0)}'; then
|
|
log_message "Default rule already set correctly, no changes needed" "info"
|
|
else
|
|
log_message "Setting to default mpdn_rule and releasing" "info"
|
|
update_track "applying" "Setting Default data call mpdn_rule to 0" "$profile_name" "100"
|
|
def_cmd1="AT+QMAP=\"mpdn_rule\",0"
|
|
execute_at_command "$def_cmd1" 10 "$token_id"
|
|
sleep 1 # Short delay to ensure command is processed
|
|
def_cmd2="AT+QMAP=\"mpdn_rule\",0,1,0,$qmap_ippt_rule0,1"
|
|
execute_at_command "$def_cmd2" 10 "$token_id"
|
|
sleep 1 # Short delay to ensure command is processed
|
|
if [ "$qmap_ippt_rule0" = "0" ]; then
|
|
log_message "IPPT is disabled for rule, release the MPDN_rule" "info"
|
|
def_cmd3="AT+QMAP=\"mpdn_rule\",0"
|
|
execute_at_command "$def_cmd3" 10 "$token_id"
|
|
sleep 1 # Short delay to ensure command is processed
|
|
if [ "$(cat /sys/devices/soc0/machine)" = "SDXPINN" ]; then
|
|
requires_reboot=1
|
|
change_for_reboot="MPDN_rule"
|
|
update_track "rebooting" "MPDN_rule released, device will reboot" "$profile_name" "105"
|
|
fi
|
|
else
|
|
log_message "IPPT is enabled for rule0 not releasing MPDN_rule, no reboot needed: IPPT Value $qmap_ippt_rule0" "info"
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# Release token
|
|
release_token "$token_id"
|
|
# Mark profile as applied if changes were made
|
|
if [ $changes_made -eq 1 ]; then
|
|
mark_profile_applied "$iccid" "$profile_name"
|
|
fi
|
|
|
|
# If IMEI was changed, need to reboot
|
|
if [ $requires_reboot -eq 1 ]; then
|
|
log_message "IMEI change requires reboot, scheduling reboot..." "info"
|
|
update_track "rebooting" "Device is rebooting to apply $change_for_reboot change" "$profile_name" "100"
|
|
sleep 2
|
|
reboot &
|
|
return 0
|
|
fi
|
|
|
|
# Force network reset if changes were made but no reboot required
|
|
if [ $changes_made -eq 1 ] && [ $requires_reboot -eq 0 ]; then
|
|
log_message "Changes applied, resetting network connection to apply changes" "info"
|
|
update_track "applying" "Resetting network connection" "$profile_name" "95"
|
|
|
|
# Get a new token for network reset
|
|
token_id=$(acquire_token)
|
|
if [ -n "$token_id" ]; then
|
|
# Force PDP context reconnection - note: errors here are common and non-fatal
|
|
log_message "Forcing network reconnection" "info"
|
|
execute_at_command "AT+COPS=2" 5 "$token_id" || true
|
|
sleep 2
|
|
execute_at_command "AT+COPS=0" 5 "$token_id" || true
|
|
sleep 1
|
|
|
|
# Release token
|
|
release_token "$token_id"
|
|
fi
|
|
fi
|
|
|
|
# Check if any changes were made
|
|
if [ $changes_made -eq 0 ]; then
|
|
log_message "Profile '$profile_name' already applied correctly, no changes needed" "info"
|
|
update_track "success" "Profile already correctly applied" "$profile_name" "100"
|
|
else
|
|
log_message "Successfully applied profile '$profile_name'" "info"
|
|
update_track "success" "Profile applied successfully" "$profile_name" "100"
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
# Check profile function with updated SA/NSA bands and TTL support
|
|
check_profile() {
|
|
local forced="${1:-0}"
|
|
|
|
log_message "Performing profile check (forced=$forced)" "info"
|
|
|
|
# Get all modem data at once with a single token
|
|
local modem_data=""
|
|
modem_data=$(fetch_modem_data)
|
|
if [ $? -ne 0 ]; then
|
|
log_message "Failed to fetch modem data, will retry later" "error"
|
|
update_track "error" "Could not communicate with modem. Will retry later." "unknown" "0"
|
|
return 1
|
|
fi
|
|
|
|
# Extract ICCID from modem data
|
|
local current_iccid=""
|
|
current_iccid=$(extract_iccid "$modem_data")
|
|
if [ $? -ne 0 ]; then
|
|
log_message "Failed to extract ICCID from modem data, will retry later" "error"
|
|
update_track "error" "Could not detect SIM card. Please check that a SIM is inserted." "unknown" "0"
|
|
return 1
|
|
fi
|
|
|
|
log_message "Current ICCID: $current_iccid" "info"
|
|
|
|
# Find profile for current ICCID
|
|
local profile_index=""
|
|
profile_index=$(find_profile_by_iccid "$current_iccid")
|
|
local profile_result=$?
|
|
|
|
# CRITICAL FIX: Early return if no profile is found
|
|
if [ $profile_result -ne 0 ]; then
|
|
log_message "No profile found for ICCID $current_iccid, nothing to apply" "info"
|
|
update_track "idle" "No profile exists for current SIM card. Create a profile to configure network settings." "$current_iccid" "0"
|
|
return 0
|
|
fi
|
|
|
|
# Only continue if we found a valid profile
|
|
log_message "Found valid profile index: $profile_index" "debug"
|
|
|
|
# Get profile details
|
|
local profile_name=$(uci -q get quecprofiles.$profile_index.name)
|
|
local network_type=$(uci -q get quecprofiles.$profile_index.network_type)
|
|
local lte_bands=$(uci -q get quecprofiles.$profile_index.lte_bands)
|
|
local sa_nr5g_bands=$(uci -q get quecprofiles.$profile_index.sa_nr5g_bands)
|
|
local nsa_nr5g_bands=$(uci -q get quecprofiles.$profile_index.nsa_nr5g_bands)
|
|
local apn=$(uci -q get quecprofiles.$profile_index.apn)
|
|
local pdp_type=$(uci -q get quecprofiles.$profile_index.pdp_type)
|
|
local imei=$(uci -q get quecprofiles.$profile_index.imei)
|
|
local ttl=$(uci -q get quecprofiles.$profile_index.ttl)
|
|
local mobile_provider=$(uci -q get quecprofiles.$profile_index.mobile_provider)
|
|
|
|
# Check if profile is paused
|
|
local paused=$(uci -q get quecprofiles.$profile_index.paused)
|
|
paused="${paused:-0}" # Default to not paused if not set
|
|
|
|
# Skip applying paused profiles
|
|
if [ "$paused" = "1" ]; then
|
|
log_message "Profile '$profile_name' is paused, skipping application" "info"
|
|
update_track "paused" "Profile is paused. Resume the profile to apply settings." "$profile_name" "0"
|
|
return 0
|
|
fi
|
|
|
|
# Default pdp_type to "IP" if not specified
|
|
pdp_type="${pdp_type:-IP}"
|
|
# Default TTL to 0 (disabled) if not specified
|
|
ttl="${ttl:-0}"
|
|
|
|
# For backward compatibility - check if old nr5g_bands exists but new fields don't
|
|
local nr5g_bands=$(uci -q get quecprofiles.$profile_index.nr5g_bands)
|
|
if [ -n "$nr5g_bands" ] && [ -z "$sa_nr5g_bands" ] && [ -z "$nsa_nr5g_bands" ]; then
|
|
sa_nr5g_bands=$nr5g_bands
|
|
nsa_nr5g_bands=$nr5g_bands
|
|
log_message "Migrating legacy nr5g_bands for profile $profile_name" "info"
|
|
fi
|
|
|
|
log_message "Found profile: $profile_name for ICCID: $current_iccid" "info"
|
|
log_message "Profile settings: network_type=$network_type, lte_bands=$lte_bands, sa_nr5g_bands=$sa_nr5g_bands, nsa_nr5g_bands=$nsa_nr5g_bands, apn=$apn, pdp_type=$pdp_type, imei=$imei, ttl=$ttl" "info"
|
|
|
|
# Check if APN is configured - it's the minimum required setting
|
|
if [ -z "$apn" ]; then
|
|
log_message "Profile has no APN configured, cannot apply" "error"
|
|
update_track "error" "Profile \"$profile_name\" is missing the required APN setting. Please edit the profile and add an APN." "$profile_name" "0"
|
|
return 1
|
|
fi
|
|
|
|
# Check if profile is already applied (unless forced)
|
|
if [ "$forced" != "1" ] && is_profile_applied "$current_iccid" "$profile_name"; then
|
|
log_message "Profile '$profile_name' is already applied, skipping" "info"
|
|
update_track "success" "Profile already applied (from flag)" "$profile_name" "100"
|
|
return 0
|
|
fi
|
|
|
|
# Apply profile if forced or if autoswitch is enabled
|
|
local enable_autoswitch
|
|
enable_autoswitch=$(uci -q get quecprofiles.settings.enable_autoswitch)
|
|
enable_autoswitch="${enable_autoswitch:-1}" # Default to enabled
|
|
|
|
if [ "$forced" = "1" ] || [ "$enable_autoswitch" = "1" ]; then
|
|
log_message "Applying profile settings..." "info"
|
|
update_track "applying" "Applying profile settings" "$profile_name" "10"
|
|
|
|
# Extract current modem settings for comparison
|
|
local current_apn=""
|
|
local current_mode=""
|
|
local current_lte_bands=""
|
|
local current_sa_nr5g_bands=""
|
|
local current_nsa_nr5g_bands=""
|
|
local current_imei=""
|
|
|
|
current_apn=$(extract_apn "$modem_data")
|
|
current_mode=$(extract_network_mode "$modem_data")
|
|
current_lte_bands=$(extract_lte_bands "$modem_data")
|
|
current_sa_nr5g_bands=$(extract_nr5g_bands "$modem_data" "sa")
|
|
current_nsa_nr5g_bands=$(extract_nr5g_bands "$modem_data" "nsa")
|
|
current_imei=$(extract_imei "$modem_data")
|
|
|
|
# Apply profile settings with the new parameters
|
|
apply_profile_settings "$profile_name" "$network_type" "$lte_bands" "$sa_nr5g_bands" "$nsa_nr5g_bands" \
|
|
"$apn" "$pdp_type" "$imei" "$ttl" "$current_apn" "$current_mode" "$current_lte_bands" \
|
|
"$current_sa_nr5g_bands" "$current_nsa_nr5g_bands" "$current_imei" "$current_iccid" "$mobile_provider"
|
|
return $?
|
|
else
|
|
log_message "Automatic profile switching is disabled, not applying profile" "info"
|
|
update_track "idle" "Automatic profile switching is disabled" "$profile_name" "0"
|
|
return 0
|
|
fi
|
|
}
|
|
|
|
# Main function
|
|
main() {
|
|
log_message "QuecProfiles daemon starting with SA/NSA NR5G and TTL support (PID: $$)" "info"
|
|
|
|
# Clear status files at startup
|
|
rm -f "$TRACK_FILE" "$CHECK_TRIGGER"
|
|
update_track "idle" "Daemon started" "none" "0"
|
|
|
|
# Get check interval from UCI
|
|
local check_interval
|
|
check_interval=$(uci -q get quecprofiles.settings.check_interval)
|
|
check_interval="${check_interval:-$DEFAULT_CHECK_INTERVAL}"
|
|
|
|
# Check autoswitch setting
|
|
local enable_autoswitch
|
|
enable_autoswitch=$(uci -q get quecprofiles.settings.enable_autoswitch)
|
|
enable_autoswitch="${enable_autoswitch:-1}" # Default to enabled
|
|
|
|
log_message "Daemon configured with check_interval=$check_interval seconds, enable_autoswitch=$enable_autoswitch" "info"
|
|
|
|
# Add a startup delay
|
|
log_message "Waiting 10 seconds before initial check..." "info"
|
|
sleep 10
|
|
|
|
# Main loop
|
|
while true; do
|
|
# Check if there's a manual check request
|
|
if [ -f "$CHECK_TRIGGER" ]; then
|
|
log_message "Manual check triggered" "info"
|
|
rm -f "$CHECK_TRIGGER"
|
|
check_profile 1 # Forced check
|
|
elif [ "$enable_autoswitch" -eq 1 ]; then
|
|
# Perform regular check
|
|
check_profile 0 # Regular check
|
|
else
|
|
log_message "Automatic profile switching is disabled" "info"
|
|
update_track "idle" "Automatic profile switching is disabled" "none" "0"
|
|
fi
|
|
|
|
# Sleep for the check interval
|
|
log_message "Sleeping for $check_interval seconds" "info"
|
|
|
|
# Break the sleep into smaller intervals to check for triggers
|
|
sleep_counter=0
|
|
while [ $sleep_counter -lt $check_interval ]; do
|
|
sleep 5
|
|
sleep_counter=$((sleep_counter + 5))
|
|
|
|
# Check for manual trigger during sleep
|
|
if [ -f "$CHECK_TRIGGER" ]; then
|
|
log_message "Manual check triggered during sleep" "info"
|
|
break
|
|
fi
|
|
done
|
|
done
|
|
}
|
|
|
|
# Set up trap handlers for clean shutdown
|
|
trap 'log_message "Received SIGTERM, exiting"; update_track "idle" "Daemon stopped" "none" "0"; exit 0' TERM
|
|
trap 'log_message "Received SIGINT, exiting"; update_track "idle" "Daemon stopped" "none" "0"; exit 0' INT
|
|
|
|
# Start the main function
|
|
main |