ಸುಧಾರಿತ ಪರಿಕರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ದೋಷ-ಸಹಿಷ್ಣು ಐಪಿಇ ನೆಟ್‌ವರ್ಕ್

ನಮಸ್ಕಾರ. ಇದರರ್ಥ 5k ಕ್ಲೈಂಟ್‌ಗಳ ನೆಟ್‌ವರ್ಕ್ ಇದೆ. ಇತ್ತೀಚೆಗೆ ತುಂಬಾ ಆಹ್ಲಾದಕರವಲ್ಲದ ಕ್ಷಣ ಬಂದಿತು - ನೆಟ್‌ವರ್ಕ್‌ನ ಮಧ್ಯದಲ್ಲಿ ನಾವು ಬ್ರೋಕೇಡ್ ಆರ್‌ಎಕ್ಸ್ 8 ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ ಮತ್ತು ಇದು ಬಹಳಷ್ಟು ಅಜ್ಞಾತ-ಯುನಿಕಾಸ್ಟ್ ಪ್ಯಾಕೆಟ್‌ಗಳನ್ನು ಕಳುಹಿಸಲು ಪ್ರಾರಂಭಿಸಿತು, ಏಕೆಂದರೆ ನೆಟ್‌ವರ್ಕ್ ಅನ್ನು ವಿಲಾನ್‌ಗಳಾಗಿ ವಿಂಗಡಿಸಲಾಗಿದೆ - ಇದು ಭಾಗಶಃ ಸಮಸ್ಯೆಯಲ್ಲ, ಆದರೆ ಇವೆ ಬಿಳಿ ವಿಳಾಸಗಳಿಗಾಗಿ ವಿಶೇಷ vlans, ಇತ್ಯಾದಿ. ಮತ್ತು ಅವರು ನೆಟ್ವರ್ಕ್ನ ಎಲ್ಲಾ ದಿಕ್ಕುಗಳಲ್ಲಿಯೂ ವಿಸ್ತರಿಸುತ್ತಾರೆ. ಆದ್ದರಿಂದ ಈಗ ಗಡಿ ವಿದ್ಯಾರ್ಥಿಯಾಗಿ ಅಧ್ಯಯನ ಮಾಡದ ಕ್ಲೈಂಟ್‌ನ ವಿಳಾಸಕ್ಕೆ ಒಳಬರುವ ಹರಿವನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ ಮತ್ತು ಈ ಹರಿವು ಕೆಲವು (ಅಥವಾ ಎಲ್ಲಾ) ಹಳ್ಳಿಗಳಿಗೆ ರೇಡಿಯೊ ಲಿಂಕ್‌ನ ಕಡೆಗೆ ಹಾರುತ್ತದೆ - ಚಾನಲ್ ಮುಚ್ಚಿಹೋಗಿದೆ - ಗ್ರಾಹಕರು ಕೋಪಗೊಂಡಿದ್ದಾರೆ - ದುಃಖ ...

