traceroute 命令详解#

traceroute 是 Linux 系统中用于追踪数据包从源主机到目标主机所经过路径的网络诊断工具。它通过发送具有不同 TTL（Time To Live）值的数据包，逐跳显示网络路径上的路由器信息，是网络故障排查和性能分析的重要工具。

入门#

基本用法#

# 追踪到目标主机的路由
traceroute google.com

# 追踪到 IP 地址的路由
traceroute 8.8.8.8

# 指定最大跳数
traceroute -m 15 google.com

# 指定每个跳数的探测次数
traceroute -q 3 google.com

常用选项#

选项	说明
`-n`	不解析主机名，只显示 IP 地址
`-m`	设置最大跳数（TTL）
`-q`	设置每个跳数的探测次数
`-w`	设置等待响应的超时时间（秒）
`-p`	设置目标端口
`-i`	指定网络接口
`-f`	设置起始 TTL 值
`-z`	设置探测之间的延迟时间

基本示例#

# 追踪到百度的路由
traceroute www.baidu.com

# 输出示例：
# traceroute to www.baidu.com (110.242.68.4), 30 hops max, 60 byte packets
#  1  192.168.1.1 (192.168.1.1)  0.523 ms  0.487 ms  0.456 ms
#  2  10.0.0.1 (10.0.0.1)  2.123 ms  2.098 ms  2.087 ms
#  3  202.96.128.86 (202.96.128.86)  5.234 ms  5.198 ms  5.187 ms
#  ...

# 不解析主机名
traceroute -n google.com

# 设置最大跳数为 15
traceroute -m 15 google.com

中级#

高级选项#

# 使用 ICMP 协议
traceroute -I google.com

# 使用 UDP 协议（默认）
traceroute -U google.com

# 使用 TCP 协议
traceroute -T google.com

# 指定目标端口
traceroute -p 80 google.com

# 指定源端口
traceroute --sport=12345 google.com

# 指定网络接口
traceroute -i eth0 google.com

网络路径分析#

# 追踪网络路径并分析延迟
traceroute google.com | tee route_analysis.txt

# 分析每跳的延迟
traceroute google.com | awk '{print $2, $3}'

# 查找高延迟节点
traceroute google.com | awk '$3 > 100 {print $0}'

# 统计跳数
traceroute google.com | grep -c "ms"

故障排查#

# 检查网络连通性
traceroute google.com

# 检查特定跳数的连通性
traceroute -f 5 -m 5 google.com

# 检查防火墙阻止
traceroute -p 80 google.com
traceroute -p 443 google.com

# 检查路由环路
traceroute -n google.com | grep -E "^\s+\d+\s+\d+\.\d+\.\d+\.\d+"

高级#

性能测试#

# 测试网络路径性能
traceroute -q 10 -w 2 google.com

# 测试不同协议的性能
traceroute -I -q 5 google.com
traceroute -U -q 5 google.com
traceroute -T -q 5 google.com

# 测试网络稳定性
for i in {1..10}; do
    echo "Run $i:"
    traceroute -q 1 google.com | tail -1
    sleep 10
done

路径监控#

#!/bin/bash
# 路由监控脚本

TARGET="google.com"
LOG_FILE="route_monitor.log"

while true; do
    TIMESTAMP=$(date "+%Y-%m-%d %H:%M:%S")
    
    echo "$TIMESTAMP - Route trace to $TARGET:" >> $LOG_FILE
    traceroute -n -q 1 -w 1 $TARGET >> $LOG_FILE 2>&1
    echo "" >> $LOG_FILE
    
    sleep 300
done

路径变化检测#

#!/bin/bash
# 路径变化检测脚本

TARGET="google.com"
BASELINE_FILE="route_baseline.txt"
CURRENT_FILE="route_current.txt"

# 建立基线路径
establish_baseline() {
    echo "Establishing baseline route to $TARGET..."
    traceroute -n -q 1 $TARGET > $BASELINE_FILE
    echo "Baseline established"
}

# 检测路径变化
detect_changes() {
    echo "Detecting route changes..."
    
    traceroute -n -q 1 $TARGET > $CURRENT_FILE
    
    if diff $BASELINE_FILE $CURRENT_FILE > /dev/null; then
        echo "No route changes detected"
    else
        echo "Route changes detected!"
        diff $BASELINE_FILE $CURRENT_FILE
    fi
}

