curl -s -X 'GET' 'http://127.0.0.1:9801/api/v2/client/mp-speeder' -H 'accept: */*' -H 'Content-Type: application/json'

 /usr/local/bin/mp-speeder/udping -h
Usage of /usr/local/bin/mp-speeder/udping:
  -C int
        ping count
  -I string
        bind interface name
  -c string
        probe address, IP:PORT
  -i duration
        ping interval (default 1s)
  -l int
        payload length
  -logLevel string
        log level, default info
  -o    output to shell
  -v    show version
  -w duration
        ping timeout (default 1s)

-c string 
      probe address, IP:PORT 

  Reference command: /usr/local/bin/mp-speeder/udping -C 100 -I eth0 -c 49.7.248.202:8888 -i 0.1s -l 200

  Reference command: /usr/local/bin/mp-speeder/udping -C 100 -I mp_tun0 -c 49.7.248.202:8888 -i 0.1s -l 200

 Reference command: iperf3 -c x.x.x.x -p 5201 -u -b 100M -B eth0 

Reference command: iperf3 -c x.x.x.x -p 5201 -u -b 100M -B 192.18.0.1

curl -X 'GET' 'http://127.0.0.1:9801/api/v2/client/flowStatistics' -H 'accept: application/json' -H 'all: true'

