ਨੁਕਸ-ਸਹਿਣਸ਼ੀਲ IPeE ਨੈੱਟਵਰਕ ਸੁਧਾਰੇ ਹੋਏ ਸਾਧਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ

ਸਤ ਸ੍ਰੀ ਅਕਾਲ. ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇੱਥੇ 5k ਗਾਹਕਾਂ ਦਾ ਇੱਕ ਨੈਟਵਰਕ ਹੈ। ਹਾਲ ਹੀ ਵਿੱਚ ਇੱਕ ਬਹੁਤ ਹੀ ਸੁਹਾਵਣਾ ਪਲ ਨਹੀਂ ਆਇਆ - ਨੈਟਵਰਕ ਦੇ ਕੇਂਦਰ ਵਿੱਚ ਸਾਡੇ ਕੋਲ ਇੱਕ ਬ੍ਰੋਕੇਡ RX8 ਹੈ ਅਤੇ ਇਸ ਨੇ ਬਹੁਤ ਸਾਰੇ ਅਣਜਾਣ-ਯੂਨੀਕਾਸਟ ਪੈਕੇਟ ਭੇਜਣੇ ਸ਼ੁਰੂ ਕਰ ਦਿੱਤੇ ਹਨ, ਕਿਉਂਕਿ ਨੈਟਵਰਕ ਨੂੰ vlans ਵਿੱਚ ਵੰਡਿਆ ਗਿਆ ਹੈ - ਇਹ ਅੰਸ਼ਕ ਤੌਰ 'ਤੇ ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਹੈ, ਪਰ ਹਨ. ਸਫੈਦ ਪਤਿਆਂ ਲਈ ਵਿਸ਼ੇਸ਼ vlans, ਆਦਿ। ਅਤੇ ਉਹ ਨੈੱਟਵਰਕ ਦੀਆਂ ਸਾਰੀਆਂ ਦਿਸ਼ਾਵਾਂ ਵਿੱਚ ਫੈਲੇ ਹੋਏ ਹਨ। ਇਸ ਲਈ ਹੁਣ ਕਲਪਨਾ ਕਰੋ ਕਿ ਕਿਸੇ ਅਜਿਹੇ ਗਾਹਕ ਦੇ ਪਤੇ 'ਤੇ ਆਉਣ ਵਾਲੇ ਪ੍ਰਵਾਹ ਦੀ ਕਲਪਨਾ ਕਰੋ ਜੋ ਸਰਹੱਦੀ ਵਿਦਿਆਰਥੀ ਵਜੋਂ ਨਹੀਂ ਪੜ੍ਹ ਰਿਹਾ ਹੈ ਅਤੇ ਇਹ ਪ੍ਰਵਾਹ ਕਿਸੇ (ਜਾਂ ਸਾਰੇ) ਪਿੰਡ ਦੇ ਰੇਡੀਓ ਲਿੰਕ ਵੱਲ ਉੱਡਦਾ ਹੈ - ਚੈਨਲ ਬੰਦ ਹੈ - ਗਾਹਕ ਗੁੱਸੇ ਹਨ - ਉਦਾਸੀ ...