# 主函数
main() {
    case "$1" in
        baseline)
            establish_baseline
            ;;
        check)
            detect_changes
            ;;
        *)
            echo "Usage: $0 {baseline|check}"
            exit 1
            ;;
    esac
}

main "$@"

大师#

网络拓扑分析#

#!/bin/bash
# 网络拓扑分析工具

TARGETS=("google.com" "baidu.com" "github.com")
OUTPUT_DIR="topology_analysis"

mkdir -p $OUTPUT_DIR

# 分析单个目标
analyze_target() {
    local target=$1
    local output_file="$OUTPUT_DIR/${target}_topology.txt"
    
    echo "Analyzing topology for $target..."
    
    echo "=== Topology Analysis for $target ===" > $output_file
    echo "Analysis Time: $(date)" >> $output_file
    echo "" >> $output_file
    
    # 基本路由追踪
    echo "Basic Route:" >> $output_file
    traceroute -n -q 1 $target >> $output_file
    echo "" >> $output_file
    
    # ICMP 追踪
    echo "ICMP Trace:" >> $output_file
    traceroute -I -n -q 1 $target >> $output_file 2>&1
    echo "" >> $output_file
    
    # TCP 追踪
    echo "TCP Trace:" >> $output_file
    traceroute -T -p 80 -n -q 1 $target >> $output_file 2>&1
    echo "" >> $output_file
    
    # 路径延迟分析
    echo "Path Latency Analysis:" >> $output_file
    for i in {1..5}; do
        traceroute -n -q 1 $target | awk '{print $2, $3}' >> $output_file
        sleep 10
    done
    
    echo "Analysis completed: $output_file"
}

# 批量分析
batch_analyze() {
    for target in "${TARGETS[@]}"; do
        analyze_target $target
    done
}

# 比较多个目标的路径
compare_paths() {
    local comparison_file="$OUTPUT_DIR/path_comparison.txt"
    
    echo "=== Path Comparison ===" > $comparison_file
    echo "Comparison Time: $(date)" >> $comparison_file
    echo "" >> $comparison_file
    
    for target in "${TARGETS[@]}"; do
        echo "--- Path to $target ---" >> $comparison_file
        traceroute -n -q 1 $target | head -10 >> $comparison_file
        echo "" >> $comparison_file
    done
    
    echo "Comparison saved to: $comparison_file"
}

# 主函数
main() {
    case "$1" in
        analyze)
            analyze_target "$2"
            ;;
        batch)
            batch_analyze
            ;;
        compare)
            compare_paths
            ;;
        *)
            echo "Usage: $0 {analyze|batch|compare}"
            exit 1
            ;;
    esac
}

main "$@"

网络性能基准测试#

#!/bin/bash
# 网络性能基准测试工具

TARGET="google.com"
TEST_COUNT=10
OUTPUT_FILE="performance_benchmark_$(date +%Y%m%d_%H%M%S).txt"

# 执行单次测试
run_single_test() {
    local test_num=$1
    
    echo "Test $test_num:"
    traceroute -q 1 -w 1 $TARGET | tee -a $OUTPUT_FILE
    echo "" >> $OUTPUT_FILE
}

# 分析性能数据
analyze_performance() {
    echo "=== Performance Analysis ===" >> $OUTPUT_FILE
    echo "" >> $OUTPUT_FILE
    
    # 提取延迟数据
    echo "Hop-by-hop Latency:" >> $OUTPUT_FILE
    grep "ms" $OUTPUT_FILE | awk '{print $2, $3}' | sort -u >> $OUTPUT_FILE
    echo "" >> $OUTPUT_FILE
    
    # 计算平均延迟
    echo "Average Latency per Hop:" >> $OUTPUT_FILE
    grep "ms" $OUTPUT_FILE | awk '{hop=$1; sum+=$3; count++} END {print "Average:", sum/count, "ms"}' >> $OUTPUT_FILE
    echo "" >> $OUTPUT_FILE
    
    # 检测丢包
    echo "Packet Loss:" >> $OUTPUT_FILE
    grep "*" $OUTPUT_FILE | wc -l >> $OUTPUT_FILE
    echo "" >> $OUTPUT_FILE
}

# 执行基准测试
run_benchmark() {
    echo "Starting performance benchmark..."
    echo "Target: $TARGET"
    echo "Test count: $TEST_COUNT"
    echo ""
    
    for ((i=1; i<=TEST_COUNT; i++)); do
        run_single_test $i
        sleep 5
    done
    
    analyze_performance
    
    echo "Benchmark completed. Results saved to: $OUTPUT_FILE"
}