ದೋಷವನ್ನು ವೈಶಿಷ್ಟ್ಯವಾಗಿ ಪರಿವರ್ತಿಸುವುದು ಗುರಿಯಾಗಿದೆ. ನಾನು ಪೂರ್ಣ-ಪ್ರಮಾಣದ ಕ್ಲೈಂಟ್ vlan ಜೊತೆಗೆ q-in-q ದಿಕ್ಕಿನಲ್ಲಿ ಯೋಚಿಸುತ್ತಿದ್ದೆ, ಆದರೆ P3310 ನಂತಹ ಎಲ್ಲಾ ರೀತಿಯ ಹಾರ್ಡ್‌ವೇರ್, dot1q ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿದಾಗ, DHCP ಅನ್ನು ಬಿಡುವುದನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ, ಅವರಿಗೆ qinq ಮತ್ತು ಹಲವು ಆಯ್ಕೆ ಮಾಡುವುದು ಹೇಗೆ ಎಂದು ತಿಳಿದಿಲ್ಲ. ಅಂತಹ ಅಪಾಯಗಳು. ಐಪಿ-ಅನ್‌ನಾಮಂಬರ್ಡ್ ಎಂದರೇನು ಮತ್ತು ಅದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ? ಬಹಳ ಸಂಕ್ಷಿಪ್ತವಾಗಿ: ಗೇಟ್‌ವೇ ವಿಳಾಸ + ಇಂಟರ್ಫೇಸ್‌ನಲ್ಲಿ ಮಾರ್ಗ. ನಮ್ಮ ಕಾರ್ಯಕ್ಕಾಗಿ, ನಮಗೆ ಅಗತ್ಯವಿದೆ: ಶೇಪರ್ ಅನ್ನು ಕತ್ತರಿಸಿ, ಗ್ರಾಹಕರಿಗೆ ವಿಳಾಸಗಳನ್ನು ವಿತರಿಸಿ, ಕೆಲವು ಇಂಟರ್ಫೇಸ್‌ಗಳ ಮೂಲಕ ಕ್ಲೈಂಟ್‌ಗಳಿಗೆ ಮಾರ್ಗಗಳನ್ನು ಸೇರಿಸಿ. ಇದೆಲ್ಲವನ್ನೂ ಮಾಡುವುದು ಹೇಗೆ? Shaper - lisg, dhcp - db2dhcp ಎರಡು ಸ್ವತಂತ್ರ ಸರ್ವರ್‌ಗಳಲ್ಲಿ, dhcprelay ಪ್ರವೇಶ ಸರ್ವರ್‌ಗಳಲ್ಲಿ ರನ್ ಆಗುತ್ತದೆ, ucarp ಸಹ ಪ್ರವೇಶ ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಚಲಿಸುತ್ತದೆ - ಬ್ಯಾಕಪ್‌ಗಾಗಿ. ಆದರೆ ಮಾರ್ಗಗಳನ್ನು ಹೇಗೆ ಸೇರಿಸುವುದು? ದೊಡ್ಡ ಸ್ಕ್ರಿಪ್ಟ್‌ನೊಂದಿಗೆ ನೀವು ಎಲ್ಲವನ್ನೂ ಮುಂಚಿತವಾಗಿ ಸೇರಿಸಬಹುದು - ಆದರೆ ಇದು ನಿಜವಲ್ಲ. ಆದ್ದರಿಂದ ನಾವು ಸ್ವಯಂ ಬರೆದ ಊರುಗೋಲನ್ನು ತಯಾರಿಸುತ್ತೇವೆ.

ಇಂಟರ್ನೆಟ್‌ನಲ್ಲಿ ಸಂಪೂರ್ಣ ಹುಡುಕಾಟದ ನಂತರ, ನಾನು C++ ಗಾಗಿ ಅದ್ಭುತವಾದ ಉನ್ನತ ಮಟ್ಟದ ಲೈಬ್ರರಿಯನ್ನು ಕಂಡುಕೊಂಡಿದ್ದೇನೆ, ಇದು ಟ್ರಾಫಿಕ್ ಅನ್ನು ಸುಂದರವಾಗಿ ಸ್ನಿಫ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಮಾರ್ಗಗಳನ್ನು ಸೇರಿಸುವ ಪ್ರೋಗ್ರಾಂಗೆ ಅಲ್ಗಾರಿದಮ್ ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ - ನಾವು ಇಂಟರ್ಫೇಸ್ನಲ್ಲಿ arp ವಿನಂತಿಗಳನ್ನು ಕೇಳುತ್ತೇವೆ, ವಿನಂತಿಸಿದ ಸರ್ವರ್ನಲ್ಲಿ lo ಇಂಟರ್ಫೇಸ್ನಲ್ಲಿ ನಾವು ವಿಳಾಸವನ್ನು ಹೊಂದಿದ್ದರೆ, ನಂತರ ನಾವು ಈ ಇಂಟರ್ಫೇಸ್ ಮೂಲಕ ಮಾರ್ಗವನ್ನು ಸೇರಿಸುತ್ತೇವೆ ಮತ್ತು ಸ್ಥಿರ ಆರ್ಪ್ ಅನ್ನು ಸೇರಿಸುತ್ತೇವೆ ಈ ಐಪಿಗೆ ರೆಕಾರ್ಡ್ ಮಾಡಿ - ಸಾಮಾನ್ಯವಾಗಿ, ಕೆಲವು ಕಾಪಿ-ಪೇಸ್ಟ್‌ಗಳು, ಸ್ವಲ್ಪ ವಿಶೇಷಣ ಮತ್ತು ನೀವು ಮುಗಿಸಿದ್ದೀರಿ

