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 15:33 | Zajímavý článek

    Nové číslo časopisu Raspberry Pi zdarma ke čtení: Raspberry Pi Official Magazine 153 (pdf)

    Ladislav Hagara | Komentářů: 0
    dnes 12:22 | Komunita

    Byl publikován květnový přehled dění a novinek z vývoje Asahi Linuxu, tj. Linuxu pro Apple Silicon. Vývojáře lze podpořit na Open Collective a GitHub Sponsors.

    Ladislav Hagara | Komentářů: 0
    včera 21:33 | Nová verze

    Programovací jazyk Rust (Wikipedie) dnes slaví 10 let od vydání verze 1.0. Přímo na oslavě byla vydána nová verze 1.87.0. Podrobnosti v poznámkách k vydání. Vyzkoušet Rust lze například na stránce Rust by Example.

    Ladislav Hagara | Komentářů: 0
    včera 14:44 | IT novinky

    Evropská komise obvinila provozovatele čínské platformy TikTok z porušování pravidel EU kvůli netransparentnosti v reklamě. Komise, která v EU plní i funkci antimonopolního úřadu, to dnes uvedla v tiskové zprávě. TikTok, který patří čínské firmě ByteDance, se může k předběžnému nálezu vyjádřit. Pokud ale podezření komise nevyvrátí, hrozí mu pokuta až do šesti procent z ročního globálního obratu.

    Ladislav Hagara | Komentářů: 12
    14.5. 20:44 | Komunita

    Sovereign Tech Agency (Wikipedie), tj. agentura zabezpečující financování svobodného a otevřeného softwaru německou vládou, podpoří GFortran částkou 360 000 eur.

    Ladislav Hagara | Komentářů: 0
    14.5. 14:00 | IT novinky

    Microsoft hodlá zrušit zhruba tři procenta pracovních míst. Microsoft na konci loňského června zaměstnával kolem 228.000 lidí. Tři procenta z tohoto počtu představují téměř 7000 pracovních míst.

    Ladislav Hagara | Komentářů: 16
    14.5. 13:33 | IT novinky

    V říjnu loňského roku provedl Úřad pro ochranu hospodářské soutěže (ÚOHS) místní šetření u společnosti Seznam.cz. Krajský soud v Brně tento týden konstatoval, že toto šetření bylo nezákonné.

    Ladislav Hagara | Komentářů: 15
    13.5. 22:22 | Bezpečnostní upozornění

    Branch Privilege Injection (CVE-2024-45332, Paper) je nejnovější bezpečnostní problém procesorů Intel. Intel jej řeší ve včerejším opravném vydání 20250512 mikrokódů pro své procesory. Neprivilegovaný uživatel si například může přečíst /etc/shadow (YouTube).

    Ladislav Hagara | Komentářů: 2
    13.5. 14:22 | Komunita

    Dle plánu byl vývoj Firefoxu přesunut z Mercurialu na Git. Oficiální repozitář se zdrojovými kódy je na GitHubu.

    Ladislav Hagara | Komentářů: 7
    13.5. 04:33 | Bezpečnostní upozornění

    V terminálovém multiplexoru GNU Screen byly nalezeny a v upstreamu ve verzi 5.0.1 už opraveny bezpečnostních chyby CVE-2025-23395, CVE-2025-46802, CVE-2025-46803, CVE-2025-46804 a CVE-2025-46805. Podrobnosti na blogu SUSE Security Teamu.

    Ladislav Hagara | Komentářů: 42
    Jaký filesystém primárně používáte?
     (57%)
     (1%)
     (8%)
     (23%)
     (4%)
     (2%)
     (3%)
     (1%)
     (0%)
     (3%)
    Celkem 625 hlasů
     Komentářů: 26, poslední 8.5. 09:58
    Rozcestník

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

    3.11.2006 10:01 Thunder.m | skóre: 35 | blog: e17
    Něco rychlejšího než cat?
    Přečteno: 269×
    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

    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: 52 | 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
    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: 49
    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?
    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="."
    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
    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
    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?
    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
    
    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.