ਟੀਚਾ ਇੱਕ ਬੱਗ ਨੂੰ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਵਿੱਚ ਬਦਲਣਾ ਹੈ। ਮੈਂ ਇੱਕ ਪੂਰੇ ਕਲਾਇੰਟ vlan ਦੇ ਨਾਲ q-in-q ਦੀ ਦਿਸ਼ਾ ਵਿੱਚ ਸੋਚ ਰਿਹਾ ਸੀ, ਪਰ P3310 ਵਰਗੇ ਹਰ ਕਿਸਮ ਦੇ ਹਾਰਡਵੇਅਰ, ਜਦੋਂ dot1q ਸਮਰਥਿਤ ਹੁੰਦਾ ਹੈ, DHCP ਨੂੰ ਪਾਸ ਕਰਨਾ ਬੰਦ ਕਰ ਦਿੰਦਾ ਹੈ, ਉਹ ਇਹ ਵੀ ਨਹੀਂ ਜਾਣਦੇ ਕਿ ਕਿਸ ਤਰ੍ਹਾਂ ਚੁਣਨਾ ਹੈ qinq ਅਤੇ ਬਹੁਤ ਸਾਰੇ ਨੁਕਸਾਨ ਉਸ ਕਿਸਮ ਦੀ. ਆਈਪੀ-ਅਨਾਮਬਰਡ ਕੀ ਹੈ ਅਤੇ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ? ਬਹੁਤ ਸੰਖੇਪ ਵਿੱਚ: ਇੰਟਰਫੇਸ 'ਤੇ ਗੇਟਵੇ ਐਡਰੈੱਸ + ਰੂਟ। ਸਾਡੇ ਕੰਮ ਲਈ, ਸਾਨੂੰ ਇਹ ਕਰਨ ਦੀ ਲੋੜ ਹੈ: ਸ਼ੇਪਰ ਨੂੰ ਕੱਟਣਾ, ਗਾਹਕਾਂ ਨੂੰ ਪਤੇ ਵੰਡਣਾ, ਕੁਝ ਖਾਸ ਇੰਟਰਫੇਸਾਂ ਰਾਹੀਂ ਗਾਹਕਾਂ ਲਈ ਰੂਟ ਜੋੜਨਾ। ਇਹ ਸਭ ਕਿਵੇਂ ਕਰਨਾ ਹੈ? ਸ਼ੈਪਰ - lisg, dhcp - db2dhcp ਦੋ ਸੁਤੰਤਰ ਸਰਵਰਾਂ 'ਤੇ, dhcprelay ਐਕਸੈਸ ਸਰਵਰਾਂ 'ਤੇ ਚੱਲਦਾ ਹੈ, ucarp ਵੀ ਐਕਸੈਸ ਸਰਵਰਾਂ 'ਤੇ ਚੱਲਦਾ ਹੈ - ਬੈਕਅੱਪ ਲਈ। ਪਰ ਰੂਟਾਂ ਨੂੰ ਕਿਵੇਂ ਜੋੜਨਾ ਹੈ? ਤੁਸੀਂ ਇੱਕ ਵੱਡੀ ਸਕ੍ਰਿਪਟ ਨਾਲ ਸਭ ਕੁਝ ਪਹਿਲਾਂ ਤੋਂ ਜੋੜ ਸਕਦੇ ਹੋ - ਪਰ ਇਹ ਸੱਚ ਨਹੀਂ ਹੈ। ਇਸ ਲਈ ਅਸੀਂ ਇੱਕ ਸਵੈ-ਲਿਖਤ ਬਸਾਖੀ ਬਣਾਵਾਂਗੇ.

ਇੰਟਰਨੈੱਟ 'ਤੇ ਪੂਰੀ ਖੋਜ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਮੈਨੂੰ C++ ਲਈ ਇੱਕ ਸ਼ਾਨਦਾਰ ਉੱਚ-ਪੱਧਰੀ ਲਾਇਬ੍ਰੇਰੀ ਮਿਲੀ, ਜੋ ਤੁਹਾਨੂੰ ਟ੍ਰੈਫਿਕ ਨੂੰ ਸੁੰਦਰਤਾ ਨਾਲ ਸੁੰਘਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ। ਰੂਟ ਜੋੜਨ ਵਾਲੇ ਪ੍ਰੋਗਰਾਮ ਦਾ ਐਲਗੋਰਿਦਮ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਹੈ - ਅਸੀਂ ਇੰਟਰਫੇਸ 'ਤੇ ਆਰਪੀ ਬੇਨਤੀਆਂ ਨੂੰ ਸੁਣਦੇ ਹਾਂ, ਜੇਕਰ ਸਾਡੇ ਕੋਲ ਸਰਵਰ 'ਤੇ ਲੋ ਇੰਟਰਫੇਸ 'ਤੇ ਕੋਈ ਐਡਰੈੱਸ ਹੈ ਜੋ ਬੇਨਤੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਅਸੀਂ ਇਸ ਇੰਟਰਫੇਸ ਰਾਹੀਂ ਇੱਕ ਰੂਟ ਜੋੜਦੇ ਹਾਂ ਅਤੇ ਇੱਕ ਸਥਿਰ ਆਰਪੀ ਜੋੜਦੇ ਹਾਂ। ਇਸ ਆਈਪੀ ਨੂੰ ਰਿਕਾਰਡ ਕਰੋ - ਆਮ ਤੌਰ 'ਤੇ, ਕੁਝ ਕਾਪੀ-ਪੇਸਟ, ਥੋੜਾ ਜਿਹਾ ਵਿਸ਼ੇਸ਼ਣ ਅਤੇ ਤੁਹਾਡਾ ਕੰਮ ਹੋ ਗਿਆ

