自动断开闲置网络的脚本

wen 实用脚本 2026-07-31 139

本文目录导读：

自动断开闲置网络的脚本

Windows 版本（批处理）
Linux 版本（Bash）
Python 版本（跨平台）
使用说明
注意事项

我来为您提供一个自动断开闲置网络的脚本方案,这里包含Windows和Linux两个版本的脚本：

Windows 版本（批处理）

@echo off
chcp 65001 >nul自动断开闲置网络监控
color 0A
:: ============================================
:: 自动断开闲置网络脚本 - Windows版本
:: 功能：监控网络流量，如果网络闲置超过设定时间则断开
:: ============================================
:: 配置参数
set "IDLE_TIME=300"        :: 闲置时间阈值（秒），5分钟
set "CHECK_INTERVAL=30"    :: 检查间隔（秒）
set "INTERFACE_NAME="      :: 要监控的接口名，留空则使用默认接口
echo ========================================
echo      自动断开闲置网络监控脚本
echo ========================================
echo 闲置时间阈值: %IDLE_TIME% 秒
echo 检查间隔: %CHECK_INTERVAL% 秒
echo ========================================
echo 按 Ctrl+C 停止监控
echo.
:main_loop
:: 获取当前时间戳
for /f "tokens=2 delims==" %%a in ('wmic OS Get localdatetime /value') do set "datetime=%%a"
set "current_time=%datetime:~0,14%"
:: 获取网络接口信息和流量数据
set "bytes_total=0"
for /f "skip=3 tokens=2,3,4" %%a in ('netstat -e') do (
    if not "%%c"=="" (
        set "bytes_total=%%c"
        goto :have_data
    )
)
:have_data
:: 保存当前字节数到临时文件
echo %bytes_total% > "%temp%\network_load.txt"
echo %current_time% > "%temp%\network_time.txt"
:: 读取上次的字节数（如果存在）
if exist "%temp%\network_load_prev.txt" (
    set /p prev_bytes=<"%temp%\network_load_prev.txt"
    set /p prev_time=<"%temp%\network_time_prev.txt"
    :: 计算流量差
    set /a bytes_diff=bytes_total-prev_bytes
    if !bytes_diff! GEQ 0 (
        echo [%date% %time%] 网络流量: %bytes_diff% 字节
    )
)
:: 检查是否有网络活动
set "is_idle=1"
if exist "%temp%\network_load_prev.txt" (
    set /p prev_bytes=<"%temp%\network_load_prev.txt"
    if !prev_bytes!==!bytes_total! (
        set "is_idle=1"
    ) else (
        set "is_idle=0"
    )
)
:: 如果闲置，增加闲置计数器
if %is_idle%==1 (
    if exist "%temp%\idle_counter.txt" (
        set /p idle_count=<"%temp%\idle_counter.txt"
    ) else (
        set idle_count=0
    )
    set /a idle_count+=%CHECK_INTERVAL%
    if %idle_count% GEQ %IDLE_TIME% (
        echo.
        echo [警告] 网络已闲置 %idle_count% 秒！
        echo 正在断开网络连接...
        :: 断开网络（根据接口类型选择命令）
        if defined INTERFACE_NAME (
            netsh interface set interface "%INTERFACE_NAME%" disabled
        ) else (
            :: 尝试断开所有活动连接
            ipconfig /release
        )
        echo 网络已断开！
        echo 按任意键重新连接...
        pause >nul
        :: 重新连接
        if defined INTERFACE_NAME (
            netsh interface set interface "%INTERFACE_NAME%" enabled
        ) else (
            ipconfig /renew
        )
        :: 重置计数器
        set idle_count=0
    )
    echo %idle_count% > "%temp%\idle_counter.txt"
) else (
    :: 重置闲置计数器
    echo 0 > "%temp%\idle_counter.txt"
)
:: 保存当前数据到临时文件
echo %bytes_total% > "%temp%\network_load_prev.txt"
echo %current_time% > "%temp%\network_time_prev.txt"
:: 等待下一次检查
timeout /t %CHECK_INTERVAL% /nobreak >nul
goto main_loop