# 主函数
main() {
    case "$1" in
        run)
            run_benchmark
            ;;
        analyze)
            analyze_performance
            ;;
        *)
            echo "Usage: $0 {run|analyze}"
            exit 1
            ;;
    esac
}

main "$@"

网络故障诊断#

#!/bin/bash
# 网络故障诊断工具

TARGET="google.com"
DIAGNOSTIC_LOG="network_diagnostic_$(date +%Y%m%d_%H%M%S).log"

# 基本连通性测试
basic_connectivity_test() {
    echo "=== Basic Connectivity Test ===" >> $DIAGNOSTIC_LOG
    
    if ping -c 4 $TARGET > /dev/null 2>&1; then
        echo "✓ Basic connectivity OK" >> $DIAGNOSTIC_LOG
    else
        echo "✗ Basic connectivity FAILED" >> $DIAGNOSTIC_LOG
    fi
    echo "" >> $DIAGNOSTIC_LOG
}

# 路由追踪测试
route_trace_test() {
    echo "=== Route Trace Test ===" >> $DIAGNOSTIC_LOG
    
    traceroute -n -q 1 -w 1 $TARGET >> $DIAGNOSTIC_LOG 2>&1
    
    if [ $? -eq 0 ]; then
        echo "✓ Route trace completed" >> $DIAGNOSTIC_LOG
    else
        echo "✗ Route trace failed" >> $DIAGNOSTIC_LOG
    fi
    echo "" >> $DIAGNOSTIC_LOG
}

# ICMP 追踪测试
icmp_trace_test() {
    echo "=== ICMP Trace Test ===" >> $DIAGNOSTIC_LOG
    
    traceroute -I -n -q 1 -w 1 $TARGET >> $DIAGNOSTIC_LOG 2>&1
    
    if [ $? -eq 0 ]; then
        echo "✓ ICMP trace completed" >> $DIAGNOSTIC_LOG
    else
        echo "✗ ICMP trace failed (may be blocked by firewall)" >> $DIAGNOSTIC_LOG
    fi
    echo "" >> $DIAGNOSTIC_LOG
}

# TCP 追踪测试
tcp_trace_test() {
    echo "=== TCP Trace Test ===" >> $DIAGNOSTIC_LOG
    
    traceroute -T -p 80 -n -q 1 -w 1 $TARGET >> $DIAGNOSTIC_LOG 2>&1
    
    if [ $? -eq 0 ]; then
        echo "✓ TCP trace completed" >> $DIAGNOSTIC_LOG
    else
        echo "✗ TCP trace failed (port may be blocked)" >> $DIAGNOSTIC_LOG
    fi
    echo "" >> $DIAGNOSTIC_LOG
}

# 路径完整性检查
path_integrity_check() {
    echo "=== Path Integrity Check ===" >> $DIAGNOSTIC_LOG
    
    local lost_hops=$(traceroute -n -q 1 $TARGET 2>&1 | grep -c "\*")
    
    if [ $lost_hops -eq 0 ]; then
        echo "✓ Path integrity OK" >> $DIAGNOSTIC_LOG
    else
        echo "⚠ $lost_hops hops not responding" >> $DIAGNOSTIC_LOG
    fi
    echo "" >> $DIAGNOSTIC_LOG
}

# 延迟分析
latency_analysis() {
    echo "=== Latency Analysis ===" >> $DIAGNOSTIC_LOG
    
    for i in {1..5}; do
        traceroute -n -q 1 $TARGET | grep "ms" | awk '{print $2, $3}' >> $DIAGNOSTIC_LOG
        sleep 2
    done
    echo "" >> $DIAGNOSTIC_LOG
}

# 生成诊断报告
generate_diagnostic_report() {
    echo "Network Diagnostic Report - $(date)" > $DIAGNOSTIC_LOG
    echo "=================================" >> $DIAGNOSTIC_LOG
    echo "Target: $TARGET" >> $DIAGNOSTIC_LOG
    echo "" >> $DIAGNOSTIC_LOG
    
    basic_connectivity_test
    route_trace_test
    icmp_trace_test
    tcp_trace_test
    path_integrity_check
    latency_analysis
    
    echo "Diagnostic completed. Log saved to: $DIAGNOSTIC_LOG"
}

