高级中学网络规划与设计实现源代码

已于 2025-03-31 16:46:27 修改
阅读量262 收藏 5
点赞数 9
文章标签： 网络 智能路由器
于 2025-03-31 16:45:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_46676829/article/details/146862923
版权

完整实现功能说明

  1. 网络设备扩展：

    • 新增了防火墙(Firewall)和服务器(Server)类
    • 所有设备类都支持VLAN配置
    • 路由器实现了DHCP服务

  2. VLAN管理：

    • 完整的VLAN创建、分配和管理功能
    • 交换机支持VLAN端口映射

  3. 用户认证系统：

    • 网络用户账户管理
    • 无线接入点的认证功能
    • 服务器本地用户认证

  4. 网络监控：

    • 流量记录和分析
    • 设备状态监控
    • 流量统计报表

  5. IP地址管理：

    • DHCP服务实现
    • IP地址池管理

  6. 安全功能：

    • 防火墙规则配置
    • IP黑白名单
    • 无线网络加密认证

  7. 模拟功能：

    • 网络流量生成
    • 设备连接测试
    • 用户认证演示

这个实现提供了一个完整的校园网络模拟系统，涵盖了网络规划、设计、实现和管理的各个方面，可以用于教学演示或网络规划的前期模拟。
 

#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <memory>
#include <random>
#include <ctime>
#include <algorithm>
#include <iomanip>

// 网络流量数据结构
struct NetworkTraffic {
    std::string sourceIP;
    std::string destinationIP;
    int bytes;
    std::string protocol;
    time_t timestamp;
};

// 用户认证信息
struct UserCredentials {
    std::string username;
    std::string password;
    std::string role; // "student", "teacher", "admin"
    std::string department;
};

// VLAN信息
struct VLAN {
    int id;
    std::string name;
    std::string subnet;
    std::vector<std::string> devices;
};

// IP地址池
class IPAddressPool {
private:
    std::string baseIP;
    int startRange;
    int endRange;
    std::map<std::string, bool> allocatedIPs;
    
public:
    IPAddressPool(const std::string& base, int start, int end) 
        : baseIP(base), startRange(start), endRange(end) {
        for (int i = start; i <= end; ++i) {
            std::string ip = baseIP + "." + std::to_string(i);
            allocatedIPs[ip] = false;
        }
    }
    
    std::string allocateIP() {
        for (auto& ip : allocatedIPs) {
            if (!ip.second) {
                ip.second = true;
                return ip.first;
            }
        }
        return ""; // 没有可用IP
    }
    
    bool releaseIP(const std::string& ip) {
        if (allocatedIPs.find(ip) != allocatedIPs.end()) {
            allocatedIPs[ip] = false;
            return true;
        }
        return false;
    }
    
    void displayPool() const {
        std::cout << "IP Address Pool (" << baseIP << ".x):\n";
        for (const auto& ip : allocatedIPs) {
            std::cout << ip.first << " - " << (ip.second ? "Allocated" : "Available") << "\n";
        }
    }
};

// 网络设备基类
class NetworkDevice {
protected:
    std::string name;
    std::string ipAddress;
    std::string macAddress;
    std::string location;
    std::vector<int> vlanIDs;
    std::vector<NetworkTraffic> trafficLog;
    
public:
    std::string getName() const { return name; }
    std::string getIPAddress() const { return ipAddress; }
    NetworkDevice(const std::string& name, const std::string& ip, 
                 const std::string& mac, const std::string& loc)
        : name(name), ipAddress(ip), macAddress(mac), location(loc) {}
    
    virtual ~NetworkDevice() {}
    
    virtual void displayInfo() const {
        std::cout << "Device: " << name 
                  << "\nIP: " << ipAddress
                  << "\nMAC: " << macAddress
                  << "\nLocation: " << location << "\n";
        
        if (!vlanIDs.empty()) {
            std::cout << "VLAN IDs: ";
            for (int id : vlanIDs) {
                std::cout << id << " ";
            }
            std::cout << "\n";
        }
    }
    
    virtual void configure() = 0;
    virtual void testConnection() = 0;
    
    void addVLAN(int vlanID) {
        if (std::find(vlanIDs.begin(), vlanIDs.end(), vlanID) == vlanIDs.end()) {
            vlanIDs.push_back(vlanID);
        }
    }
    
    void removeVLAN(int vlanID) {
        vlanIDs.erase(std::remove(vlanIDs.begin(), vlanIDs.end(), vlanID), vlanIDs.end());
    }
    
    void logTraffic(const NetworkTraffic& traffic) {
        trafficLog.push_back(traffic);
    }
    