'ਰਾਊਟਰ' ਦੇ ਸਰੋਤ

#include <stdio.h>
#include <sys/types.h>
#include <ifaddrs.h>
#include <netinet/in.h>
#include <string.h>
#include <arpa/inet.h>

#include <tins/tins.h>
#include <map>
#include <iostream>
#include <functional>
#include <sstream>

using std::cout;
using std::endl;
using std::map;
using std::bind;
using std::string;
using std::stringstream;

using namespace Tins;

class arp_monitor {
public:
    void run(Sniffer &sniffer);
    void reroute();
    void makegws();
    string iface;
    map <string, string> gws;
private:
    bool callback(const PDU &pdu);
    map <string, string> route_map;
    map <string, string> mac_map;
    map <IPv4Address, HWAddress<6>> addresses;
};

void  arp_monitor::makegws() {
    struct ifaddrs *ifAddrStruct = NULL;
    struct ifaddrs *ifa = NULL;
    void *tmpAddrPtr = NULL;
    gws.clear();
    getifaddrs(&ifAddrStruct);
    for (ifa = ifAddrStruct; ifa != NULL; ifa = ifa->ifa_next) {
        if (!ifa->ifa_addr) {
            continue;
        }
        string ifName = ifa->ifa_name;
        if (ifName == "lo") {
            char addressBuffer[INET_ADDRSTRLEN];
            if (ifa->ifa_addr->sa_family == AF_INET) { // check it is IP4
                // is a valid IP4 Address
                tmpAddrPtr = &((struct sockaddr_in *) ifa->ifa_addr)->sin_addr;
                inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, INET_ADDRSTRLEN);
            } else if (ifa->ifa_addr->sa_family == AF_INET6) { // check it is IP6
                // is a valid IP6 Address
                tmpAddrPtr = &((struct sockaddr_in6 *) ifa->ifa_addr)->sin6_addr;
                inet_ntop(AF_INET6, tmpAddrPtr, addressBuffer, INET6_ADDRSTRLEN);
            } else {
                continue;
            }
            gws[addressBuffer] = addressBuffer;
            cout << "GW " << addressBuffer << " is added" << endl;
        }
    }
    if (ifAddrStruct != NULL) freeifaddrs(ifAddrStruct);
}

void arp_monitor::run(Sniffer &sniffer) {
    cout << "RUNNED" << endl;
    sniffer.sniff_loop(
            bind(
                    &arp_monitor::callback,
                    this,
                    std::placeholders::_1
            )
    );
}

void arp_monitor::reroute() {
    cout << "REROUTING" << endl;
    map<string, string>::iterator it;
    for ( it = route_map.begin(); it != route_map.end(); it++ ) {
        if (this->gws.count(it->second) && !this->gws.count(it->second)) {
            string cmd = "ip route replace ";
            cmd += it->first;
            cmd += " dev " + this->iface;
            cmd += " src " + it->second;
            cmd += " proto static";
            cout << cmd << std::endl;
            cout << "REROUTE " << it->first << " SRC " << it->second << endl;
            system(cmd.c_str());
            cmd = "arp -s ";
            cmd += it->first;
            cmd += " ";
            cmd += mac_map[it->first];
            cout << cmd << endl;
            system(cmd.c_str());

        }
    }
    for ( it = gws.begin(); it != gws.end(); it++ ) {
	string cmd = "arping -U -s ";
	cmd += it->first;
	cmd += " -I ";
	cmd += this->iface;
	cmd += " -b -c 1 ";
	cmd += it->first;
        system(cmd.c_str());
    }
    cout << "REROUTED" << endl;
}