Linux 版本（Bash）

#!/bin/bash
# ============================================
# 自动断开闲置网络脚本 - Linux版本
# 功能：监控网络流量，如果网络闲置超过设定时间则断开
# 依赖：需要安装 iptables, ip, ss 等工具
# ============================================
# 配置参数
IDLE_TIME=300          # 闲置时间阈值（秒）
CHECK_INTERVAL=30       # 检查间隔（秒）
INTERFACE="eth0"        # 要监控的网络接口
BREAK_CONNECTION=true   # 是否真正断开连接（false则只记录）
LOG_FILE="/var/log/network_idle.log"
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color
# 日志函数
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}
# 获取网络流量统计
get_network_stats() {
    local iface=$1
    local rx_bytes tx_bytes
    rx_bytes=$(cat /sys/class/net/$iface/statistics/rx_bytes 2>/dev/null || echo 0)
    tx_bytes=$(cat /sys/class/net/$iface/statistics/tx_bytes 2>/dev/null || echo 0)
    echo "$rx_bytes $tx_bytes"
}
# 检查接口是否存在
check_interface() {
    if [ ! -d "/sys/class/net/$INTERFACE" ]; then
        log "错误：网络接口 $INTERFACE 不存在！"
        exit 1
    fi
}
# 断开网络连接
break_connection() {
    log "网络闲置超过 ${IDLE_TIME} 秒，正在断开连接..."
    if [ "$BREAK_CONNECTION" = true ]; then
        # 停用接口（需要root权限）
        sudo ifconfig $INTERFACE down
        # 或者使用 ip 命令
        # sudo ip link set $INTERFACE down
        # 记录断开时间
        echo "DISCONNECTED at $(date)" >> "$LOG_FILE"
    else
        log "（干运行模式）计划断开连接"
    fi
}
# 恢复网络连接
restore_connection() {
    log "恢复网络连接..."
    if [ "$BREAK_CONNECTION" = true ]; then
        # 启用接口
        sudo ifconfig $INTERFACE up
        # 或者使用 ip 命令
        # sudo ip link set $INTERFACE up
        # 记录恢复时间
        echo "RECONNECTED at $(date)" >> "$LOG_FILE"
    fi
}
# 主函数
main() {
    echo "========================================"
    echo "  自动断开闲置网络监控脚本"
    echo "========================================"
    echo "网络接口: $INTERFACE"
    echo "闲置时间阈值: $IDLE_TIME 秒"
    echo "检查间隔: $CHECK_INTERVAL 秒"
    echo "日志文件: $LOG_FILE"
    echo "========================================"
    echo "按 Ctrl+C 停止监控"
    echo ""
    # 检查接口
    check_interface
    # 初始化变量
    prev_stats=""
    idle_counter=0
    # 主循环
    while true; do
        # 获取当前流量统计
        current_stats=$(get_network_stats $INTERFACE)
        current_time=$(date +%s)
        if [ -n "$prev_stats" ]; then
            # 计算流量变化
            prev_rx=$(echo $prev_stats | cut -d' ' -f1)
            prev_tx=$(echo $prev_stats | cut -d' ' -f2)
            curr_rx=$(echo $current_stats | cut -d' ' -f1)
            curr_tx=$(echo $current_stats | cut -d' ' -f2)
            bytes_change=$(( (curr_rx - prev_rx) + (curr_tx - prev_tx) ))
            if [ $bytes_change -gt 0 ]; then
                # 有网络活动
                if [ $idle_counter -gt 0 ]; then
                    log "网络恢复活动（间歇 $idle_counter 秒后）"
                fi
                idle_counter=0
                log "活跃: $bytes_change 字节"
            else
                # 无网络活动
                idle_counter=$((idle_counter + CHECK_INTERVAL))
                log "闲置 ${idle_counter}/${IDLE_TIME} 秒"
                # 检查是否超过阈值
                if [ $idle_counter -ge $IDLE_TIME ]; then
                    break_connection
                    # 等待直到有恢复信号（这里简化处理，等待10分钟）
                    log "等待恢复网络（10分钟后自动恢复）..."
                    sleep 600
                    restore_connection
                    idle_counter=0
                fi
            fi
        fi
        # 保存当前统计数据
        prev_stats=$current_stats
        # 等待下一次检查
        sleep $CHECK_INTERVAL
    done
}
# 捕捉Ctrl+C
trap 'echo ""; log "监控已停止"; exit 0' INT
# 检查root权限
if [ "$EUID" -ne 0 ] && [ "$BREAK_CONNECTION" = true ]; then
    echo "警告：需要root权限才能断开网络连接！"
    echo "建议使用: sudo $0"