    void displayTraffic() const {
        std::cout << "Traffic log for " << name << ":\n";
        for (const auto& traffic : trafficLog) {
            char buffer[80];
            std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", std::localtime(&traffic.timestamp));
            std::cout << buffer << " " << traffic.sourceIP << " -> " << traffic.destinationIP
                      << " (" << traffic.protocol << ") " << traffic.bytes << " bytes\n";
            // std::cout << std::put_time(std::localtime(&traffic.timestamp), "%Y-%m-%d %H:%M:%S")
            //           << " " << traffic.sourceIP << " -> " << traffic.destinationIP
            //           << " (" << traffic.protocol << ") " << traffic.bytes << " bytes\n";
        }
    }
};

// 交换机类
class Switch : public NetworkDevice {
private:
    int portCount;
    std::vector<std::string> connectedDevices;
    std::map<int, std::vector<int>> vlanPortMapping; // VLAN ID -> Port numbers
    
public:
    Switch(const std::string& name, const std::string& ip, 
          const std::string& mac, const std::string& loc, int ports)
        : NetworkDevice(name, ip, mac, loc), portCount(ports) {}
    
    void addConnectedDevice(const std::string& device) {
        connectedDevices.push_back(device);
    }
    
    void displayInfo() const override {
        NetworkDevice::displayInfo();
        std::cout << "Type: Switch\nPorts: " << portCount << "\n";
        std::cout << "Connected Devices: ";
        for (const auto& dev : connectedDevices) {
            std::cout << dev << " ";
        }
        std::cout << "\n";
        
        if (!vlanPortMapping.empty()) {
            std::cout << "VLAN Port Mapping:\n";
            for (const auto& mapping : vlanPortMapping) {
                std::cout << "VLAN " << mapping.first << ": Ports ";
                for (int port : mapping.second) {
                    std::cout << port << " ";
                }
                std::cout << "\n";
            }
        }
    }
    
    void configure() override {
        std::cout << "Configuring switch " << name << "...\n";
        // 这里可以添加实际的配置逻辑
    }
    
    void testConnection() override {
        std::cout << "Testing switch " << name << " connections...\n";
        // 测试连接逻辑
    }
    
    void assignPortToVLAN(int port, int vlanID) {
        vlanPortMapping[vlanID].push_back(port);
        addVLAN(vlanID);
    }
    
    void removePortFromVLAN(int port, int vlanID) {
        auto& ports = vlanPortMapping[vlanID];
        ports.erase(std::remove(ports.begin(), ports.end(), port), ports.end());
        if (ports.empty()) {
            vlanPortMapping.erase(vlanID);
            removeVLAN(vlanID);
        }
    }
};

// 路由器类
class Router : public NetworkDevice {
private:
    std::map<std::string, std::string> routingTable;
    std::vector<VLAN> vlans;
    bool dhcpEnabled;
    IPAddressPool dhcpPool;
    
public:
    Router(const std::string& name, const std::string& ip, 
          const std::string& mac, const std::string& loc)
        : NetworkDevice(name, ip, mac, loc), dhcpEnabled(false), dhcpPool("192.168.1", 100, 200) {}
    
    void addRoute(const std::string& dest, const std::string& gateway) {
        routingTable[dest] = gateway;
    }
    
    void displayInfo() const override {
        NetworkDevice::displayInfo();
        std::cout << "Type: Router\n";
        std::cout << "DHCP: " << (dhcpEnabled ? "Enabled" : "Disabled") << "\n";
        
        if (!routingTable.empty()) {
            std::cout << "Routing Table:\n";
            for (const auto& route : routingTable) {
                std::cout << "Destination: " << route.first 
                          << " -> Gateway: " << route.second << "\n";
            }
        }
        
        if (!vlans.empty()) {
            std::cout << "VLANs:\n";
            for (const auto& vlan : vlans) {
                std::cout << "VLAN " << vlan.id << " (" << vlan.name << "): " 
                          << vlan.subnet << "\n";
            }
        }
    }
    
    void configure() override {
        std::cout << "Configuring router " << name << "...\n";
        // 路由配置逻辑
    }
    
    void testConnection() override {
        std::cout << "Testing router " << name << " connections...\n";
        // 测试连接逻辑
    }
    
    void addVLAN(const VLAN& vlan) {
        vlans.push_back(vlan);
        this->NetworkDevice::addVLAN(vlan.id);
    }
    
    void enableDHCP(bool enable) {
        dhcpEnabled = enable;
        if (enable) {
            std::cout << "DHCP service enabled on router " << name << "\n";
        } else {
            std::cout << "DHCP service disabled on router " << name << "\n";
        }
    }
    