bool arp_monitor::callback(const PDU &pdu) {
    // Retrieve the ARP layer
    const ARP &arp = pdu.rfind_pdu<ARP>();

    if (arp.opcode() == ARP::REQUEST) {
	
        string target = arp.target_ip_addr().to_string();
        string sender = arp.sender_ip_addr().to_string();
        this->route_map[sender] = target;
        this->mac_map[sender] = arp.sender_hw_addr().to_string();
        cout << "save sender " << sender << ":" << this->mac_map[sender] << " want taregt " << target << endl;
        if (this->gws.count(target) && !this->gws.count(sender)) {
            string cmd = "ip route replace ";
            cmd += sender;
            cmd += " dev " + this->iface;
            cmd += " src " + target;
            cmd += " proto static";
//            cout << cmd << std::endl;
/*            cout << "ARP REQUEST FROM " << arp.sender_ip_addr()
                 << " for address " << arp.target_ip_addr()
                 << " sender hw address " << arp.sender_hw_addr() << std::endl
                 << " run cmd: " << cmd << endl;*/
            system(cmd.c_str());
            cmd = "arp -s ";
            cmd += arp.sender_ip_addr().to_string();
            cmd += " ";
            cmd += arp.sender_hw_addr().to_string();
            cout << cmd << endl;
            system(cmd.c_str());
        }
    }
    return true;
}

arp_monitor monitor;
void reroute(int signum) {
    monitor.makegws();
    monitor.reroute();
}

int main(int argc, char *argv[]) {
    string test;
    cout << sizeof(string) << endl;

    if (argc != 2) {
        cout << "Usage: " << *argv << " <interface>" << endl;
        return 1;
    }
    signal(SIGHUP, reroute);
    monitor.iface = argv[1];
    // Sniffer configuration
    SnifferConfiguration config;
    config.set_promisc_mode(true);
    config.set_filter("arp");

    monitor.makegws();

    try {
        // Sniff on the provided interface in promiscuous mode
        Sniffer sniffer(argv[1], config);

        // Only capture arp packets
        monitor.run(sniffer);
    }
    catch (std::exception &ex) {
        std::cerr << "Error: " << ex.what() << std::endl;
    }
}

libtins ਇੰਸਟਾਲੇਸ਼ਨ ਸਕ੍ਰਿਪਟ

#!/bin/bash

git clone https://github.com/mfontanini/libtins.git
cd libtins
mkdir build
cd build
cmake ../
make
make install
ldconfig

ਬਾਈਨਰੀ ਬਣਾਉਣ ਲਈ ਕਮਾਂਡ

g++ main.cpp -o arp-rt -O3 -std=c++11 -lpthread -ltins

ਇਸਨੂੰ ਕਿਵੇਂ ਲਾਂਚ ਕਰਨਾ ਹੈ?

start-stop-daemon --start --exec  /opt/ipoe/arp-routes/arp-rt -b -m -p /opt/ipoe/arp-routes/daemons/eth0.800.pid -- eth0.800

ਹਾਂ - ਇਹ HUP ਸਿਗਨਲ ਦੇ ਅਧਾਰ 'ਤੇ ਟੇਬਲਾਂ ਨੂੰ ਦੁਬਾਰਾ ਬਣਾਏਗਾ। ਤੁਸੀਂ ਨੈੱਟਲਿੰਕ ਦੀ ਵਰਤੋਂ ਕਿਉਂ ਨਹੀਂ ਕੀਤੀ? ਇਹ ਸਿਰਫ ਆਲਸ ਹੈ ਅਤੇ ਲੀਨਕਸ ਇੱਕ ਸਕ੍ਰਿਪਟ ਤੇ ਇੱਕ ਸਕ੍ਰਿਪਟ ਹੈ - ਇਸ ਲਈ ਸਭ ਕੁਝ ਠੀਕ ਹੈ. ਖੈਰ, ਰੂਟ ਰੂਟ ਹਨ, ਅੱਗੇ ਕੀ ਹੈ? ਅੱਗੇ, ਸਾਨੂੰ ਉਹਨਾਂ ਰੂਟਾਂ ਨੂੰ ਭੇਜਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਜੋ ਇਸ ਸਰਵਰ 'ਤੇ ਹਨ ਬਾਰਡਰ 'ਤੇ - ਇੱਥੇ, ਉਸੇ ਪੁਰਾਣੇ ਹਾਰਡਵੇਅਰ ਦੇ ਕਾਰਨ, ਅਸੀਂ ਘੱਟ ਤੋਂ ਘੱਟ ਵਿਰੋਧ ਦਾ ਰਸਤਾ ਲਿਆ - ਅਸੀਂ ਇਹ ਕੰਮ BGP ਨੂੰ ਸੌਂਪਿਆ ਹੈ।

