गल्ती-सहिष्णु आईपीईई नेटवर्क सुधार उपकरणहरू प्रयोग गरेर

नमस्ते। यसको मतलब त्यहाँ 5k ग्राहकहरूको नेटवर्क छ। भर्खरै एक धेरै रमाइलो क्षण आयो - नेटवर्कको बीचमा हामीसँग ब्रोकेड RX8 छ र यसले धेरै अज्ञात-युनिकास्ट प्याकेटहरू पठाउन थाल्यो, किनकि नेटवर्क भ्लान्समा विभाजित छ - यो आंशिक रूपमा समस्या होइन, तर त्यहाँ छन्। सेतो ठेगानाहरूका लागि विशेष vlans, आदि। र तिनीहरू नेटवर्कको सबै दिशाहरूमा फैलिएका छन्। त्यसोभए अब सीमावर्ती विद्यार्थीको रूपमा अध्ययन नगर्ने ग्राहकको ठेगानामा आगमन प्रवाहको कल्पना गर्नुहोस् र यो प्रवाह कुनै (वा सबै) गाउँको रेडियो लिङ्कतिर उड्छ - च्यानल अवरुद्ध छ - ग्राहकहरू रिसाउँछन् - उदासी ...

लक्ष्य भनेको बगलाई सुविधामा परिणत गर्नु हो। म पूर्ण ग्राहक भलानसँग q-in-q को दिशामा सोचिरहेको थिएँ, तर P3310 जस्ता सबै प्रकारका हार्डवेयरहरू, जब dot1q सक्षम हुन्छ, DHCP लाई अनुमति दिन रोक्छ, उनीहरूलाई पनि थाहा छैन कि कसरी चयन गर्ने qinq र धेरै। त्यस प्रकारका गल्तीहरू। ip-unnambered के हो र यसले कसरी काम गर्छ? धेरै छोटकरीमा: गेटवे ठेगाना + इन्टरफेसमा मार्ग। हाम्रो कार्यको लागि, हामीले आवश्यक छ: आकार काट्नुहोस्, ग्राहकहरूलाई ठेगानाहरू वितरण गर्नुहोस्, निश्चित इन्टरफेसहरू मार्फत ग्राहकहरूलाई मार्गहरू थप्नुहोस्। यो सब कसरी गर्ने ? Shaper - lisg, dhcp - db2dhcp दुई स्वतन्त्र सर्भरहरूमा, dhcprelay पहुँच सर्भरहरूमा चल्छ, ucarp पनि पहुँच सर्भरहरूमा चल्छ - ब्याकअपको लागि। तर मार्गहरू कसरी थप्ने? तपाईले ठूलो लिपिको साथ सबै कुरा पहिले नै थप्न सक्नुहुन्छ - तर यो सत्य होइन। त्यसैले हामी एक स्व-लिखित बैसाखी बनाउनेछौं।

इन्टरनेटमा गहिरो खोज पछि, मैले C++ को लागि एक अद्भुत उच्च-स्तरको पुस्तकालय फेला पारे, जसले तपाईंलाई ट्राफिकलाई राम्ररी सुँघ्न अनुमति दिन्छ। रूटहरू थप्ने कार्यक्रमको लागि एल्गोरिथ्म निम्नानुसार छ - हामी इन्टरफेसमा एआरपी अनुरोधहरू सुन्छौं, यदि हामीसँग अनुरोध गरिएको सर्भरमा लो इन्टरफेसमा ठेगाना छ भने, हामी यस इन्टरफेस मार्फत मार्ग थप्छौं र स्थिर एआरपी थप्छौं। यो ip मा रेकर्ड गर्नुहोस् - सामान्यतया, केहि प्रतिलिपि-पेस्ट, एक सानो विशेषण र तपाइँ सकियो

'राउटर' को स्रोतहरू