'ರೂಟರ್' ಮೂಲಗಳು

#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 ಗೆ ನಿಯೋಜಿಸಿದ್ದೇವೆ.

ಬಿಜಿಪಿ ಸಂರಚನೆಅತಿಥೇಯ ಹೆಸರು *******
ಗುಪ್ತಪದ *******
ಲಾಗ್ ಫೈಲ್ /var/log/bgp.log
!
# AS ಸಂಖ್ಯೆ, ವಿಳಾಸಗಳು ಮತ್ತು ನೆಟ್‌ವರ್ಕ್‌ಗಳು ಕಾಲ್ಪನಿಕ
ರೂಟರ್ ಬಿಜಿಪಿ 12345
ಬಿಜಿಪಿ ರೂಟರ್-ಐಡಿ 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

ಕೆಳಗೆ.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. ಇದು ಕನಿಷ್ಟ ಸೆಟ್ ಆಗಿದೆ - ಲಿಸ್ಗ್ ಅದರ ಸುತ್ತಲೂ ಎಲ್ಲವನ್ನೂ ಸುತ್ತುತ್ತದೆ ಮತ್ತು ನಾವು ಈಗಾಗಲೇ ಶೇಪರ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಎಲ್ಲವೂ ಏಕೆ ತುಂಬಾ ಉದ್ದವಾಗಿದೆ ಮತ್ತು ಗೊಂದಲಮಯವಾಗಿದೆ? accel-pppd ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದು ಮತ್ತು pppoe ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಬಳಸುವುದು ಸುಲಭವಲ್ಲವೇ? ಇಲ್ಲ, ಇದು ಸರಳವಲ್ಲ - ಜನರು ಪ್ಯಾಚ್‌ಕಾರ್ಡ್ ಅನ್ನು ರೂಟರ್‌ಗೆ ಹೊಂದಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ, pppoe ಅನ್ನು ನಮೂದಿಸಬಾರದು. accel-ppp ಒಂದು ತಂಪಾದ ವಿಷಯ - ಆದರೆ ಅದು ನಮಗೆ ಕೆಲಸ ಮಾಡಲಿಲ್ಲ - ಕೋಡ್‌ನಲ್ಲಿ ಬಹಳಷ್ಟು ದೋಷಗಳಿವೆ - ಅದು ಕುಸಿಯುತ್ತದೆ, ಅದು ವಕ್ರವಾಗಿ ಕತ್ತರಿಸುತ್ತದೆ, ಮತ್ತು ದುಃಖದ ವಿಷಯವೆಂದರೆ ಅದು ಪ್ರಕಾಶಮಾನವಾಗಿದ್ದರೆ - ನಂತರ ಜನರು ಮರುಲೋಡ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ ಎಲ್ಲವೂ - ಫೋನ್‌ಗಳು ಕೆಂಪು ಬಣ್ಣದ್ದಾಗಿವೆ - ಅದು ಕೆಲಸ ಮಾಡಲಿಲ್ಲ. ಕೀಪ್‌ಅಲೈವ್‌ಗಿಂತ ಯುಕಾರ್ಪ್ ಅನ್ನು ಬಳಸುವುದರಿಂದ ಏನು ಪ್ರಯೋಜನ? ಹೌದು, ಎಲ್ಲದರಲ್ಲೂ - 100 ಗೇಟ್‌ವೇಗಳಿವೆ, ಕೀಪಲೈವ್ಡ್ ಮತ್ತು ಕಾನ್ಫಿಗರ್‌ನಲ್ಲಿ ಒಂದು ದೋಷವಿದೆ - ಎಲ್ಲವೂ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ. 1 ಗೇಟ್‌ವೇ ಯುಕಾರ್ಪ್‌ನೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ. ಭದ್ರತೆಗೆ ಸಂಬಂಧಿಸಿದಂತೆ, ಎಡಭಾಗದವರು ತಮಗಾಗಿ ವಿಳಾಸಗಳನ್ನು ನೋಂದಾಯಿಸಿಕೊಳ್ಳುತ್ತಾರೆ ಮತ್ತು ಅವುಗಳನ್ನು ಹಂಚಿಕೆಯಲ್ಲಿ ಬಳಸುತ್ತಾರೆ ಎಂದು ಅವರು ಹೇಳುತ್ತಾರೆ - ಈ ಕ್ಷಣವನ್ನು ನಿಯಂತ್ರಿಸಲು, ನಾವು ಎಲ್ಲಾ ಸ್ವಿಚ್‌ಗಳು/ಓಲ್ಟ್‌ಗಳು/ಬೇಸ್‌ಗಳಲ್ಲಿ dhcp-snooping + source-guard + arp ತಪಾಸಣೆಯನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ. ಕ್ಲೈಂಟ್ dhpc ಹೊಂದಿಲ್ಲ ಆದರೆ ಸ್ಥಿರ - ಪೋರ್ಟ್‌ನಲ್ಲಿ ಪ್ರವೇಶ-ಪಟ್ಟಿ.