bgp ਸੰਰਚਨਾਮੇਜ਼ਬਾਨ ਨਾਂ *******
ਪਾਸਵਰਡ *******
ਲਾਗ ਫਾਈਲ /var/log/bgp.log
!
# AS ਨੰਬਰ, ਪਤੇ ਅਤੇ ਨੈੱਟਵਰਕ ਫਰਜ਼ੀ ਹਨ
ਰਾਊਟਰ bgp 12345
bgp ਰਾਊਟਰ-id 1.2.3.4
ਜੁੜਿਆ ਮੁੜ ਵੰਡੋ
ਸਥਿਰ ਨੂੰ ਮੁੜ ਵੰਡੋ
ਗੁਆਂਢੀ 1.2.3.1 ਰਿਮੋਟ-ਜਿਵੇਂ 12345
ਗੁਆਂਢੀ 1.2.3.1 ਅਗਲੀ-ਹੌਪ-ਸਵੈ
ਗੁਆਂਢੀ 1.2.3.1 ਰੂਟ-ਮੈਪ ਵਿੱਚ ਕੋਈ ਨਹੀਂ
ਗੁਆਂਢੀ 1.2.3.1 ਰੂਟ-ਮੈਪ ਐਕਸਪੋਰਟ ਕਰੋ
!
ਪਹੁੰਚ-ਸੂਚੀ ਨਿਰਯਾਤ ਪਰਮਿਟ 1.2.3.0/24
!
ਰੂਟ-ਮੈਪ ਨਿਰਯਾਤ ਪਰਮਿਟ 10
ਆਈਪੀ ਐਡਰੈੱਸ ਐਕਸਪੋਰਟ ਨਾਲ ਮੇਲ ਕਰੋ
!
ਰੂਟ-ਨਕਸ਼ੇ ਨਿਰਯਾਤ ਇਨਕਾਰ 20

ਚਲੋ ਜਾਰੀ ਰੱਖੀਏ। ਸਰਵਰ ਨੂੰ arp ਬੇਨਤੀਆਂ ਦਾ ਜਵਾਬ ਦੇਣ ਲਈ, ਤੁਹਾਨੂੰ arp ਪ੍ਰੌਕਸੀ ਨੂੰ ਸਮਰੱਥ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।

echo 1 > /proc/sys/net/ipv4/conf/eth0.800/proxy_arp

ਚਲੋ ਅੱਗੇ ਵਧਦੇ ਹਾਂ - ucarp. ਅਸੀਂ ਇਸ ਚਮਤਕਾਰ ਲਈ ਲਾਂਚ ਸਕ੍ਰਿਪਟਾਂ ਖੁਦ ਲਿਖਦੇ ਹਾਂ.

ਇੱਕ ਡੈਮਨ ਚਲਾਉਣ ਦੀ ਉਦਾਹਰਨ

start-stop-daemon --start --exec  /usr/sbin/ucarp -b -m -p /opt/ipoe/ucarp-gen2/daemons/$iface.$vhid.$virtualaddr.pid -- --interface=eth0.800 --srcip=1.2.3.4 --vhid=1 --pass=carpasword --addr=10.10.10.1 --upscript=/opt/ipoe/ucarp-gen2/up.sh --downscript=/opt/ipoe/ucarp-gen2/down.sh -z -k 10 -P --xparam="10.10.10.0/24"

up.sh

#!/bin/bash

iface=$1
addr=$2
gw=$3

vlan=`echo $1 | sed "s/eth0.//"`


ip ad ad $addr/32 dev lo
ip ro add blackhole $gw
echo 1 > /proc/sys/net/ipv4/conf/$iface/proxy_arp

killall -9 dhcrelay
/etc/init.d/dhcrelay zap
/etc/init.d/dhcrelay start


killall -HUP arp-rt

down.sh

#!/bin/bash

iface=$1
addr=$2
gw=$3

ip ad d $addr/32 dev lo
ip ro de blackhole $gw
echo 0 > /proc/sys/net/ipv4/conf/$iface/proxy_arp


killall -9 dhcrelay
/etc/init.d/dhcrelay zap
/etc/init.d/dhcrelay start