Code explanation Code rewrite #!/bin/bash
​
# Set color output
YELLOW='\\033[0;33m'
GREEN='\\033[0;32m'
RED='\\033[0;31m'
NC='\\033[0m' # No Color
​
# Global variable used to store the list of ENIs
interfaces=""
​
# Function: Check whether the process is running
check_process() {
    local process_name=$1
    if pgrep -f "$process_name" > /dev/null; then
        echo -e "${GREEN}[✓] Process $process_name is running${NC}"
        return 0
    else
        echo -e "${RED}[✗] Process $process_name is not running${NC}"
        return 1
    fi
}
​
# Function: Check network interface card existence and start up
check_interface() {
    local interface=$1
    if ip link show "$interface" &> /dev/null; then
        if ip link show "$interface" | grep -q "UP"; then
            echo -e "${GREEN}[✓] Network interface card $interface is started and status is normal${NC}"
            return 0
        else
            echo -e "${RED}[✗] Network interface card $interface exists but not started${NC}"
            return 1
        fi
    else
        echo -e "${RED}[✗] Network interface card $interface does not exist${NC}"
        return 1
    fi
}
​
# Function: Check rp_filter
check_rp_filter() {
    if sysctl net.ipv4.conf.mp_tun0.rp_filter | grep -q "net.ipv4.conf.mp_tun0.rp_filter = 1"; then
        echo -e "${RED}[✗] rp_filter is not disabled${NC}"
        return 0
    else
        echo -e "${GREEN}[✓] rp_filter is closed${NC}"
        return 1
    fi
}
​
# Function: Check policy-based routing
check_policy_routing() {
    # Check policy rule existence
    if ip rule | grep -q "from 198.18.0.1 lookup"; then
        local table_num=$(ip rule | grep "from 198.18.0.1 lookup " | awk '{print $NF}')
        echo -e "${GREEN}[✓] Find policy rule: from 198.18.0.1 lookup $table_num${NC}"
        
        # Check default route in routing table
        if ip route show table "$table_num" | grep -q "default dev mp_tun0"; then
            echo -e "${GREEN}[✓] Correct default route exists in route table $table_num${NC}"
        else
            echo -e "${RED}[✗] Correct default route not found in route table $table_num${NC}"
            return 1
        fi
    else
        echo -e "${RED}[✗] Policy rule not found: from 198.18.0.1${NC}"
        return 1
    fi
​
    # Check policy rule existence based on source ip
    
    for iface in $interfaces; do
        # Get the IP address of the network interface card
        local ip_addr=$(ip addr show $iface | awk '/inet / {print $2}' | cut -d/ -f1|head -n 1)
        if [ -z "$ip_addr" ]; then
            echo -e "${YELLOW}[-] Network interface card $iface has no IP address configuration and cannot be used to speed up. Suggest checking${NC}"
            continue
        fi
        
        # Check policy rule existence
        if ip rule | grep -q "from $ip_addr lookup"; then
            local table_num=$(ip rule | grep "from $ip_addr lookup" | awk '{print $NF}')
            echo -e "${GREEN}[✓] Find policy rule for network interface card $iface ($ip_addr): lookup $table_num${NC}"
            
            # Check whether there is a route in routing table
            if ip route show table "$table_num" | grep -q "dev $iface"; then
                echo -e "${GREEN}[✓] Route table $table_num configured correctly${NC}"
            else
                echo -e "${RED}[✗] Route not found in route table $table_num${NC}"
                return 1
            fi
        else
            echo -e "${YELLOW}[-] Policy rule for network interface card $iface ($ip_addr) not found, may affect acceleration performance, enable policy-based routing management in SDK${NC}"
        fi
    done
    return 0
}
​
# Function: check speeder status
check_speeder_status() {
    local response
    response=$(curl -s -X 'GET' 'http://127.0.0.1:9801/api/v2/client/mp-speeder' -H 'accept: */*' -H 'Content-Type: application/json')
    
    if echo "$response" | grep -q '"ready":true'; then
        echo -e "${GREEN}[✓] speeder is running and acceleration status is normal${NC}"
        
        # Extract list of ENIs
        interfaces=$(echo "$response" | sed -n 's/.*"interfaces":\\[\\([^]]*\\)\\].*/\\1/p' | sed 's/"//g' | sed 's/:[0-9]*//g' | tr ',' ' ')
        echo -e "${GREEN}[✓] List of ENIs: $interfaces${NC}"
        return 0
    else
        echo -e "${RED}[✗] speeder is not running or acceleration status is abnormal${NC}"
        return 1
    fi
}
​
# Function: Check traffic diversion rule
check_iptables_rules() {
    echo "Start checking traffic diversion rule..."
    
   # Check traffic diversion rule
    if iptables -L mp_route_mark -nv -t mangle | grep -q "0x1/0xf"; then
        echo -e "${GREEN}[✓] Traffic diversion rule check passed${NC}"
    else
        echo -e "${YELLOW}[-] No traffic diversion rule detected, please confirm whether it meets expectations${NC}"
    fi
    return 0
}
​
# Function: Check L3 feature
check_l3_functionality() {
    echo "Start checking L3 feature..."
​
    # Check wireguard virtual port status
    # /usr/local/bin/mp-speeder/wg show
    # interface: 09yg7kk9di
    #   public key: ISh0Y01aQ3dig5gyuivFnQe8lxi8Sdp3epNReVIYVSI=
    #   private key: (hidden)
    #   listening port: 55368
​
    # peer: RzZ9m8lgMVeFzILbkfLmlM9I3ZBuGoP4hrfe78Vjzg0=
    #   endpoint: 198.18.0.5:10001
    #   allowed ips: 192.168.18.0/28
    #   latest handshake: 1 minute ago
    #   transfer: 3.66 MiB received, 17.26 MiB sent
    #   persistent keepalive: every 15 seconds
    local response
    response=$(/usr/local/bin/mp-speeder/wg show)
    if echo "$response" | grep -q "latest handshake"; then
        echo -e "${GREEN}[✓] wireguard virtual port status is normal${NC}"
    else
        echo -e "${RED}[✗] wireguard virtual port status exception${NC}"
        return 1
    fi
​
    # Check the route table
    local interface_name=$(echo "$response" | grep "interface:" | awk '{print $2}')
    local allowed_ips=$(echo "$response" | grep "allowed ips:" | awk '{print $3}')
​
    if [ -z "$interface_name" ] || [ -z "$allowed_ips" ]; then
        echo -e "${RED}[✗] unable to get interface name or allow IP from wireguard configuration${NC}"
        return 1
    fi
​
    # Check the route table
    local routing_tables=$(ip route)
    local expected_route="$allowed_ips dev $interface_name scope link"
    if echo "$routing_tables" | grep -q "$expected_route"; then
        echo -e "${GREEN}[✓] Correct route exists in routing table: $expected_route${NC}"
    else
        echo -e "${RED}[✗] Correct route not found in routing table: $expected_route${NC}"
        return 1
    fi
​
    # Check whether the endpoint conforms to the 198.18.x.x format
    local endpoint=$(echo "$response" | grep "endpoint:" | awk '{print $2}')
    if echo "$endpoint" | grep -q "198.18."; then
        echo -e "${GREEN}[✓] endpoint complies with the 198.18.x.x format${NC}"
    else
        echo -e "${RED}[✗] endpoint does not match the 198.18.x.x format${NC}"
        return 1
    fi
​
    # Check traffic diversion rule
    # The following rules must exist in the output of iptables -L -nv -t mangle
    # The OUTPUT chain has three chains: mp_route_bypass, mp_route_mark, and mp_l3_route, and mp_route_bypass must be first.
    # 2. The mp_route_bypass chain must have one rule with destination as allowed_ips and target as ACCEPT
    # 3. The mp_l3_route chain must have one rule with destination as endpoint and target as MARK
    local mangle_rules=$(iptables -L OUTPUT -nv -t mangle)
    
    # 1. Check chain sequence in OUTPUT chain
    if ! echo "$mangle_rules" | grep -q "mp_route_bypass" || \\
       ! echo "$mangle_rules" | grep -q "mp_route_mark" || \\
       ! echo "$mangle_rules" | grep -q "mp_l3_route"; then
        echo -e "${RED}[✗] Necessary chain lacks in OUTPUT chain${NC}"
        return 1
    fi
    
    # Confirm mp_route_bypass is in the first position
    if ! iptables -L OUTPUT  1 -nv -t mangle | grep -q "mp_route_bypass"; then
        echo -e "${RED}[✗] mp_route_bypass is not in the first position of OUTPUT chain${NC}"
        return 1
    fi
​
    # 2. Check rules in mp_route_bypass chain
    if ! iptables -L mp_route_bypass -nv -t mangle | grep -q "ACCEPT.*$allowed_ips"; then
        echo -e "${RED}[✗] The mp_route_bypass chain lacks an ACCEPT rule for target $allowed_ips${NC}"
        return 1
    fi
​
    # 3. Check rules in mp_l3_route chain
    endpoint=$(echo "$endpoint" | awk -F ':' '{print $1}')
    if ! iptables -L mp_l3_route -nv -t mangle  | grep -q "$endpoint.*MARK.*0x1/0xf"; then
        echo -e "${RED}[✗] The mp_l3_route chain lacks a MARK rule for target $endpoint${NC}"
        return 1
    fi
​
    echo -e "${GREEN}[✓] iptables rules check passed${NC}"
​
    echo "L3 feature check done"
    return 0
}
​
# Parse command-line parameters.
while [[ "$#" -gt 0 ]]; do
    case $1 in
        -h|--help)
            echo "Usage: $0 [options]"
            echo "Options:"
            echo "  -h, --help         Display help information"
            echo "  -l, --l3-check     Check L3 feature"
            exit 0
            ;;
        -l|--l3-check)
            l3_check=true
            shift
            ;;
        *)
            echo -e "${RED}[✗] Unknown parameter: $1${NC}"
            exit 1
            ;;
    esac