fi
# 运行主函数
main

Python 版本（跨平台）

#!/usr/bin/env python3
"""
自动断开闲置网络脚本 - Python版本
支持Windows和Linux
依赖: psutil
安装: pip install psutil
"""
import os
import sys
import time
import platform
import subprocess
import psutil
from datetime import datetime
class NetworkMonitor:
    def __init__(self, idle_time=300, check_interval=30, interface=None):
        """
        初始化监控器
        :param idle_time: 闲置时间阈值（秒）
        :param check_interval: 检查间隔（秒）
        :param interface: 要监控的接口名（None则使用默认）
        """
        self.idle_time = idle_time
        self.check_interval = check_interval
        self.interface = interface
        self.idle_counter = 0
        self.prev_stats = None
        self.is_disconnected = False
    def get_network_stats(self):
        """获取网络流量统计"""
        if self.interface:
            try:
                stats = psutil.net_io_counters(pernic=True)[self.interface]
                return (stats.bytes_sent, stats.bytes_recv)
            except KeyError:
                print(f"错误：接口 {self.interface} 不存在！")
                sys.exit(1)
        else:
            stats = psutil.net_io_counters()
            return (stats.bytes_sent, stats.bytes_recv)
    def check_internet(self):
        """检查互联网连接状态"""
        try:
            import socket
            socket.create_connection(("8.8.8.8", 53), timeout=3)
            return True
        except OSError:
            return False
    def disconnect_network(self):
        """断开网络连接"""
        print(f"\n[{datetime.now()}] 网络闲置超过 {self.idle_time} 秒，正在断开...")
        system = platform.system()
        try:
            if system == "Windows":
                # Windows断开网络
                if self.interface:
                    subprocess.run(
                        ["netsh", "interface", "set", "interface", 
                         self.interface, "disabled"],
                        check=True, capture_output=True
                    )
                else:
                    subprocess.run(["ipconfig", "/release"], check=True)
            elif system == "Linux":
                # Linux断开网络
                if self.interface:
                    subprocess.run(["sudo", "ifconfig", self.interface, "down"], 
                                 check=True)
                else:
                    print("请在Linux系统中指定具体网络接口")
                    return
            else:
                print(f"不支持的系统: {system}")
                return
            self.is_disconnected = True
            print("网络已断开")
        except subprocess.CalledProcessError as e:
            print(f"断开网络失败: {e}")
    def restore_connection(self):
        """恢复网络连接"""
        print(f"\n[{datetime.now()}] 正在恢复网络连接...")
        system = platform.system()
        try:
            if system == "Windows":
                if self.interface:
                    subprocess.run(
                        ["netsh", "interface", "set", "interface",
                         self.interface, "enabled"],
                        check=True, capture_output=True
                    )
                else:
                    subprocess.run(["ipconfig", "/renew"], check=True)
            elif system == "Linux":
                if self.interface:
                    subprocess.run(["sudo", "ifconfig", self.interface, "up"], 
                                 check=True)
                else:
                    print("请在Linux系统中指定具体网络接口")
                    return
            self.is_disconnected = False
            self.idle_counter = 0
            print("网络已恢复")
        except subprocess.CalledProcessError as e:
            print(f"恢复网络失败: {e}")
    def run(self):
        """主监控循环"""
        print("=" * 60)
        print("自动断开闲置网络监控脚本")
        print("=" * 60)
        print(f"系统: {platform.system()}")
        print(f"接口: {self.interface or '默认'}")
        print(f"闲置时间阈值: {self.idle_time} 秒")
        print(f"检查间隔: {self.check_interval} 秒")
        print("=" * 60)
        print("按 Ctrl+C 停止监控")
        print()
        try:
            while True:
                # 获取当前流量
                current_stats = self.get_network_stats()
                if self.prev_stats:
                    # 计算流量变化
                    bytes_sent = current_stats[0] - self.prev_stats[0]
                    bytes_recv = current_stats[1] - self.prev_stats[1]
                    total_change = bytes_sent + bytes_recv
                    if total_change > 0:
                        if self.idle_counter > 0:
                            print(f"[{datetime.now()}] 网络恢复活动")
                        self.idle_counter = 0
                        print(f"[{datetime.now()}] 网络活跃: 发送 {bytes_sent}B / 接收 {bytes_recv}B")
                    else:
                        self.idle_counter += self.check_interval
                        print(f"[{datetime.now()}] 闲置: {self.idle_counter}/{self.idle_time} 秒")
                        if self.idle_counter >= self.idle_time:
                            self.disconnect_network()
                            # 等待恢复（这里简化处理，等待5分钟后恢复）
                            print("等待5分钟后自动恢复...")
                            time.sleep(300)
                            self.restore_connection()
                # 保存当前数据
                self.prev_stats = current_stats
                # 等待下一次检查
                time.sleep(self.check_interval)
        except KeyboardInterrupt:
            print("\n监控已停止")
            if self.is_disconnected:
                print("正在恢复网络连接...")
                self.restore_connection()
            sys.exit(0)