dhcprelay ਨੂੰ ਇੱਕ ਇੰਟਰਫੇਸ ਤੇ ਕੰਮ ਕਰਨ ਲਈ, ਇਸਨੂੰ ਇੱਕ ਐਡਰੈੱਸ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਸਲਈ, ਇੰਟਰਫੇਸ ਤੇ ਜੋ ਅਸੀਂ ਵਰਤਦੇ ਹਾਂ ਅਸੀਂ ਖੱਬਾ ਐਡਰੈੱਸ ਜੋੜਾਂਗੇ - ਉਦਾਹਰਨ ਲਈ 10.255.255.1/32, 10.255.255.2/32, ਆਦਿ। ਮੈਂ ਤੁਹਾਨੂੰ ਇਹ ਨਹੀਂ ਦੱਸਾਂਗਾ ਕਿ ਰੀਲੇਅ ਨੂੰ ਕਿਵੇਂ ਸੰਰਚਿਤ ਕਰਨਾ ਹੈ - ਸਭ ਕੁਝ ਸਧਾਰਨ ਹੈ.

ਤਾਂ ਸਾਡੇ ਕੋਲ ਕੀ ਹੈ? ਗੇਟਵੇਜ਼ ਦਾ ਬੈਕਅੱਪ, ਰੂਟਾਂ ਦੀ ਸਵੈ-ਸੰਰਚਨਾ, dhcp. ਇਹ ਘੱਟੋ ਘੱਟ ਸੈੱਟ ਹੈ - lisg ਵੀ ਇਸਦੇ ਆਲੇ ਦੁਆਲੇ ਹਰ ਚੀਜ਼ ਨੂੰ ਲਪੇਟਦਾ ਹੈ ਅਤੇ ਸਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਹੀ ਇੱਕ ਸ਼ੇਪਰ ਹੈ. ਹਰ ਚੀਜ਼ ਇੰਨੀ ਲੰਬੀ ਅਤੇ ਉਲਝਣ ਵਾਲੀ ਕਿਉਂ ਹੈ? ਕੀ ਐਕਸਲ-ਪੀਪੀਪੀਡੀ ਲੈਣਾ ਅਤੇ ਪੀਪੀਪੀਈ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਵਰਤਣਾ ਆਸਾਨ ਨਹੀਂ ਹੈ? ਨਹੀਂ, ਇਹ ਸੌਖਾ ਨਹੀਂ ਹੈ - ਲੋਕ ਸ਼ਾਇਦ ਹੀ ਇੱਕ ਪੈਚਕਾਰਡ ਨੂੰ ਰਾਊਟਰ ਵਿੱਚ ਫਿੱਟ ਕਰ ਸਕਦੇ ਹਨ, pppoe ਦਾ ਜ਼ਿਕਰ ਨਾ ਕਰਨ ਲਈ. accel-ppp ਇੱਕ ਵਧੀਆ ਚੀਜ਼ ਹੈ - ਪਰ ਇਹ ਸਾਡੇ ਲਈ ਕੰਮ ਨਹੀਂ ਕਰਦੀ ਹੈ - ਕੋਡ ਵਿੱਚ ਬਹੁਤ ਸਾਰੀਆਂ ਗਲਤੀਆਂ ਹਨ - ਇਹ ਟੁੱਟ ਜਾਂਦਾ ਹੈ, ਇਹ ਟੇਢੇ ਢੰਗ ਨਾਲ ਕੱਟਦਾ ਹੈ, ਅਤੇ ਸਭ ਤੋਂ ਦੁਖਦਾਈ ਗੱਲ ਇਹ ਹੈ ਕਿ ਜੇਕਰ ਇਹ ਚਮਕਦਾਰ ਹੋ ਗਿਆ ਹੈ - ਤਾਂ ਲੋਕਾਂ ਨੂੰ ਮੁੜ ਲੋਡ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਸਭ ਕੁਝ - ਫੋਨ ਲਾਲ ਹਨ - ਇਹ ਬਿਲਕੁਲ ਕੰਮ ਨਹੀਂ ਕਰਦਾ ਸੀ। ਕੀਪਲਾਈਵ ਦੀ ਬਜਾਏ ਯੂਕਾਰਪ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਕੀ ਫਾਇਦਾ ਹੈ? ਹਾਂ, ਹਰ ਚੀਜ਼ ਵਿੱਚ - ਇੱਥੇ 100 ਗੇਟਵੇ, Keepalived ਅਤੇ ਸੰਰਚਨਾ ਵਿੱਚ ਇੱਕ ਗਲਤੀ ਹੈ - ਸਭ ਕੁਝ ਕੰਮ ਨਹੀਂ ਕਰਦਾ. 1 ਗੇਟਵੇ ucarp ਨਾਲ ਕੰਮ ਨਹੀਂ ਕਰਦਾ। ਸੁਰੱਖਿਆ ਬਾਰੇ, ਉਹ ਕਹਿੰਦੇ ਹਨ ਕਿ ਖੱਬੇ ਪਾਸੇ ਵਾਲੇ ਆਪਣੇ ਲਈ ਪਤੇ ਰਜਿਸਟਰ ਕਰਨਗੇ ਅਤੇ ਸ਼ੇਅਰ 'ਤੇ ਉਨ੍ਹਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਗੇ - ਇਸ ਪਲ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ, ਅਸੀਂ ਸਾਰੇ ਸਵਿੱਚਾਂ/ਓਲਟਸ/ਬੇਸਾਂ 'ਤੇ dhcp-snooping + source-guard + arp ਨਿਰੀਖਣ ਸਥਾਪਤ ਕਰਦੇ ਹਾਂ। ਜੇ ਕਲਾਇੰਟ ਕੋਲ dhpc ਨਹੀਂ ਹੈ ਪਰ ਪੋਰਟ 'ਤੇ ਸਥਿਰ - ਐਕਸੈਸ-ਲਿਸਟ ਹੈ।