    std::string assignIP() {
        if (dhcpEnabled) {
            return dhcpPool.allocateIP();
        }
        return "";
    }
    
    bool releaseIP(const std::string& ip) {
        return dhcpPool.releaseIP(ip);
    }
    
    void displayDHCPPool() const {
        if (dhcpEnabled) {
            dhcpPool.displayPool();
        } else {
            std::cout << "DHCP is not enabled on this router\n";
        }
    }
};

// 防火墙类
class Firewall : public NetworkDevice {
private:
    std::vector<std::string> allowedIPs;
    std::vector<std::string> blockedIPs;
    std::vector<std::string> securityRules;
    
public:
    Firewall(const std::string& name, const std::string& ip, 
            const std::string& mac, const std::string& loc)
        : NetworkDevice(name, ip, mac, loc) {}
    
    void displayInfo() const override {
        NetworkDevice::displayInfo();
        std::cout << "Type: Firewall\n";
        
        if (!allowedIPs.empty()) {
            std::cout << "Allowed IPs:\n";
            for (const auto& ip : allowedIPs) {
                std::cout << ip << "\n";
            }
        }
        
        if (!blockedIPs.empty()) {
            std::cout << "Blocked IPs:\n";
            for (const auto& ip : blockedIPs) {
                std::cout << ip << "\n";
            }
        }
        
        if (!securityRules.empty()) {
            std::cout << "Security Rules:\n";
            for (const auto& rule : securityRules) {
                std::cout << rule << "\n";
            }
        }
    }
    
    void configure() override {
        std::cout << "Configuring firewall " << name << "...\n";
        // 防火墙配置逻辑
    }
    
    void testConnection() override {
        std::cout << "Testing firewall " << name << " connections...\n";
        // 测试连接逻辑
    }
    
    void addAllowedIP(const std::string& ip) {
        allowedIPs.push_back(ip);
    }
    
    void addBlockedIP(const std::string& ip) {
        blockedIPs.push_back(ip);
    }
    
    void addSecurityRule(const std::string& rule) {
        securityRules.push_back(rule);
    }
    
    bool isAllowed(const std::string& ip) const {
        if (!blockedIPs.empty() && std::find(blockedIPs.begin(), blockedIPs.end(), ip) != blockedIPs.end()) {
            return false;
        }

        // if (std::find(blockedIPs.begin(), blockedIPs.end(), ip) != blockedIPs.end()) {
        //     return false;
        // }
        
        if (!allowedIPs.empty()) {
            return std::find(allowedIPs.begin(), allowedIPs.end(), ip) != allowedIPs.end();
        }
        
        return true;
    }
};

// 服务器类
class Server : public NetworkDevice {
private:
    std::string serverType; // "web", "database", "file", "dns", etc.
    std::vector<std::string> services;
    std::vector<UserCredentials> userAccounts;
    
public:
    Server(const std::string& name, const std::string& ip, 
          const std::string& mac, const std::string& loc, const std::string& type)
        : NetworkDevice(name, ip, mac, loc), serverType(type) {}
    
    void displayInfo() const override {
        NetworkDevice::displayInfo();
        std::cout << "Type: Server (" << serverType << ")\n";
        
        if (!services.empty()) {
            std::cout << "Services:\n";
            for (const auto& service : services) {
                std::cout << service << "\n";
            }
        }
        
        if (!userAccounts.empty()) {
            std::cout << "User Accounts: " << userAccounts.size() << " registered\n";
        }
    }
    
    void configure() override {
        std::cout << "Configuring server " << name << "...\n";
        // 服务器配置逻辑
    }
    
    void testConnection() override {
        std::cout << "Testing server " << name << " connections...\n";
        // 测试连接逻辑
    }
    
    void addService(const std::string& service) {
        services.push_back(service);
    }
    
    void addUser(const UserCredentials& user) {
        userAccounts.push_back(user);
    }
    
    bool authenticateUser(const std::string& username, const std::string& password) const {
        for (const auto& user : userAccounts) {
            if (user.username == username && user.password == password) {
                return true;
            }
        }
        return false;
    }
    
    std::string getUserRole(const std::string& username) const {
        for (const auto& user : userAccounts) {
            if (user.username == username) {
                return user.role;
            }
        }
        return "";
    }
};

// 无线接入点类
class AccessPoint : public NetworkDevice {
private:
    std::string ssid;
    std::string encryption;
    int maxClients;
    std::vector<std::string> connectedClients;
    std::vector<UserCredentials> authorizedUsers;
    
public:
    AccessPoint(const std::string& name, const std::string& ip, 
               const std::string& mac, const std::string& loc,
               const std::string& ssid, const std::string& enc, int max)
        : NetworkDevice(name, ip, mac, loc), ssid(ssid), encryption(enc), maxClients(max) {}
    