ಇದನ್ನೆಲ್ಲಾ ಏಕೆ ಮಾಡಲಾಯಿತು? ಅನಗತ್ಯ ಸಂಚಾರವನ್ನು ನಾಶಮಾಡಲು. ಈಗ ಪ್ರತಿಯೊಂದು ಸ್ವಿಚ್ ತನ್ನದೇ ಆದ vlan ಅನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ಅಜ್ಞಾತ-ಯುನಿಕಾಸ್ಟ್ ಇನ್ನು ಮುಂದೆ ಭಯಾನಕವಲ್ಲ, ಏಕೆಂದರೆ ಇದು ಕೇವಲ ಒಂದು ಪೋರ್ಟ್‌ಗೆ ಮಾತ್ರ ಹೋಗಬೇಕಾಗುತ್ತದೆ ಮತ್ತು ಎಲ್ಲರಿಗೂ ಅಲ್ಲ... ಅಲ್ಲದೆ, ಅಡ್ಡಪರಿಣಾಮಗಳು ಪ್ರಮಾಣಿತ ಸಾಧನ ಸಂರಚನೆಯಾಗಿದೆ, ವಿಳಾಸ ಜಾಗವನ್ನು ನಿಯೋಜಿಸುವಲ್ಲಿ ಹೆಚ್ಚಿನ ದಕ್ಷತೆ.

ಲಿಸ್ಗ್ ಅನ್ನು ಹೇಗೆ ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು ಪ್ರತ್ಯೇಕ ವಿಷಯವಾಗಿದೆ. ಗ್ರಂಥಾಲಯಗಳಿಗೆ ಲಿಂಕ್‌ಗಳನ್ನು ಲಗತ್ತಿಸಲಾಗಿದೆ. ಬಹುಶಃ ಮೇಲಿನವು ಯಾರಿಗಾದರೂ ತಮ್ಮ ಗುರಿಗಳನ್ನು ಸಾಧಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ನಮ್ಮ ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿ ಆವೃತ್ತಿ 6 ಅನ್ನು ಇನ್ನೂ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿಲ್ಲ - ಆದರೆ ಸಮಸ್ಯೆ ಇರುತ್ತದೆ - ಆವೃತ್ತಿ 6 ಗಾಗಿ ಪಟ್ಟಿಯನ್ನು ಪುನಃ ಬರೆಯುವ ಯೋಜನೆಗಳಿವೆ ಮತ್ತು ಮಾರ್ಗಗಳನ್ನು ಸೇರಿಸುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ನಾವು ಸರಿಪಡಿಸಬೇಕಾಗಿದೆ.

Linux ISG
DB2DHCP
ಲಿಬ್ಟಿನ್ಸ್

ಮೂಲ: www.habr.com