def main():
    """主函数"""
    import argparse
    parser = argparse.ArgumentParser(description="自动断开闲置网络")
    parser.add_argument("-t", "--time", type=int, default=300,
                      help="闲置时间阈值（秒），默认300")
    parser.add_argument("-i", "--interval", type=int, default=30,
                      help="检查间隔（秒），默认30")
    parser.add_argument("-n", "--interface", type=str, default=None,
                      help="网络接口名称")
    parser.add_argument("-d", "--dry-run", action="store_true",
                      help="干运行模式（不真正断开网络）")
    args = parser.parse_args()
    monitor = NetworkMonitor(
        idle_time=args.time,
        check_interval=args.interval,
        interface=args.interface
    )
    # 干运行模式
    if args.dry_run:
        monitor.disconnect_network = lambda: print("[干运行] 计划断开网络")
        monitor.restore_connection = lambda: print("[干运行] 计划恢复网络")
    monitor.run()
if __name__ == "__main__":
    main()

使用说明

Windows 版本

保存为 network_idle.bat
右键以管理员身份运行
修改开头的配置参数

Linux 版本

保存为 network_idle.sh
添加执行权限：chmod +x network_idle.sh
以root运行：sudo ./network_idle.sh

Python 版本

# 安装依赖
pip install psutil
# 运行（默认设置）
python network_monitor.py
# 自定义参数
python network_monitor.py -t 600 -i 30 -n eth0
# 干运行模式（测试）
python network_monitor.py --dry-run

注意事项

权限要求：断开和恢复网络需要管理员/root权限
接口识别：在不同系统上，网络接口名称可能不同（如Windows是"以太网"，Linux是"eth0"）
安全建议：
- 先使用干运行模式测试
- 调整适当的闲置时间阈值避免频繁断网
- 考虑添加异常处理

您可以根据实际需求修改配置参数或扩展功能。

本文地址： https://www.bmjup.com/post/34678.html