    void displayInfo() const override {
        NetworkDevice::displayInfo();
        std::cout << "Type: Wireless Access Point\n"
                  << "SSID: " << ssid << "\n"
                  << "Encryption: " << encryption << "\n"
                  << "Max Clients: " << maxClients << "\n"
                  << "Connected Clients: " << connectedClients.size() << "\n";
    }
    
    void configure() override {
        std::cout << "Configuring access point " << name << "...\n";
        // 无线配置逻辑
    }
    
    void testConnection() override {
        std::cout << "Testing access point " << name << " connections...\n";
        // 测试连接逻辑
    }
    
    bool connectClient(const std::string& clientMAC, const std::string& username, const std::string& password) {
        if (connectedClients.size() >= maxClients) {
            std::cout << "Maximum clients reached for AP " << name << "\n";
            return false;
        }
        
        for (const auto& user : authorizedUsers) {
            if (user.username == username && user.password == password) {
                connectedClients.push_back(clientMAC);
                std::cout << "Client " << clientMAC << " connected to AP " << name << "\n";
                return true;
            }
        }
        
        std::cout << "Authentication failed for client " << clientMAC << "\n";
        return false;
    }
    
    void disconnectClient(const std::string& clientMAC) {
        connectedClients.erase(std::remove(connectedClients.begin(), connectedClients.end(), clientMAC), 
                              connectedClients.end());
    }
    
    void addAuthorizedUser(const UserCredentials& user) {
        authorizedUsers.push_back(user);
    }
};

// 网络监控系统
class NetworkMonitor {
private:
    std::vector<std::weak_ptr<NetworkDevice>> devices;
    std::vector<NetworkTraffic> networkTraffic;
    
public:
    void addDevice(std::weak_ptr<NetworkDevice> device) {
        devices.push_back(device);
    }
    
    void logTraffic(const NetworkTraffic& traffic) {
        networkTraffic.push_back(traffic);
    }
    
    void displayTrafficReport() const {
        std::cout << "=== Network Traffic Report ===\n";
        std::cout << "Total traffic records: " << networkTraffic.size() << "\n";
        
        std::map<std::string, int> trafficByProtocol;
        std::map<std::string, int> trafficBySource;
        std::map<std::string, int> trafficByDestination;
        
        for (const auto& traffic : networkTraffic) {
            trafficByProtocol[traffic.protocol] += traffic.bytes;
            trafficBySource[traffic.sourceIP] += traffic.bytes;
            trafficByDestination[traffic.destinationIP] += traffic.bytes;
        }
        
        std::cout << "\nTraffic by Protocol:\n";
        for (const auto& item : trafficByProtocol) {
            std::cout << item.first << ": " << item.second << " bytes\n";
        }
        
        std::cout << "\nTop Traffic Sources:\n";
        std::vector<std::pair<std::string, int>> sources(trafficBySource.begin(), trafficBySource.end());
        std::sort(sources.begin(), sources.end(), 
                 [](const auto& a, const auto& b) { return a.second > b.second; });
        for (int i = 0; i < std::min(5, (int)sources.size()); ++i) {
            std::cout << sources[i].first << ": " << sources[i].second << " bytes\n";
        }
        
        std::cout << "\nTop Traffic Destinations:\n";
        std::vector<std::pair<std::string, int>> destinations(trafficByDestination.begin(), trafficByDestination.end());
        std::sort(destinations.begin(), destinations.end(), 
                 [](const auto& a, const auto& b) { return a.second > b.second; });
                 for (int i = 0; i < std::min(5, (int)destinations.size()); ++i) {
                     std::cout << destinations[i].first << ": " << destinations[i].second << " bytes\n";
                 }
             }
             
