abclinuxu.cz AbcLinuxu.cz itbiz.cz ITBiz.cz HDmag.cz HDmag.cz abcprace.cz AbcPráce.cz
AbcLinuxu hledá autory!
Inzerujte na AbcPráce.cz od 950 Kč
Rozšířené hledání
×
dnes 17:00 | Nová verze

Byl vydán Docker 1.13. Přehled novinek na YouTube a v poznámkách k vydání na GitHubu. Docker umožňuje běh aplikací v softwarových kontejnerech (Wikipedia).

Ladislav Hagara | Komentářů: 0
dnes 15:51 | Komunita

Mozilla.cz informuje, že nástroje pro webové vývojáře se možná oddělí od Firefoxu a stanou doplňkem. Nástroje pro webové vývojáře prošly velkým přepisem a tým, který se stará o jejich vývoj, by uvítal možnost jejich častějších aktualizacích nezávisle na vydávání nových verzí Firefoxu.

Ladislav Hagara | Komentářů: 1
dnes 07:00 | Humor

Čtenářům AbcLinuxu vše nejlepší k dnešnímu Dni zvýšení povědomí o tučňácích (Penguin Awareness Day).

Ladislav Hagara | Komentářů: 0
dnes 06:00 | Komunita

Bylo spuštěno hlasování o přednáškách a workshopech pro letošní InstallFest, jenž proběhne o víkendu 4. a 5. března v Praze. Současně byla oznámena změna místa. InstallFest se letos vrací zpět na Karlovo náměstí do budovy E.

Ladislav Hagara | Komentářů: 0
dnes 02:48 | Komunita

Greg Kroah-Hartman potvrdil, že Linux 4.9 je jádrem s prodlouženou upstream podporou (LTS, Long Term Support). Podpora je plánována do ledna 2019. Aktuální jádra s prodlouženou podporou jsou tedy 3.2, 3.4, 3.10, 3.12, 3.16, 3.18, 4.1, 4.4 a 4.9.

Ladislav Hagara | Komentářů: 0
dnes 00:11 | Zajímavý článek

Výrobce síťových prvků, společnost Netgear, spustila nový program, který slibuje vývojářům, expertům, ale i běžným uživatelům vyplacení finanční odměny za nalezení bezpečnostních chyby v jejich produktech. Za nalezení zranitelnosti v hardware, API nebo mobilní aplikaci nabízí odměnu od 150 do 15 tisíc dolarů (dle závažnosti).

Michal Makovec | Komentářů: 0
dnes 00:08 | Pozvánky

V sobotu 18. 2. se v Praze v prostorách VŠE uskuteční od 9:30 již 4. ročník největší české konference o open source redakčním systému WordPress (WP) - WordCamp Praha 2017.

… více »
smíťa | Komentářů: 0
včera 23:58 | Komunita

Kryptoměnová komunita zahájila nový rok spuštěním projektu Blockchain.cz, jehož cílem je kolektivně nalézt ideální překlad pro čím dál frekventovanější slovo „blockchain“. Přispět návrhem může kdokoli. Sběr bude trvat až do konce září 2017. Následně bude probíhat dvoutýdenní veřejné hlasování, které bude zakončeno výběrem toho nejlepšího návrhu.

xHire | Komentářů: 8
včera 15:55 | Bezpečnostní upozornění

Společnost Oracle vydala čtvrtletní bezpečnostní aktualizaci svých softwarových produktů (CPU, Critical Patch Update). Opraveno je celkově 270 bezpečnostních chyb. V Oracle Java SE je například opraveno 17 bezpečnostních chyb. Vzdáleně zneužitelných bez autentizace je 16 z nich. V Oracle MySQL je opraveno 27 bezpečnostních chyb. Vzdáleně zneužitelných bez autentizace je 5 z nich.

Ladislav Hagara | Komentářů: 0
včera 02:48 | Nová verze

Po půl roce od vydání verze 9.0 (zprávička) byla vydána verze 10.0 zvukového serveru PulseAudio. Přehled novinek v poznámkách k vydání.

Ladislav Hagara | Komentářů: 31
Jak se stavíte k trendu ztenčování přenosných zařízení (smartphony, notebooky)?
 (10%)
 (2%)
 (74%)
 (3%)
 (10%)