# 主函数
main() {
    generate_diagnostic_report
}

main

无敌#

企业级网络监控系统#

#!/bin/bash
# 企业级网络监控系统

CONFIG_FILE="/etc/network_monitor/config.conf"
LOG_DIR="/var/log/network_monitor"
ALERT_SCRIPT="/usr/local/bin/send_alert.sh"

mkdir -p $LOG_DIR

# 加载配置
source $CONFIG_FILE

# 追踪网络路径
trace_network_path() {
    local target=$1
    local output_file="$LOG_DIR/path_${target}_$(date +%Y%m%d_%H%M%S).txt"
    
    traceroute -n -q 1 -w 1 $target > $output_file 2>&1
    
    return $?
}

# 分析路径变化
analyze_path_changes() {
    local target=$1
    local current_file=$2
    local baseline_file="$LOG_DIR/path_${target}_baseline.txt"
    
    if [ ! -f "$baseline_file" ]; then
        cp $current_file $baseline_file
        echo "Baseline established for $target"
        return 0
    fi
    
    if diff $baseline_file $current_file > /dev/null; then
        return 0
    else
        echo "Path change detected for $target"
        diff $baseline_file $current_file
        return 1
    fi
}

# 检查路径健康
check_path_health() {
    local target=$1
    local output_file=$2
    
    local lost_hops=$(grep "\*" $output_file | wc -l)
    local total_hops=$(grep -c "ms" $output_file)
    
    if [ $lost_hops -gt $MAX_LOST_HOPS ]; then
        echo "ALERT: Too many lost hops for $target: $lost_hops"
        $ALERT_SCRIPT "Path health issue: $target - $lost_hops lost hops"
        return 1
    fi
    
    return 0
}

# 监控网络路径
monitor_network_paths() {
    while true; do
        for target in "${MONITOR_TARGETS[@]}"; do
            local output_file=$(mktemp)
            
            trace_network_path $target
            
            if [ $? -eq 0 ]; then
                analyze_path_changes $target $output_file
                check_path_health $target $output_file
            else
                echo "ERROR: Failed to trace path to $target"
            fi
            
            rm $output_file
        done
        
        sleep $MONITOR_INTERVAL
    done
}

# 生成监控报告
generate_monitor_report() {
    local report_file="$LOG_DIR/monitor_report_$(date +%Y%m%d).txt"
    
    echo "Network Monitor Report - $(date +%Y-%m-%d)" > $report_file
    echo "================================" >> $report_file
    echo "" >> $report_file
    
    for target in "${MONITOR_TARGETS[@]}"; do
        echo "=== $target ===" >> $report_file
        ls -lt $LOG_DIR/path_${target}_*.txt 2>/dev/null | head -5 >> $report_file
        echo "" >> $report_file
    done
    
    echo "Report saved to: $report_file"
}

# 主函数
main() {
    case "$1" in
        monitor)
            monitor_network_paths
            ;;
        report)
            generate_monitor_report
            ;;
        *)
            echo "Usage: $0 {monitor|report}"
            exit 1
            ;;
    esac
}

main "$@"

智能网络诊断系统#

#!/bin/bash
# 智能网络诊断系统

DIAGNOSTIC_DB="/var/lib/network_diagnostic/db"
LOG_FILE="/var/log/network_diagnostic/diagnostic.log"

mkdir -p $DIAGNOSTIC_DB $(dirname $LOG_FILE)

# 执行诊断
perform_diagnostic() {
    local target=$1
    local diagnostic_id=$(date +%s%N)
    local output_dir="$DIAGNOSTIC_DB/$diagnostic_id"
    
    mkdir -p $output_dir
    
    echo "Performing diagnostic for $target (ID: $diagnostic_id)..."
    
    # 基本追踪
    traceroute -n -q 1 $target > $output_dir/basic_trace.txt 2>&1
    
    # ICMP 追踪
    traceroute -I -n -q 1 $target > $output_dir/icmp_trace.txt 2>&1
    
    # TCP 追踪
    traceroute -T -p 80 -n -q 1 $target > $output_dir/tcp_trace.txt 2>&1
    
    # 保存元数据
    echo "target=$target" > $output_dir/metadata.txt
    echo "timestamp=$(date)" >> $output_dir/metadata.txt
    echo "diagnostic_id=$diagnostic_id" >> $output_dir/metadata.txt
    
    echo "Diagnostic completed: $output_dir"
    return $diagnostic_id
}