             void checkDeviceStatus() const {
                 std::cout << "=== Device Status Check ===\n";
                 for (const auto& weakDev : devices) {
                     if (auto dev = weakDev.lock()) {
                         std::cout << dev->getName() << ": Online\n";
                     } else {
                         std::cout << "[Device no longer exists]\n";
                     }
                 }
             }
         };
         
         // 校园网络类
         class CampusNetwork {
         private:
             std::vector<std::shared_ptr<NetworkDevice>> devices;
             std::string schoolName;
             std::unique_ptr<NetworkMonitor> monitor;
             std::vector<VLAN> vlans;
             std::vector<UserCredentials> networkUsers;
             
         public:
             CampusNetwork(const std::string& name) : schoolName(name), monitor(std::make_unique<NetworkMonitor>()) {}
             
             void addDevice(std::shared_ptr<NetworkDevice> device) {
                 devices.push_back(device);
                 monitor->addDevice(device);
             }
             
             void displayNetwork() const {
                 std::cout << "=== " << schoolName << " Campus Network ===\n";
                 std::cout << "Total devices: " << devices.size() << "\n";
                 std::cout << "Total VLANs: " << vlans.size() << "\n";
                 std::cout << "Total users: " << networkUsers.size() << "\n\n";
                 
                 for (const auto& device : devices) {
                     device->displayInfo();
                     std::cout << "------------------------\n";
                 }
             }
             
             void configureAll() {
                 std::cout << "Configuring all network devices...\n";
                 for (const auto& device : devices) {
                     device->configure();
                 }
             }
             
             void testAllConnections() {
                 std::cout << "Testing all network connections...\n";
                 for (const auto& device : devices) {
                     device->testConnection();
                 }
             }
             
             void addVLAN(const VLAN& vlan) {
                 vlans.push_back(vlan);
                 std::cout << "Added VLAN " << vlan.id << " (" << vlan.name << ")\n";
             }
             
             void assignDeviceToVLAN(const std::string& deviceName, int vlanID) {
                 for (auto& device : devices) {
                     if (device->getName() == deviceName) {
                         device->addVLAN(vlanID);
                         std::cout << "Assigned " << deviceName << " to VLAN " << vlanID << "\n";
                         
                         // Also add to VLAN's device list
                         for (auto& vlan : vlans) {
                             if (vlan.id == vlanID) {
                                 if (std::find(vlan.devices.begin(), vlan.devices.end(), deviceName) == vlan.devices.end()) {
                                     vlan.devices.push_back(deviceName);
                                 }
                                 break;
                             }
                         }
                         return;
                     }
                 }
                 std::cout << "Device " << deviceName << " not found\n";
             }
             
             void addUser(const UserCredentials& user) {
                 networkUsers.push_back(user);
                 std::cout << "Added user " << user.username << " (" << user.role << ")\n";
             }
             
             bool authenticateUser(const std::string& username, const std::string& password) const {
                 for (const auto& user : networkUsers) {
                     if (user.username == username && user.password == password) {
                         return true;
                     }
                 }
                 return false;
             }
             
             void generateTraffic() {
                 std::cout << "Generating simulated network traffic...\n";
                 std::vector<std::string> protocols = {"HTTP", "HTTPS", "SSH", "FTP", "DNS"};
                 std::random_device rd;
                 std::mt19937 gen(rd());
                 std::uniform_int_distribution<> sizeDist(100, 10000);
                 std::uniform_int_distribution<> protocolDist(0, protocols.size()-1);
                 std::uniform_int_distribution<> deviceDist(0, devices.size()-1);
                 
                 for (int i = 0; i < 20; ++i) { // Generate 20 traffic records
                     int srcIdx = deviceDist(gen);
                     int dstIdx = deviceDist(gen);
                     while (dstIdx == srcIdx) { dstIdx = deviceDist(gen); } // Ensure different devices
                     
                     NetworkTraffic traffic;
                     traffic.sourceIP = devices[srcIdx]->getIPAddress();
                     traffic.destinationIP = devices[dstIdx]->getIPAddress();
                     traffic.bytes = sizeDist(gen);
                     traffic.protocol = protocols[protocolDist(gen)];
                     traffic.timestamp = time(nullptr) - rand() % 3600; // Within last hour
                     
                     // Log to both source device and network monitor
                     devices[srcIdx]->logTraffic(traffic);
                     monitor->logTraffic(traffic);
                 }
             }
             
             void displayTrafficReport() const {
                 monitor->displayTrafficReport();
             }
             
             void checkDeviceStatus() const {
                 monitor->checkDeviceStatus();
             }
             
             void displayVLANs() const {
                 std::cout << "=== VLAN Configuration ===\n";
                 for (const auto& vlan : vlans) {
                     std::cout << "VLAN " << vlan.id << " (" << vlan.name << "): " << vlan.subnet << "\n";
                     std::cout << "Devices: ";
                     for (const auto& dev : vlan.devices) {
                         std::cout << dev << " ";
                     }
                     std::cout << "\n------------------------\n";
                 }
             }
         };
         
         // 主函数 - 演示校园网络
         int main() {
             // 创建校园网络实例
             CampusNetwork xiuShanHighSchool("秀山高级中学");
             
             // 添加VLAN
            //  VLAN vlan10 = {10, "Administration", "192.168.10.0/24"};
            //  VLAN vlan20 = {20, "Classrooms", "192.168.20.0/24"};
            //  VLAN vlan30 = {30, "Library", "192.168.30.0/24"};
            VLAN vlan10 = {10, "Administration", "192.168.10.0/24", {}};
            VLAN vlan20 = {20, "Classrooms", "192.168.20.0/24", {}};
            VLAN vlan30 = {30, "Library", "192.168.30.0/24", {}};

             xiuShanHighSchool.addVLAN(vlan10);
             xiuShanHighSchool.addVLAN(vlan20);
             xiuShanHighSchool.addVLAN(vlan30);
             
             // 添加用户
             xiuShanHighSchool.addUser({"admin", "secure123", "admin", "IT"});
             xiuShanHighSchool.addUser({"teacher1", "teach456", "teacher", "Math"});
             xiuShanHighSchool.addUser({"student1", "learn789", "student", "Grade10"});
             
             // 添加核心交换机
             auto coreSwitch = std::make_shared<Switch>("Core-Switch", "192.168.1.1", 
                                                      "00:1A:2B:3C:4D:5E", "Main Server Room", 48);
             coreSwitch->addConnectedDevice("Router-1");
             coreSwitch->addConnectedDevice("Library-Switch");
             
             // 配置交换机的VLAN端口
             coreSwitch->assignPortToVLAN(1, 10);  // 端口1给管理VLAN
             coreSwitch->assignPortToVLAN(2, 20);  // 端口2给教室VLAN
             coreSwitch->assignPortToVLAN(3, 30);  // 端口3给图书馆VLAN
             
             // 添加路由器
             auto router = std::make_shared<Router>("Router-1", "192.168.1.254", 
                                                  "00:1B:2C:3D:4E:5F", "Main Server Room");
             router->addRoute("10.0.0.0/24", "192.168.1.1");
             router->enableDHCP(true);
             
             // 添加防火墙
             auto firewall = std::make_shared<Firewall>("Main-Firewall", "192.168.1.2",
                                                      "00:1C:2D:3E:4F:5A", "Main Server Room");
             firewall->addAllowedIP("192.168.1.0/24");
             firewall->addBlockedIP("10.10.10.10");
             firewall->addSecurityRule("Block all incoming traffic on port 22 except from 192.168.1.100");
             
             // 添加服务器
             auto webServer = std::make_shared<Server>("Web-Server", "192.168.1.100",
                                                     "00:1D:2E:3F:4A:5B", "Main Server Room", "web");
             webServer->addService("Apache HTTP Server");
             webServer->addService("MySQL Database");
             webServer->addUser({"webadmin", "webpass123", "admin", "IT"});
             
             // 添加无线接入点
             auto libraryAP = std::make_shared<AccessPoint>("Library-AP", "192.168.1.101",
                                                          "00:1E:2F:3A:4B:5C", "Library", 
                                                          "XiuShan-Library", "WPA2-Enterprise", 30);
             libraryAP->addAuthorizedUser({"teacher1", "teach456", "teacher", "Math"});
             libraryAP->addAuthorizedUser({"student1", "learn789", "student", "Grade10"});
             
             // 将设备添加到校园网络
             xiuShanHighSchool.addDevice(coreSwitch);
             xiuShanHighSchool.addDevice(router);
             xiuShanHighSchool.addDevice(firewall);
             xiuShanHighSchool.addDevice(webServer);
             xiuShanHighSchool.addDevice(libraryAP);
             
             // 分配设备到VLAN
             xiuShanHighSchool.assignDeviceToVLAN("Web-Server", 10);  // 管理VLAN
             xiuShanHighSchool.assignDeviceToVLAN("Library-AP", 30);  // 图书馆VLAN
             
             // 显示网络信息
             xiuShanHighSchool.displayNetwork();
             xiuShanHighSchool.displayVLANs();
             
             // 配置和测试网络
             xiuShanHighSchool.configureAll();
             xiuShanHighSchool.testAllConnections();
             
             // 生成并显示网络流量
             xiuShanHighSchool.generateTraffic();
             xiuShanHighSchool.displayTrafficReport();
             
             // 检查设备状态
             xiuShanHighSchool.checkDeviceStatus();
             
             // 演示DHCP功能
             std::cout << "\n=== DHCP Demonstration ===\n";
             std::string assignedIP = router->assignIP();
             std::cout << "Assigned IP: " << assignedIP << "\n";
             router->displayDHCPPool();
             
             // 演示用户认证
             std::cout << "\n=== User Authentication ===\n";
             std::cout << "Teacher login: " << (xiuShanHighSchool.authenticateUser("teacher1", "teach456") ? "Success" : "Failed") << "\n";
             std::cout << "Invalid login: " << (xiuShanHighSchool.authenticateUser("hacker", "password") ? "Success" : "Failed") << "\n";
             
             // 演示无线连接
             std::cout << "\n=== Wireless Connection ===\n";
             libraryAP->connectClient("AA:BB:CC:DD:EE:FF", "student1", "learn789");
             libraryAP->connectClient("11:22:33:44:55:66", "hacker", "password");
             
             return 0;
         }