done
​
​
​
echo "Start system check..."
echo "----------------------------------------"
​
echo "1. Check process status:"
# Check mp-sdk process
check_process "mp-sdk"
if [ $? -ne 0 ]; then
    echo -e "\\n${RED}Check failed, stop${NC}"
    exit 1
fi
​
# Check mp-speeder process
check_process "mp-speeder"
if [ $? -ne 0 ]; then
    echo -e "\\n${RED}Check failed, stop${NC}"
    exit 1
fi
​
echo -e "\\n2. Check network interface card status:"
check_interface "mp_tun0"
if [ $? -ne 0 ]; then
    echo -e "\\n${RED}Check failed, stop${NC}"
    exit 1
fi
​
echo -e "\\n3. Check acceleration status:"
check_speeder_status
if [ $? -ne 0 ]; then
    echo -e "\\n${RED}Check failed, stop${NC}"
    exit 1
fi
​
echo -e "\\n4. Check rp_filter configuration:"
check_rp_filter
if [ $? -ne 0 ]; then
    echo -e "\\n${RED}Check failed, stop${NC}"
    exit 1
fi
​
echo -e "\\n5. Check routing configuration:"
check_policy_routing
if [ $? -ne 0 ]; then
    echo -e "\\n${RED}Check failed, stop${NC}"
    exit 1
fi
​
echo -e "\\n6. Check traffic diversion rule configuration:"
check_iptables_rules
if [ $? -ne 0 ]; then
    echo -e "\\n${RED}Check failed, stop${NC}"
    exit 1
fi
​
# If the --l3-check parameter is specified, then execute L3 feature check
if [ "$l3_check" = true ]; then
    echo -e "\\n5. Check L3 feature:"
    check_l3_functionality
    if [ $? -ne 0 ]; then
        echo -e "\\n${RED}L3 feature check failed${NC}"
        exit 1
    fi
fi
​
echo "----------------------------------------"
echo -e "${GREEN}ALL check items are normal${NC}"
exit 0
​

Reference command: curl --interface eth0 ip.sb