ਇਹ ਸਭ ਕਿਉਂ ਕੀਤਾ ਗਿਆ? ਅਣਚਾਹੇ ਆਵਾਜਾਈ ਨੂੰ ਨਸ਼ਟ ਕਰਨ ਲਈ. ਹੁਣ ਹਰ ਇੱਕ ਸਵਿੱਚ ਦਾ ਆਪਣਾ vlan ਹੈ ਅਤੇ ਅਗਿਆਤ-ਯੂਨੀਕਾਸਟ ਹੁਣ ਡਰਾਉਣਾ ਨਹੀਂ ਹੈ, ਕਿਉਂਕਿ ਇਸਨੂੰ ਸਿਰਫ਼ ਇੱਕ ਪੋਰਟ 'ਤੇ ਜਾਣ ਦੀ ਲੋੜ ਹੈ ਨਾ ਕਿ ਸਭ ਨੂੰ... ਖੈਰ, ਮਾੜੇ ਪ੍ਰਭਾਵ ਇੱਕ ਪ੍ਰਮਾਣਿਤ ਉਪਕਰਣ ਸੰਰਚਨਾ ਹਨ, ਐਡਰੈੱਸ ਸਪੇਸ ਨਿਰਧਾਰਤ ਕਰਨ ਵਿੱਚ ਵਧੇਰੇ ਕੁਸ਼ਲਤਾ।

lisg ਨੂੰ ਕਿਵੇਂ ਸੰਰਚਿਤ ਕਰਨਾ ਹੈ ਇੱਕ ਵੱਖਰਾ ਵਿਸ਼ਾ ਹੈ। ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੇ ਲਿੰਕ ਜੁੜੇ ਹੋਏ ਹਨ। ਸ਼ਾਇਦ ਉਪਰੋਕਤ ਕਿਸੇ ਨੂੰ ਆਪਣੇ ਟੀਚਿਆਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰੇਗਾ. ਵਰਜਨ 6 ਅਜੇ ਸਾਡੇ ਨੈਟਵਰਕ ਤੇ ਲਾਗੂ ਨਹੀਂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ - ਪਰ ਇੱਕ ਸਮੱਸਿਆ ਹੋਵੇਗੀ - ਸੰਸਕਰਣ 6 ਲਈ lisg ਨੂੰ ਮੁੜ ਲਿਖਣ ਦੀ ਯੋਜਨਾ ਹੈ, ਅਤੇ ਰੂਟ ਜੋੜਨ ਵਾਲੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਠੀਕ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੋਵੇਗਾ।

ਲੀਨਕਸ ISG
DB2DHCP
ਲਿਬਟਿਨਸ

ਸਰੋਤ: www.habr.com