网络工程设计与系统集成Q-A
weixin_41997073的博客
07-17 1483
一2.什么是网络协议？协议包括哪些要素？举例说明协议工作原理。网络协议为计算机网络中进行数据交换而建立的规则、标准或约定的集合。它确保了数据在网络中的有序、可靠传输，是网络中所有设备之间的通信的基础。网络协议的三要素：语法(数据与控制信息的结构或格式)、语义(需要发出何种控制信息)、时序（事件实现顺序的详细说明，也称为同步）以TCP/IP 协议中 TCP（传输控制协议）为例连接建立（三次握手）客户端发送一个SYN（同步序列编号）包到服务器，并进入SYN_SENT状态，等待服务器确认。
基于单片机实现智慧灯杆--系统分析设计与实现
sinat_59174725的博客
03-25 1734
#多种用户的调研智慧灯杆作为一项多功能的城市基础设施，涉及到多种用户类型，每种用户都有其独特的需求和利益点。
深入理解卷积神经网络（附代码，底层实现）
myDarling_的博客
11-10 2881
剖析卷积神经网络的原理
万石中学高效设备维修管理系统设计与实现
weixin_29935511的博客
11-10 1045
本文还有配套的精品资源，点击获取 简介：万石中学设备报修系统V1.0是一个为学校环境优化的软件解决方案，专门设计用于简化设备维修管理流程，提升工作效率。它包含了设备登记、故障申报、维修跟踪、历史记录保存、资源调度、权限管理、通知提醒、报表统计和用户界面设计等多个关键功能。通过这些功能，学校能够有效地管理维修工作，减少教学中断时间，并为设备管理和资源配置提供数据支持。 ...
基于SpringBoot的服装设计系统的设计与实现
各类程序设计成品、文档、学习资料
06-08 3384
服装系统的主要功能是：用户、管理员、商品类型、商品展示、商品购买、订单结算、商品订单、订单费用、商品收藏、商品浏览等。经过分析,使用B/S架构来开发本服装系统。此系统采用SpringBoot开发框架，SpringBoot技术具有开发软件的特性，其优点是安全性能高，能减轻用户端浏览器的负担，提高交互速度。系统拟选用的SpringBoot技术开发平台先结合Idea编辑器，采用的数据库服务器为MySQL。
springboot大学生网络教学平台的设计与实现毕业设计源码281819
08-18 2260
用户可以进行登录，用户分为管理员、教师和学生。教师登录可实现个人信息管理、公告管理、资料管理（课程的章节管理、）、发布试卷、试卷管理（查看试卷）、分数管理；学生登录可查看个人基本信息、查看公告、下载教学资料、智能学习（课程视频学习、课程讨论）、在线考试、查看考试信息，查看分数、查看课表；管理员身份登录网站后台，拥有权限的管理员将对整个平台进行管理，主要包括用户信息管理（教师信息管理、学生信息管理）、课程管理（可以有什么课程）、班级管理（学习统计（课程视频学习与否（多少）统计、讨论次数统计））...
ssm基于SSM技术的零食销售系统的设计与实现
m0_73268882的博客
07-12 1135
本基于SSM技术的零食销售系统设计目标是实现零食销售的信息化管理，提高管理效率，使得零食销售管理工作规范化、科学化、高效化。本文重点阐述了基于SSM技术的零食销售系统的开发过程，以实际运用为开发背景，基于B/S结构、SSM框架，运用了Java编程语言和MYSQL数据库进行开发，充分保证系统的安全性和稳定性。本系统界面良好，操作简单方便，通过系统概述、系统分析、系统设计、数据库设计、系统测试这几个部分，详细的说明了系统的开发过程，最后并对整个开发过程进行了总结，满足了不同权限用户的功能需求，实现了零食销售相关
java基于ssm的学校教务管理系统的设计与实现论文
2301_82242844的博客
05-04 1121
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
springboot校园二手交易平台的设计与实现毕业设计源码260839
08-28 4707
前端功能： 1.用户注册（注册不需要身份证）与登录，登录密码需用到加密技术； 2.用户发布信息，信息包括商品信息的描述以及商品图片等，参考闲鱼； 3.商品浏览与搜索； 4.商品出售与购买、添加购物车、收藏等； 5.买家与卖家能够进行聊天 6.根据用户的购买记录和收藏记录来进行智能推荐； 7.可以将学校当成分类展示的标准，这样不同学校下就展示不同学校下的商品，因为是校园二手交易网站，想做到真正的面向校园，比如我选择所在学校B大学，就会显示出B大学的学生发布的二手商品信息。 8.用户个人信息管理模块...
ssm基于JavaEE的电脑销售管理系统设计与实现毕业设计源码
08-30 1277
一、前台部分 用户登录与注册 能查看，修改个人信息 产品展示模块（包含一些具体如销量、编号、价格和具体图片展示） 购物车模块 含有其他商品推荐 收银台 订单查看和修改模块 商品检索和浏览模块 二、 后台管理员模块 商品管理 订单管理 网站管理 账号管理...
ASP+ACCESS中学网站设计与实现(论文+源代码+开题报告+任务书).zip
04-19
本系统的开放设计思想有以下几点： 1.尽量采用铁富高级中学现有的软、硬件环境及先进的管理系统开发方案，从而达到充分利用学校现有的资源，提高系统开发水平和应用程序的...ASP+ACCESS中学网站设计与实现(论文+源代码
ASP.NET某中学图书馆系统的设计与实现(源代码+论文).zip
03-05
在本次介绍的“ASP.NET某中学图书馆系统的设计与实现”项目中，开发者使用ASP.NET框架结合C#或VB.NET编程语言，设计并实现了一套适用于中学图书馆环境的网络应用程序。该系统可能涵盖了用户管理、图书检索、借阅管理...
基于ASP.NET教务平台-学籍管理模块开发与设计(源代码+论文).zip
01-01
ASP.NET是一种广泛使用的服务器端的Web应用框架，它由微软公司开发，主要用于构建动态网站、网络应用程序和XML网络服务。教务平台作为教育信息化的重要组成部分，需要具备课程管理、成绩管理、学籍管理等多项功能，...
OSPF综合实验
rumina1233的博客
06-05 229
本文介绍了网络拓扑中三台路由器(R1、R2、R3)的配置过程。主要内容包括：1)为每台路由器配置LoopBack接口地址和物理接口IP地址；2)部署OSPF动态路由协议，将各接口划入区域0并宣告对应网段；3)完成配置后测试网络连通性，客户端成功连接FTP服务器实现文件传输，并通过Web服务器获取网页内容。整个配置过程通过命令行界面完成，涉及接口IP分配、路由协议配置等关键步骤，最终实现了多路由器网络的互联互通和基础服务访问。
java UDP 模板
wu_android的博客
06-05 1134
UDP（User Datagram Protocol）是一种无连接的传输层协议，在 Java 中可以使用 UDP 进行网络编程。
运输层__
最新发布
王老汉的博客
06-07 762
发送方维持一个叫做拥塞窗口cwnd(congestion window)的状态变量，其大小取决于网络的拥塞程度，且在动态变化，发送方让自己的发送窗口等于或小于拥塞窗口。发送方控制拥塞窗口的原则是：只要网络没有出现拥塞，拥塞窗口就再增大一些，以便把更多的分组发送出去。拥塞控制是一个全局性的过程，涉及到所有的主机，所有的路由器，以及与降低网络传输性能有关的所有因素。服务器：SYN=1，ACK=1，seq=y，ack=x+1(注意大小写)服务器：FIN=1，ACK=1，seq=w，ack=u+1。
网络通信核心概念全解析：从IP地址到TCP/UDP实战
ZNing_1的博客
06-05 1278
解析网络通信三要素（IP地址、端口号、协议）与TCP/IP五层模型，对比TCP/UDP特性，演示Socket编程实战，并探讨数据封装/解封装流程及性能优化方案（粘包处理、高并发）。理解网络基础架构，构建高效稳定的通信应用。
Cilium动手实验室: 精通之旅---6.Cilium IPv6 Networking and Observability - Lab
Q先生
06-05 1033
您现在可以在 Kubernetes 中可视化 IPv6 流，并希望您能看到，如果您有合适的工具，在 Kubernetes 上运行 IPv6 并不一定是一场运营噩梦。由于 Pod 被固定到不同的节点，因此它应该显示不同节点上的 Pod 之间的 IPv6 连接成功。验证了使用 ICMPv6 的节点间 IPv6 连接以及通过 HTTP 的 Pod 到服务 IPv6 连接。到目前为止，我们只对 IP 地址进行作。另外个窗口 运行从 pod-worker 到 pod-worker2 的 IPv6 ping。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Shelby-Lee

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值