Celkem 339 hlasů
 Komentářů: 24, poslední 17.1. 10:14
    Rozcestník
    Reklama

    Dotaz: Něco rychlejšího než cat?

    Thunder.m avatar 3.11.2006 10:01 Thunder.m | skóre: 35 | blog: e17
    Něco rychlejšího než cat?
    Přečteno: 230×
    Stavím skript, který bude spracovávat velké množství ip adres, momentálně pro rozdělení jednotlivých částí ip adresy používám příkaz
    "`echo $IP | cut -d. -f1`"
    ten je ale relativně pomalý a tak bych se chtěl zeptat jestli neexistuje něco rychlejšího než tento postup?

    Zkoušel jsem samozřejmě awk, který je o cca 20% pomalejší než cat.

    Odpovědi

    Thunder.m avatar 3.11.2006 10:06 Thunder.m | skóre: 35 | blog: e17
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    Na každý cyklus používám 5 takovýchto příkazů, pokud je tam nemam (stále se jedná o relativně dost výpočtů), tak celková doba zpracování klesne na 1/20.
    3.11.2006 10:16 žabža
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    Použít bash a takové ty jeho expanze se suffixama a prefixama, co si u nich nikdy nepamatuju syntax?
    3.11.2006 13:18 Aleš Kapica | skóre: 45 | blog: kenyho_stesky | Ostrava
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    Nebylo by to rychlejší takhle?
    user@stroj:~$ ip=($(echo "127.0.0.1" | tr '.' ' '))
    user@stroj:~$ echo "${ip[0]} : ${ip[1]} :  ${ip[2]} : ${ip[3]}"
    127 : 0 :  0 : 1
    
    David Watzke avatar 3.11.2006 13:40 David Watzke | skóre: 74 | blog: Blog... | Praha
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    Nebo takhle
    ip=($(tr '.' ' ' <<< "127.0.0.1"))
    echo "${ip[0]} : ${ip[1]} :  ${ip[2]} : ${ip[3]}"
    
    :-) echo je sice builtin, ale stejně je pomalejší než tohle :-D
    “Being honest may not get you a lot of friends but it’ll always get you the right ones” ―John Lennon
    Thunder.m avatar 3.11.2006 15:47 Thunder.m | skóre: 35 | blog: e17
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    Díky, to přineslo rozumné zrychlení.
    3.11.2006 10:22 cronin | skóre: 48
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    cut ako taky v tomto pripade netrva dlho, dlho trva jeho spustanie. Pre kazde pouzitie sa spusti novy proces. Nedaju sa tie IP adresy spracovat nejako hromadne?
    Thunder.m avatar 3.11.2006 15:55 Thunder.m | skóre: 35 | blog: e17
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    No nejsem zrovna programátor :) Snažím se vytvořit univerzální generátor pravidel pro iptables, tak aby byly ve stromu a tak nedocházelo ke zpomalování ani při obrovském množství pravidel. Je tu víc problémů nad kterými se zamýšlím a které musím řešit.
    3.11.2006 11:42 Ladislav Sückr | skóre: 21
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?

    Šlo by to zproduktivnit tak, že si ty IP adresy uložíš do souboru a pak je jedním spuštěním cut "rozsekáš". Nástin řešení by mohl např. být:

    #!/bin/sh
    
    # vytvoreni souboru s IP adresama
    for ip in 192.168.1.1 192.168.1.2 192.168.1.3 192.168.1.4
    do
        echo $ip >> ip.txt
    done
    
    # vybrani pozadovane casti IP
    cut -d . -f 1 ip.txt
    
    Myslet špatně je lepší než nemyslet vůbec.
    3.11.2006 14:14 happy barney | skóre: 34 | blog: dont_worry_be_happy
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    for ip in 192.168.1.1 192.168.1.2 192.168.1.3 192.168.1.4
    do
        echo $ip
    done | cut -d . -f 1
    
    3.11.2006 14:18 thingie
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    Jestli záleží na rychlosti, je vhodné si položit otázku, proč to vlastně píšeš v bashi.
    3.11.2006 15:22 retkarach
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    co tak pouzit IFS ? nieco v style: oldIFS=$IFS; IFS="."
    Thunder.m avatar 3.11.2006 15:57 Thunder.m | skóre: 35 | blog: e17
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    Přikládám jak takový skript vypadá, jeden cyklus while je tam na test rychlosti.
    #! /bin/bash
    
    DEV="eth0"
    FILE="/test_2"
    CHAIN_TYPE="post" # pre/post/fwd
    
    M1=""
    M2=""
    M3=""
    M4=""
    IP1=""
    IP2=""
    IP3=""
    IP4=""
    BC=""
    BCN=""
    
    
    rm -rf "$FILE"
    
    
    convert_net_to_mask() {
    
        if let $(( (32-$1) > 0)); then
            M4=$(( (255 << (32-$1)) & 255))
        else
            M4=255
        fi
        if let $(( (24-$1) > 0)); then
            M3=$(( (255 << (24-$1)) & 255))
        else
            M3=255
        fi
        if let $(( (16-$1) > 0)); then
            M2=$(( (255 << (16-$1)) & 255))
        else
            M2=255
        fi
        if let $(( (8-$1) > 0)); then
            M1=$(( (255 << (8-$1)) & 255))
        else
            M1=255
        fi
    
    }
    
    convert_ip_to_network() {
    
        IP=($(tr '/' ' ' <<< "$1"))
        BC=${IP[1]}
        IP=($(tr '.' ' ' <<< "${IP[0]}"))
        BCN="$(($BC - 1))"
    
        convert_net_to_mask "$BCN"
    
        IP="$((${IP[0]} & $M1)).$((${IP[1]} & $M2)).$((${IP[2]} & $M3)).$((${IP[3]} & $M4))/$BCN"
    }
    
    
    A="0"
    while [ $A -lt 40 ]; do
    
    IP="10.93.49.194/32"
    IPR="10.93.0.0/16"
    
    chain="chain_${CHAIN_TYPE}_`echo $IPR | cut -d. -f1``echo $IPR | cut -d. -f2``echo $IPR | cut -d. -f3``echo $IPR | cut -d. -f4 | cut -d/ -f1`_`echo $IPR | cut -d/ -f2`"
    
    echo IPTABLES=\"iptables\" > "$FILE"
    
    if [ "`iptables -t nat -L -n | grep \"$chain\" | grep \"$IPR\"`" == "" ]; then
        echo \$IPTABLES -t nat -N "$chain" >> "$FILE"
        if [ "$CHAIN_TYPE" == "post" ]; then
            echo \$IPTABLES -t nat -A POSTROUTING -o $DEV -s $IPR -j "$chain" >> "$FILE"
        elif [ "$CHAIN_TYPE" == "pre" ]; then
            echo \$IPTABLES -t nat -A PREROUTING -i $DEV -d $IPR -j "$chain" >> "$FILE"
        elif [ "$CHAIN_TYPE" == "fwd" ]; then
            echo \$IPTABLES -A FORWARD -i $DEV -d $IPR -j "$chain" >> "$FILE"
        fi
    fi
    
    I="0"
    J="$((`echo $IP | cut -d/ -f2` - `echo $IPR | cut -d/ -f2` ))"
    while [ $I -lt $J ]; do
        convert_ip_to_network "$IP"
        CHAIN="chain_${CHAIN_TYPE}_${IP[0]}${IP[1]}${IP[2]}${IP[3]}_$BC"
        if [ "`iptables -t nat -L -n | grep \"$CHAIN\"`" == "" ]; then
            echo \$IPTABLES -t nat -N "$CHAIN" >> "$FILE"
        fi
        IPS="${IP[0]}.${IP[1]}.${IP[2]}.${IP[2]}/$BC1 $IPS"
        CHAINS="$CHAIN $CHAINS"
        I="$(($I + 1))"
    done
    
    CHAINS="$chain $CHAINS"
    
    I="1"
    for IP in $IPS; do
        CHAIND="`echo $CHAINS | cut -d \" \" -f $(($I + 1))`"
        if [ "`iptables -t nat -L -n | grep \"$CHAIND\"`" == "" ]; then
            echo \$IPTABLES -t nat -A "`echo $CHAINS | cut -d \" \" -f $I`" -s $IP -j "$CHAIND" >> "$FILE"
        fi
        I="$(($I + 1))"
    done
    
    A="$(($A + 1))"
    done
    
    
    David Watzke avatar 3.11.2006 16:01 David Watzke | skóre: 74 | blog: Blog... | Praha
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    1. Když už jde o rychlost, používej místo [ a ] raději [[ a ]] (první je builtin, druhé keyword).
    2. Lepší než krkolomné A="$(($A + 1))" je kupříkladu ((A++)).
    “Being honest may not get you a lot of friends but it’ll always get you the right ones” ―John Lennon
    Thunder.m avatar 3.11.2006 16:47 Thunder.m | skóre: 35 | blog: e17
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    Můžeš mi jen trochu víc rozvést první bod? Nějak jsem to nepochopil, třeba nějaký příklad :)
    David Watzke avatar 3.11.2006 16:55 David Watzke | skóre: 74 | blog: Blog... | Praha
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    Builtin je vestavěný příkaz (to je právě ten '[') a keyword je klíčové slovo (to je zase '[['). Keyword je rychlejší:
    $ time for((i=0;i<99999;i++)); do [ "" ]; done
    
    real    0m1.493s
    user    0m1.402s
    sys     0m0.061s
    
    $ time for((i=0;i<99999;i++)); do [[ "" ]]; done
    
    real    0m1.096s
    user    0m1.054s
    sys     0m0.025s
    “Being honest may not get you a lot of friends but it’ll always get you the right ones” ―John Lennon
    David Watzke avatar 3.11.2006 16:57 David Watzke | skóre: 74 | blog: Blog... | Praha
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    Jo a jinak fungují docela stejně, snad až na tohle:
    $ [ ]
    $ [[ ]]
    bash: syntax error near `]]'
    “Being honest may not get you a lot of friends but it’ll always get you the right ones” ―John Lennon
    David Watzke avatar 3.11.2006 16:05 David Watzke | skóre: 74 | blog: Blog... | Praha
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    1. $(tohle je lepší) než zastaralé `toto` ;-)
    2. [[ -z "něco" ]] je (trochu) rychlejší, než [[ "něco" == "" ]]
    “Being honest may not get you a lot of friends but it’ll always get you the right ones” ―John Lennon
    Thunder.m avatar 4.11.2006 13:28 Thunder.m | skóre: 35 | blog: e17
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    Tak jsem dosáhnul relativně uspokojivé doby lepší než 1 vteřina pro jeden záznam, ale problém je v tom že při průchodu v cyklu while se to postupně zpomaluje a nakonci to už je třeba 4 vteřiny (po průchodu cca 100 adres), nevíte kde by mohl být problém?
    Thunder.m avatar 4.11.2006 13:39 Thunder.m | skóre: 35 | blog: e17
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    Ještě popíšu postup jak to dělám. Účel je ten že se pro iptables vygeneruje strom, který je daleko vhodnější pro obrovský počet pravidel. Plánujeme mít cca 2000 adres v konfiguračním souboru.

    Mam 3 soubory:

    první soubor obsahuje jednoduchý cyklus:
    while read A B C; do
       /tree.sh $A $B $C
    done < config.cfg
    
    druhý soubor je hlavní:
    #! /bin/sh
    # Vytvoreno 31.10.2006
    
    # definujeme cesty v systemu
    PATH="/usr/sbin:/usr/bin:/sbin:/bin"
    
    # zadame cesty k potrebnym programum
    IPTABLES="/sbin/iptables"
    IP="/sbin/ip"
    #NAT_CONFIG="/etc/nat_1-1.conf"
    NAT_CONFIG="/nat-1-1.conf"
    
    # rozsah czela.netu, nebo vnitrni site
    NAT_DEV="eth0"
    INTERNAL_IP="10.93.0.0/16"
    EXTERNAL_IP="88.146.200.0/22"
    
    # dummy rozhrani
    DUMMY_IFACE="dummy0"
    DUMMY_IP="10.93.0.32"
    
        convert_net_to_mask() {
    
            if let $(( (32-$1) > 0)); then
                M4=$(( (255 << (32-$1)) & 255))
            else
                M4=255
            fi
            if let $(( (24-$1) > 0)); then
                M3=$(( (255 << (24-$1)) & 255))
            else
                M3=255
            fi
            if let $(( (16-$1) > 0)); then
                M2=$(( (255 << (16-$1)) & 255))
            else
                M2=255
            fi
            if let $(( (8-$1) > 0)); then
                M1=$(( (255 << (8-$1)) & 255))
            else
                M1=255
            fi
    
        }
    
        convert_ip_to_network() {
    
        IP_POM=($(tr '/' ' ' <<< "$1"))
        BC=${IP_POM[1]}
        IP_POM=($(tr '.' ' ' <<< "${IP_POM[0]}"))
        BCN="$(($BC - 1))"
    
        convert_net_to_mask "$BCN"
    
    
    
        }
        # Tady zacina nat 1:1
        if [ ! -e $NAT_CONFIG ]; then
            echo "error, $NAT_CONFIG does not exist!"
        else
            # Zakladni cast celkem peti stromu
            IP_POM=""
            M1=""
            M2=""
            M3=""
            M4=""
            BC=""
            BCN=""
            # vytvorime zakladni chainy
            if [ -z "`$IPTABLES -t nat -L -n | grep \"chain_pre\"`" ]; then
                $IPTABLES -t nat -N "chain_pre"
                $IPTABLES -t nat -A PREROUTING -i $NAT_DEV -d $EXTERNAL_IP -j "chain_pre"
                $IPTABLES -t nat -N "chain_post"
                $IPTABLES -t nat -A POSTROUTING -o $NAT_DEV -s $INTERNAL_IP -j "chain_post"
                $IPTABLES -N "chain_fwd"
                $IPTABLES -A FORWARD -i $NAT_DEV -s $INTERNAL_IP -j "chain_fwd"
                $IPTABLES -t nat -N "chain_pre_2"
                $IPTABLES -t nat -A PREROUTING -i ! $NAT_DEV -s $INTERNAL_IP -d $EXTERNAL_IP -j "chain_pre_2"
                $IPTABLES -t nat -N "chain_post_2"
                $IPTABLES -t nat -A POSTROUTING -o ! $NAT_DEV -s $INTERNAL_IP -d $INTERNAL_IP -j "chain_post_2"
            fi
            #while read UserName PublicIP PrivateIP; do
            PublicIP=$1
            PrivateIP=$2
            UserName=$3
                if [ "`echo $UserName | cut -c1`" == "#" ] || [ "`echo $PublicIP | cut -c1`" == "#" ]; then
                    if [ "`echo $UserName | cut -c2`" != " " ] && [ "`echo $UserName | cut -c2`" != "" ] && [ "`echo $UserName | cut -c2`"                    echo "    $UserName commented"
                    fi
                    if [ "`echo $PublicIP | cut -c2`" != " " ]; then
                        echo "    $UserName commented"
                    fi
                else
                    echo "    $UserName ($PrivateIP -> $PublicIP)"
                    for LOCAL_IP in $PrivateIP; do
                        # rozdeleni na porty
                        if [ "`echo $LOCAL_IP | grep :`" ]; then
                            PORT_TYPE="`echo $LOCAL_IP | cut -d: -f2`"
                            PUBLIC_PORT="`echo $LOCAL_IP | cut -d: -f3`"
                            PRIVATE_PORT="`echo $LOCAL_IP | cut -d: -f4`"
                        fi
                        # local ip musi byt jako posledni!
                        LOCAL_IP="`echo $LOCAL_IP | cut -d: -f1`"
    
                        if [ "`echo $PUBLIC_PORT | grep -`" != "" ]; then
                            PUBLIC_PORT="`echo $PUBLIC_PORT | cut -d- -f1`:`echo $PUBLIC_PORT | cut -d- -f2`"
                        fi
                        echo 0
                        # Tato cast je opet pro generovani stromu
                        # tam kde je rozdeleni podle INTERNAL_IP
                        # chain_post
                        if [ -z "`echo $LOCAL_IP | grep /`" ]; then
                            LOCAL_IP=$LOCAL_IP/32
                        fi
                        if [ -z "`echo $PublicIP | grep /`" ]; then
                            PublicIP=$PublicIP/32
                        fi
                        I="0"
                        J="$((`echo $LOCAL_IP | cut -d/ -f2` - `echo $INTERNAL_IP | cut -d/ -f2`))"
                        IP_POM="$LOCAL_IP"
                        CHAINS=""
                        while [[ $I -lt $J ]]; do
                            convert_ip_to_network "$IP_POM"
                            CHAIN="chain_post_${IP_POM[0]}${IP_POM[1]}${IP_POM[2]}${IP_POM[3]}_$BC"
                            if [[ -z "`$IPTABLES -t nat -L -n | grep \"$CHAIN\"`" ]]; then
                                $IPTABLES -t nat -N "$CHAIN"
                            fi
                            IP_POMS="${IP_POM[0]}.${IP_POM[1]}.${IP_POM[2]}.${IP_POM[3]}/$BC $IP_POMS"
                            CHAINS="$CHAIN $CHAINS"
                            IP_POM="$((${IP_POM[0]} & $M1)).$((${IP_POM[1]} & $M2)).$((${IP_POM[2]} & $M3)).$((${IP_POM[3]} & $M4))/$BCN"
                            ((I++))
                        done
                        CHAINS="chain_post $CHAINS"
                        I="1"
                        for IP_POM in $IP_POMS; do
                            CHAIND="`echo $CHAINS | cut -d \" \" -f $(($I + 1))`"
                            if [[ -z "`$IPTABLES -t nat -L -n | grep \"$CHAIND\"`" ]]; then
                                $IPTABLES -t nat -A "`echo $CHAINS | cut -d \" \" -f $I`" -s $IP_POM -j "$CHAIND"
                            fi
                            ((I++))
                        done
                        echo 1
                        if false; then
                        # chain_post_2
                        I="0"
                        J="$((`echo $LOCAL_IP | cut -d/ -f2` - `echo $INTERNAL_IP | cut -d/ -f2`))"
                        IP_POM="$LOCAL_IP"
                        CHAINS=""
                        while [[ $I -lt $J ]]; do
                            convert_ip_to_network "$IP_POM"
                            CHAIN="chain_post_2_${IP_POM[0]}${IP_POM[1]}${IP_POM[2]}${IP_POM[3]}_$BC"
                            if [[ -z "`$IPTABLES -t nat -L -n | grep \"$CHAIN\"`" ]]; then
                                $IPTABLES -t nat -N "$CHAIN"
                            fi
                            IP_POMS="${IP_POM[0]}.${IP_POM[1]}.${IP_POM[2]}.${IP_POM[3]}/$BC $IP_POMS"
                            CHAINS="$CHAIN $CHAINS"
                            IP_POM="$((${IP_POM[0]} & $M1)).$((${IP_POM[1]} & $M2)).$((${IP_POM[2]} & $M3)).$((${IP_POM[3]} & $M4))/$BCN"
                            ((I++))
                        done
                        CHAINS="chain_post_2 $CHAINS"
                        I="1"
                        for IP_POM in $IP_POMS; do
                            CHAIND="`echo $CHAINS | cut -d \" \" -f $(($I + 1))`"
                            if [[ -z "`$IPTABLES -t nat -L -n | grep \"$CHAIND\"`" ]]; then
                                $IPTABLES -t nat -A "`echo $CHAINS | cut -d \" \" -f $I`" -d $IP_POM -j "$CHAIND"
                            fi
                            ((I++))
                        done
                        fi
                        echo 2
                        # chain_fwd
                        I="0"
                        J="$((`echo $LOCAL_IP | cut -d/ -f2` - `echo $INTERNAL_IP | cut -d/ -f2`))"
                        IP_POM="$LOCAL_IP"
                        CHAINS=""
                        while [[ $I -lt $J ]]; do
                            convert_ip_to_network "$IP_POM"
                            CHAIN="chain_fwd_${IP_POM[0]}${IP_POM[1]}${IP_POM[2]}${IP_POM[3]}_$BC"
                            if [[ -z "`$IPTABLES -L -n | grep \"$CHAIN\"`" ]]; then
                                $IPTABLES -N "$CHAIN"
                            fi
                            IP_POMS="${IP_POM[0]}.${IP_POM[1]}.${IP_POM[2]}.${IP_POM[3]}/$BC $IP_POMS"
                            CHAINS="$CHAIN $CHAINS"
                            IP_POM="$((${IP_POM[0]} & $M1)).$((${IP_POM[1]} & $M2)).$((${IP_POM[2]} & $M3)).$((${IP_POM[3]} & $M4))/$BCN"
                            ((I++))
                        done
                        CHAINS="chain_fwd $CHAINS"
                        I="1"
                        for IP_POM in $IP_POMS; do
                            CHAIND="`echo $CHAINS | cut -d \" \" -f $(($I + 1))`"
                            if [[ -z "`$IPTABLES -L -n | grep \"$CHAIND\"`" ]]; then
                                $IPTABLES -A "`echo $CHAINS | cut -d \" \" -f $I`" -d $IP_POM -j "$CHAIND"
                            fi
                            ((I++))
                        done
                        echo 3
                        # pro ty kde je rozdeleni podle EXTERNAL_IP
                        # chain_pre
                        I="0"
                        J="$((`echo $PublicIP | cut -d/ -f2` - `echo $EXTERNAL_IP | cut -d/ -f2`))"
                        IP_POM="$PublicIP"
                        CHAINS=""
                        while [[ $I -lt $J ]]; do
                            convert_ip_to_network "$IP_POM"
                            CHAIN="chain_pre_${IP_POM[0]}${IP_POM[1]}${IP_POM[2]}${IP_POM[3]}_$BC"
                            if [[ -z "`$IPTABLES -t nat -L -n | grep \"$CHAIN\"`" ]]; then
                                $IPTABLES -t nat -N "$CHAIN"
                            fi
                            IP_POMS="${IP_POM[0]}.${IP_POM[1]}.${IP_POM[2]}.${IP_POM[3]}/$BC $IP_POMS"
                            CHAINS="$CHAIN $CHAINS"
                            IP_POM="$((${IP_POM[0]} & $M1)).$((${IP_POM[1]} & $M2)).$((${IP_POM[2]} & $M3)).$((${IP_POM[3]} & $M4))/$BCN"
                            ((I++))
                        done
                        CHAINS="chain_pre $CHAINS"
                        I="1"
                        for IP_POM in $IP_POMS; do
                            CHAIND="`echo $CHAINS | cut -d \" \" -f $(($I + 1))`"
                            if [[ -z "`$IPTABLES -t nat -L -n | grep \"$CHAIND\"`" ]]; then
                                $IPTABLES -t nat -A "`echo $CHAINS | cut -d \" \" -f $I`" -d $IP_POM -j "$CHAIND"
                            fi
                            ((I++))
                        done
                        echo 4
                        # chain_pre_2
                        if false; then
                        I="0"
                        J="$((`echo $PublicIP | cut -d/ -f2` - `echo $EXTERNAL_IP | cut -d/ -f2`))"
                        IP_POM="$PublicIP"
                        CHAINS=""
                        while [[ $I -lt $J ]]; do
                            convert_ip_to_network "$IP_POM"
                            CHAIN="chain_pre_2_${IP_POM[0]}${IP_POM[1]}${IP_POM[2]}${IP_POM[3]}_$BC"
                            if [[ -z "`$IPTABLES -t nat -L -n | grep \"$CHAIN\"`" ]]; then
                                $IPTABLES -t nat -N "$CHAIN"
                            fi
                            IP_POMS="${IP_POM[0]}.${IP_POM[1]}.${IP_POM[2]}.${IP_POM[3]}/$BC $IP_POMS"
                            CHAINS="$CHAIN $CHAINS"
                            IP_POM="$((${IP_POM[0]} & $M1)).$((${IP_POM[1]} & $M2)).$((${IP_POM[2]} & $M3)).$((${IP_POM[3]} & $M4))/$BCN"
                            ((I++))
                        done
                        CHAINS="chain_pre_2 $CHAINS"
                        I="1"
                        for IP_POM in $IP_POMS; do
                            CHAIND="`echo $CHAINS | cut -d \" \" -f $(($I + 1))`"
                            if [[ -z "`$IPTABLES -t nat -L -n | grep \"$CHAIND\"`" ]]; then
                                $IPTABLES -t nat -A "`echo $CHAINS | cut -d \" \" -f $I`" -d $IP_POM -j "$CHAIND"
                            fi
                            ((I++))
                        done
                        fi
                        echo 5
                        # no a strom je za nami
                        # zakladni nat 1:1
                        PUBLIC_POM="`echo $PublicIP | cut -d. -f1``echo $PublicIP | cut -d. -f2``echo $PublicIP | cut -d. -f3``echo $Publi                    LOCAL_POM="`echo $LOCAL_IP | cut -d. -f1``echo $LOCAL_IP | cut -d. -f2``echo $LOCAL_IP | cut -d. -f3``echo $LOCAL_                    PublicIP2="`echo $PublicIP | cut -d/ -f1`"
                        LOCAL_IP2="`echo $LOCAL_IP | cut -d/ -f1`"
                        if [ "$PUBLIC_PORT" == "" ]; then
                            $IPTABLES -t nat -A chain_pre_"$PUBLIC_POM" -d $PublicIP2 -j DNAT --to $LOCAL_IP2
                            $IPTABLES -t nat -A chain_post_"$LOCAL_POM" -s $LOCAL_IP2 -j SNAT --to $PublicIP2
                            $IPTABLES -A chain_fwd_"$LOCAL_POM" -d $LOCAL_IP2 -j ACCEPT
                        elif [ "$PRIVATE_PORT" == "" ]; then
                            $IPTABLES -t nat -A chain_pre_"$PUBLIC_POM" -d $PublicIP2 -p $PORT_TYPE --dport $PUBLIC_PORT -j DNAT --to $LOC                        $IPTABLES -t nat -A chain_post_"$LOCAL_POM" -s $LOCAL_IP2 -j SNAT --to $PublicIP2
                            $IPTABLES -A chain_fwd_"$LOCAL_POM" -d $LOCAL_IP2 -p $PORT_TYPE --dport $PUBLIC_PORT -j ACCEPT
                        else
                            $IPTABLES -t nat -A chain_pre_"$PUBLIC_POM" -d $PublicIP2 -p $PORT_TYPE --dport $PUBLIC_PORT -j DNAT --to $LOC                        $IPTABLES -t nat -A chain_post_"$LOCAL_POM" -s $LOCAL_IP2 -j SNAT --to $PublicIP2
                            $IPTABLES -A chain_fwd_"$LOCAL_POM" -d $LOCAL_IP2 -p $PORT_TYPE --dport $PRIVATE_PORT -j ACCEPT
                        fi
                        # Zaroven by bylo pekne zevnitr site na svou verejnou ip pingnout,
                        # pro tohle je idealne nutne mit dummy, dalsi moznost je nastavit
                        # DUMMY_IFACE na jedno z rozhrani LAN, kde se neprovadi nat.
                        if false; then
                        [ "$DUMMY_IFACE" == "" ] && DUMMY_IFACE="dummy0"
                        [ "$DUMMY_IP" == "" ] && DUMMY_IP="`$IP addr show $DUMMY_IFACE | grep inet | grep -v inet6 | awk '{print \$2}' | c                    if [ "$PUBLIC_PORT" == "" ]; then
                            $IPTABLES -t nat -A chain_pre_2_"$PUBLIC_POM" -d $PublicIP2 -j DNAT --to $LOCAL_IP2
                            $IPTABLES -t nat -A chain_post_2_"$LOCAL_POM" -d $LOCAL_IP2 -j SNAT --to $DUMMY_IP
                        elif [ "$PRIVATE_PORT" == "" ]; then
                            $IPTABLES -t nat -A chain_pre_2_"$PUBLIC_POM" -d $PublicIP2 -p $PORT_TYPE --dport $PUBLIC_PORT -j DNAT --to $L                        $IPTABLES -t nat -A chain_post_2_"$LOCAL_POM" -d $LOCAL_IP2 -p $PORT_TYPE --dport $PUBLIC_PORT -j SNAT --to $D                    else
                            $IPTABLES -t nat -A chain_pre_2_"$PUBLIC_POM" -d $PublicIP2 -p $PORT_TYPE --dport $PUBLIC_PORT -j DNAT --to $L                        $IPTABLES -t nat -A chain_post_2_"$LOCAL_POM" -d $LOCAL_IP2 -p $PORT_TYPE --dport $PRIVATE_PORT -j SNAT --to $                    fi
                        fi
                    done
                fi
        fi
    Třetí soubor je konfigurační:
    62.240.181.2    10.93.0.1       ns.czela.net
    62.240.181.3    10.93.1.211       vochomurka
    62.240.181.4    10.93.0.18      mikael.czela.net
    62.240.181.9    10.93.0.103     zapy.czela.net
    62.240.181.10   10.93.16.9      nns.neverhood.cz
    62.240.181.13   10.93.34.139    cermaksip.czela.net
    62.240.181.15   10.93.0.30      karany.czela.net
    62.240.181.18   10.93.11.7      wg.czela.net
    
    Thunder.m avatar 4.11.2006 14:51 Thunder.m | skóre: 35 | blog: e17
    Rozbalit Rozbalit vše Re: Něco rychlejšího než cat?
    Už jsem to našel, iptables se asi nelíbí tak moc příkazů a tak časem stoupne doba vykonání určitého příkazu.

    Založit nové vláknoNahoru

    Tiskni Sdílej: Linkuj Jaggni to Vybrali.sme.sk Google Del.icio.us Facebook

    ISSN 1214-1267   www.czech-server.cz
    © 1999-2015 Nitemedia s. r. o. Všechna práva vyhrazena.