# 分析诊断结果
analyze_diagnostic() {
    local diagnostic_id=$1
    local output_dir="$DIAGNOSTIC_DB/$diagnostic_id"
    
    if [ ! -d "$output_dir" ]; then
        echo "Diagnostic not found: $diagnostic_id"
        return 1
    fi
    
    echo "=== Diagnostic Analysis ==="
    echo "ID: $diagnostic_id"
    echo "Target: $(grep target $output_dir/metadata.txt | cut -d= -f2)"
    echo ""
    
    # 基本追踪结果
    echo "Basic Trace:"
    cat $output_dir/basic_trace.txt
    echo ""
    
    # ICMP 追踪结果
    echo "ICMP Trace:"
    cat $output_dir/icmp_trace.txt
    echo ""
    
    # TCP 追踪结果
    echo "TCP Trace:"
    cat $output_dir/tcp_trace.txt
    echo ""
    
    # 健康评估
    local lost_hops=$(grep "\*" $output_dir/basic_trace.txt | wc -l)
    if [ $lost_hops -eq 0 ]; then
        echo "✓ Path health: Good"
    elif [ $lost_hops -lt 3 ]; then
        echo "⚠ Path health: Fair ($lost_hops lost hops)"
    else
        echo "✗ Path health: Poor ($lost_hops lost hops)"
    fi
}

# 比较诊断结果
compare_diagnostics() {
    local id1=$1
    local id2=$2
    
    local dir1="$DIAGNOSTIC_DB/$id1"
    local dir2="$DIAGNOSTIC_DB/$id2"
    
    if [ ! -d "$dir1" ] || [ ! -d "$dir2" ]; then
        echo "One or both diagnostics not found"
        return 1
    fi
    
    echo "=== Diagnostic Comparison ==="
    echo "ID1: $id1"
    echo "ID2: $id2"
    echo ""
    
    echo "Basic Trace Comparison:"
    diff $dir1/basic_trace.txt $dir2/basic_trace.txt
    echo ""
    
    echo "ICMP Trace Comparison:"
    diff $dir1/icmp_trace.txt $dir2/icmp_trace.txt
}

