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í
×

    8.11. 00:33 | Nová verze

    Byla vydána OpenIndiana 2026.10. Unixový operační systém OpenIndiana (Wikipedie) vychází z OpenSolarisu (Wikipedie).

    Ladislav Hagara | Komentářů: 24
    8.11. 00:22 | IT novinky

    Americký výrobce polovodičů onsemi (ON Semiconductor) zrušil plány na rozšíření výroby v rožnovském závodě v Česku za dvě miliardy dolarů (podle aktuálního kurzu zhruba 43,5 mld. Kč). Důvodem je vývoj na trhu.

    Ladislav Hagara | Komentářů: 62
    7.11. 13:00 | Bezpečnostní upozornění
    Nové vydání zlib opravuje několik problémů při kompresi a dekompresi dat, přetečení bufferů, čtení mimo vyhrazenou paměť, únik neinicializovaných dat. Zvlášť významné jsou chyby v inflateGetDictionary(), inflateSync() a gzwrite(), které mohou způsobit poškození paměti. Vysoká relevance - zlib používá řada systémových i aplikačních komponent.
    vencour | Komentářů: 1
    7.11. 12:25 | Bezpečnostní upozornění
    Digicert hlásí neoprávněné čtení archivních zákaznických údajů. Došlo k němu po migraci z února 2025, po níž se interní systém, dříve dostupný jen přes VPN, stal přístupným z internetu. Chyba v oprávněních umožnila nově vytvořeným účtům číst archivní záznamy. K přístupu k datům mělo dojít mezi 27. červnem a 2. červencem 2026. DigiCert neoprávněné čtení potvrdil až 19. října 2026. Problém zpočátku vyhodnotil jako tvorbu účtů, ne jako … více »
    vencour | Komentářů: 1
    7.11. 04:44 | Pozvánky

    O víkendu probíhá na FIT VUT v Brně konference OpenAlt 2026 o otevřeném softwaru a datech, IT bezpečnosti, DIY a IoT. Na programu je spousta zajímavých přednášek. Pokud jste v Brně, stavte se. Vstup zdarma. Přednášky lze sledovat i online na VHSky a YouTube.

    Ladislav Hagara | Komentářů: 2
    7.11. 02:11 | IT novinky

    Qualcomm uzavřel víceletou dohodu se SpaceX. Bude dodávat rádiové technologie, baseband jednotky a software pro plánovanou pozemní 5G síť Starlink Mobile. Výstavba má zahrnovat desítky tisíc základnových stanic v USA. Zahájení nasazování se očekává v roce 2027. Qualcomm dohodu označuje za svůj dosud největší 5G kontrakt.

    vencour | Komentářů: 4
    7.11. 02:00 | IT novinky

    Google rozšířil Cloud Vulnerability Reward Program. Nově nabízí odměnu až 250 tisíc dolarů za vysoce závažné architektonické bezpečnostní chyby označované jako Root-in-Cloud.

    vencour | Komentářů: 5
    6.11. 12:22 | IT novinky

    V březnu byla oznámena spolupráce GrapheneOS s Motorolou. Nejnovější vlajka Motorola Signature 27 je první Motorola s oficiální podporou GrapheneOS. GrapheneOS (Wikpedie) je varianta Androidu zaměřující se na bezpečnost a soukromí.

    Ladislav Hagara | Komentářů: 11
    6.11. 04:55 | Nová verze

    Omarchy (Wikipedie) je linuxová distribuce s dlaždicovým správcem oken Hyprland. Založena je na Arch Linuxu. Vydána byla v nové verzi 4.5.0. Nově také pro Apple Silicon, konkrétně pro M1/M2/M3/Neo MacBooky.

    Ladislav Hagara | Komentářů: 5
    6.11. 03:22 | Nová verze

    Byla vydána nová stabilní verze 8.3 webového prohlížeče Vivaldi (Wikipedie). Postavena je na Chromiu 156 s bezpečnostními opravami z Chromia 157. Přehled novinek i s náhledy v příspěvku na blogu.

    Ladislav Hagara | Komentářů: 3
    Které desktopové prostředí na Linuxu používáte?
     (8%)
     (7%)
     (4%)
     (21%)
     (30%)
     (9%)
     (5%)
     (2%)
     (14%)
     (20%)
    Celkem 3067 hlasů
     Komentářů: 36, poslední 11.11. 22:38
    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: 494×
    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ákno • Nahoru

    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.