#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 राउटर-आईडी २.२.२.२
जोडिएको पुन: वितरण
स्थिर पुन: वितरण
छिमेकी 1.2.3.1 remote-as 12345
छिमेकी 1.2.3.1 next-hop-self
छिमेकी 1.2.3.1 मार्ग-नक्सा कुनै पनि छैन
छिमेकी 1.2.3.1 मार्ग-नक्सा बाहिर निर्यात
!
पहुँच-सूची निर्यात अनुमति १.२.३.०/२४
!
मार्ग-नक्सा निर्यात अनुमति 10
आईपी ​​ठेगाना निर्यात मिलाउनुहोस्
!
मार्ग-नक्सा निर्यात अस्वीकार २०

जारी राखौं। सर्भरले एआरपी अनुरोधहरूको जवाफ दिनको लागि, तपाईंले एआरपी प्रोक्सी सक्षम गर्नुपर्छ।

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 ले यसको वरिपरि सबै कुरा लपेट्छ र हामीसँग पहिले नै आकार छ। किन सबै कुरा यति लामो र जटिल छ? accel-pppd लिन र pppoe पूरै प्रयोग गर्न सजिलो छैन? होइन, यो सजिलो छैन - मानिसहरूले प्याचकोर्डलाई राउटरमा फिट गर्न सक्दैनन्, pppoe उल्लेख नगर्न। accel-ppp एउटा राम्रो कुरा हो - तर यसले हाम्रो लागि काम गरेन - कोडमा धेरै त्रुटिहरू छन् - यो टुक्रा टुक्रा हुन्छ, यसले बाङ्गो काट्छ, र सबैभन्दा दुखद कुरा यो हो कि यदि यो उज्यालो भयो - तब मानिसहरूले पुन: लोड गर्न आवश्यक छ। सबै कुरा - फोनहरू रातो छन् - यसले काम गरेन। Keepalived भन्दा Ucarp प्रयोग गरेर के फाइदा छ? हो, सबै कुरामा - त्यहाँ 100 गेटवेहरू छन्, Keepalived र कन्फिगरेसनमा एउटा त्रुटि - सबै कुराले काम गर्दैन। 1 गेटवे ucarp संग काम गर्दैन। सुरक्षाको सन्दर्भमा, तिनीहरू भन्छन् कि बायाँ व्यक्तिहरूले आफ्नो लागि ठेगानाहरू दर्ता गर्नेछन् र तिनीहरूलाई साझेदारीमा प्रयोग गर्नेछन् - यो क्षणलाई नियन्त्रण गर्न, हामीले सबै स्विचहरू/olts/बेसहरूमा dhcp-snooping + source-guard + arp निरीक्षण सेट अप गर्छौं। यदि ग्राहकसँग dhpc छैन तर स्थिर - पोर्टमा पहुँच सूची।

यो सब किन गरियो ? अनावश्यक यातायात नष्ट गर्न। अब प्रत्येक स्विचको आफ्नै भ्लान छ र अज्ञात-युनिकास्ट अब डरलाग्दो छैन, किनकि यसले केवल एउटा पोर्टमा जानु पर्छ र सबैमा होइन... ठीक छ, साइड इफेक्टहरू मानकीकृत उपकरण कन्फिगरेसन हुन्, ठेगाना ठाउँ बाँडफाँडमा बढी दक्षता।

lisg कसरी कन्फिगर गर्ने एक अलग विषय हो। पुस्तकालयहरूको लिङ्कहरू संलग्न छन्। सायद माथिको कुराले कसैलाई आफ्नो लक्ष्य हासिल गर्न मद्दत गर्नेछ। संस्करण 6 अझै हाम्रो नेटवर्कमा लागू गरिएको छैन - तर त्यहाँ समस्या हुनेछ - त्यहाँ संस्करण 6 को लागि lisg पुन: लेख्ने योजनाहरू छन्, र यो मार्गहरू थप्ने कार्यक्रमलाई सच्याउन आवश्यक हुनेछ।

लिनक्स ISG
DB2DHCP
लिब्टिन्स

स्रोत: www.habr.com