# 列出诊断
list_diagnostics() {
    echo "=== Available Diagnostics ==="
    
    for dir in $DIAGNOSTIC_DB/*/; do
        if [ -d "$dir" ]; then
            local id=$(basename $dir)
            local target=$(grep target $dir/metadata.txt | cut -d= -f2)
            local timestamp=$(grep timestamp $dir/metadata.txt | cut -d= -f2)
            
            echo "ID: $id"
            echo "Target: $target"
            echo "Time: $timestamp"
            echo ""
        fi
    done
}

# 主函数
main() {
    case "$1" in
        diagnose)
            perform_diagnostic "$2"
            ;;
        analyze)
            analyze_diagnostic "$2"
            ;;
        compare)
            compare_diagnostics "$2" "$3"
            ;;
        list)
            list_diagnostics
            ;;
        *)
            echo "Usage: $0 {diagnose|analyze|compare|list}"
            exit 1
            ;;
    esac
}

main "$@"

网络路径优化建议#

#!/bin/bash
# 网络路径优化建议工具

TARGET="google.com"
OUTPUT_FILE="path_optimization_$(date +%Y%m%d_%H%M%S).txt"

# 收集路径数据
collect_path_data() {
    echo "=== Path Data Collection ===" > $OUTPUT_FILE
    echo "Target: $TARGET" >> $OUTPUT_FILE
    echo "Collection Time: $(date)" >> $OUTPUT_FILE
    echo "" >> $OUTPUT_FILE
    
    # 基本路径
    echo "Basic Path:" >> $OUTPUT_FILE
    traceroute -n -q 1 $TARGET >> $OUTPUT_FILE
    echo "" >> $OUTPUT_FILE
    
    # ICMP 路径
    echo "ICMP Path:" >> $OUTPUT_FILE
    traceroute -I -n -q 1 $TARGET >> $OUTPUT_FILE 2>&1
    echo "" >> $OUTPUT_FILE
    
    # TCP 路径
    echo "TCP Path:" >> $OUTPUT_FILE
    traceroute -T -p 80 -n -q 1 $TARGET >> $OUTPUT_FILE 2>&1
    echo "" >> $OUTPUT_FILE
}

# 分析路径性能
analyze_path_performance() {
    echo "=== Path Performance Analysis ===" >> $OUTPUT_FILE
    echo "" >> $OUTPUT_FILE
    
    # 提取延迟数据
    echo "Hop Latencies:" >> $OUTPUT_FILE
    grep "ms" $OUTPUT_FILE | awk '{print $2, $3}' | sort -u >> $OUTPUT_FILE
    echo "" >> $OUTPUT_FILE
    
    # 计算统计信息
    echo "Latency Statistics:" >> $OUTPUT_FILE
    grep "ms" $OUTPUT_FILE | awk '{sum+=$3; count++} END {print "Average:", sum/count, "ms"}' >> $OUTPUT_FILE
    echo "" >> $OUTPUT_FILE
    
    # 检测高延迟节点
    echo "High Latency Hops (>100ms):" >> $OUTPUT_FILE
    grep "ms" $OUTPUT_FILE | awk '$3 > 100 {print $0}' >> $OUTPUT_FILE
    echo "" >> $OUTPUT_FILE
}

# 提供优化建议
provide_optimization_suggestions() {
    echo "=== Optimization Suggestions ===" >> $OUTPUT_FILE
    echo "" >> $OUTPUT_FILE
    
    # 检查丢包
    local lost_hops=$(grep "\*" $OUTPUT_FILE | wc -l)
    if [ $lost_hops -gt 0 ]; then
        echo "⚠ Detected $lost_hops unresponsive hops:" >> $OUTPUT_FILE
        echo "   - Consider checking firewall rules" >> $OUTPUT_FILE
        echo "   - Verify network connectivity" >> $OUTPUT_FILE
        echo "   - Contact ISP if issue persists" >> $OUTPUT_FILE
        echo "" >> $OUTPUT_FILE
    fi
    
    # 检查路径长度
    local hop_count=$(grep -c "ms" $OUTPUT_FILE)
    if [ $hop_count -gt 20 ]; then
        echo "⚠ Long path detected ($hop_count hops):" >> $OUTPUT_FILE
        echo "   - Consider using CDN services" >> $OUTPUT_FILE
        echo "   - Evaluate alternative routing options" >> $OUTPUT_FILE
        echo "   - Check with ISP for route optimization" >> $OUTPUT_FILE
        echo "" >> $OUTPUT_FILE
    fi
    
    # 检查 ICMP 阻塞
    if grep -q "ICMP trace" $OUTPUT_FILE && [ $? -ne 0 ]; then
        echo "⚠ ICMP may be blocked:" >> $OUTPUT_FILE
        echo "   - Use TCP tracing for better results" >> $OUTPUT_FILE
        echo "   - Check firewall ICMP rules" >> $OUTPUT_FILE
        echo "" >> $OUTPUT_FILE
    fi
    
    # 一般建议
    echo "General Recommendations:" >> $OUTPUT_FILE
    echo "   - Regularly monitor network path performance" >> $OUTPUT_FILE
    echo "   - Implement redundancy for critical paths" >> $OUTPUT_FILE
    echo "   - Consider using BGP for route optimization" >> $OUTPUT_FILE
    echo "   - Monitor latency trends over time" >> $OUTPUT_FILE
}

# 生成优化报告
generate_optimization_report() {
    collect_path_data
    analyze_path_performance
    provide_optimization_suggestions
    
    echo "Optimization report generated: $OUTPUT_FILE"
}

# 主函数
main() {
    generate_optimization_report
}

main

最佳实践#

使用 -n 选项：避免 DNS 解析，提高性能
合理设置超时：根据网络环境设置合适的超时时间
多次测试：进行多次测试以获得准确结果
结合其他工具：结合 ping、mtr 等工具进行综合诊断
记录基线：建立网络路径基线，便于比较变化
分析丢包：注意分析丢包情况，识别网络问题
使用不同协议：尝试 ICMP、UDP、TCP 等不同协议
注意防火墙：注意防火墙可能阻止某些类型的探测

注意事项#

traceroute 可能被防火墙阻止
某些路由器可能不响应 traceroute 探测
不同操作系统的 traceroute 实现可能不同
在生产环境中使用时要谨慎，避免影响网络性能
注意网络隐私，不要追踪不明来源的地址
结果可能因网络拥塞而变化
对于关键业务，建议使用专业的网络监控工具
注意 TTL 值的设置，避免超过最大跳数
某些网络可能禁止 traceroute 或限制其使用