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

včera 23:55 | Pozvánky

Spolek OpenAlt zve příznivce otevřených technologií a otevřeného přístupu na 145. brněnský sraz, který proběhne v pátek 20. října od 18:00 hodin v restauraci Time Out na adrese Novoměstská 2 v Řečkovicích. Jedná se o poslední sraz před konferencí OpenAlt 2017, jež proběhne o víkendu 4. a 5. listopadu 2017 na FIT VUT v Brně. Běží registrace účastníků.

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

Byla vydána verze 5.2.0 multiplatformního virtualizačního nástroje Oracle VM VirtualBox. Jedná se o první stabilní verzi z nové větve 5.2. Z novinek lze zmínit například možnost exportování VM do Oracle Cloudu, bezobslužnou instalaci hostovaného systému nebo vylepšené GUI. Podrobnosti v seznamu změn. Aktualizována byla také dokumentace.

Ladislav Hagara | Komentářů: 1
včera 14:00 | Zajímavý projekt

Byl spuštěn Humble Down Under Bundle. Za vlastní cenu lze koupit multiplatformní hry The Warlock of Firetop Mountain, Screencheat, Hand of Fate a Satellite Reign. Při nadprůměrné platbě (aktuálně 3,63 $) také Hacknet, Hacknet Labyrinths, Crawl a Hurtworld. Při platbě 12 $ a více lze získat navíc Armello.

Ladislav Hagara | Komentářů: 0
včera 13:00 | Nová verze

Google Chrome 62 byl prohlášen za stabilní (YouTube). Nejnovější stabilní verze 62.0.3202.62 tohoto webového prohlížeče přináší řadu oprav a vylepšení. Vylepšeny byly také nástroje pro vývojáře (YouTube). Opraveno bylo 35 bezpečnostních chyb.

Ladislav Hagara | Komentářů: 2
včera 11:00 | Zajímavý článek

Článek (en) na Mozilla.cz je věnován vykreslování stránek ve Firefoxu. V průběhu roku 2018 by se ve Firefoxu měl objevit WebRender, jenž by měl vykreslování stránek urychlit díky využití GPU.

Ladislav Hagara | Komentářů: 4
včera 08:22 | Bezpečnostní upozornění

NÚKIB (Národní úřad pro kybernetickou a informační bezpečnost) informuje o zranitelnosti ROCA v procesu generování RSA klíčů, který se odehrává v softwarové knihovně implementované například v kryptografických čipových kartách, bezpečnostních tokenech a dalších hardwarových čipech vyrobených společností Infineon Technologies AG. Zranitelnost umožňuje praktický faktorizační útok, při kterém útočník dokáže vypočítat

… více »
Ladislav Hagara | Komentářů: 3
včera 01:23 | Zajímavý software

Příspěvek na blogu otevřené certifikační autority Let's Encrypt informuje o začlenění podpory protokolu ACME (Automatic Certificate Management Environment) přímo do webového serveru Apache. Klienty ACME lze nahradit novým modulem Apache mod_md. Na vývoj tohoto modulu bylo uvolněno 70 tisíc dolarů z programu Mozilla Open Source Support (MOSS). K rozchození HTTPS na Apache stačí nově přidat do konfiguračního souboru řádek s ManagedDomain. Minutový videonávod na YouTube [reddit].

Ladislav Hagara | Komentářů: 2
17.10. 14:15 | Komunita

Daniel Stenberg, autor nástroje curl, na svém blogu oznámil, že obdržel letošní Polhemovu cenu, kterou uděluje Švédská inženýrská asociace za „technologickou inovaci nebo důvtipné řešení technického problému“.

marbu | Komentářů: 10
17.10. 13:40 | Pozvánky

Cílem Social Good Hackathonu, který se uskuteční 21. a 22. října v Brně, je vymyslet a zrealizovat projekty, které pomůžou zlepšit svět kolem nás. Je to unikátní příležitost, jak představit nejrůznější sociální projekty a zrealizovat je, propojit aktivní lidi, zástupce a zástupkyně nevládních organizací a lidi z prostředí IT a designu. Hackathon pořádá brněnská neziskovka Nesehnutí.

… více »
Barbora | Komentářů: 1
17.10. 00:44 | Pozvánky

V sobotu 21. října 2017 se na půdě Elektrotechnické fakulty ČVUT v Praze uskuteční RT-Summit – setkání vývojářů linuxového jádra a uživatelů jeho real-time verze označované jako preempt-rt.

… více »
Pavel Píša | Komentářů: 8
Jak se vás potenciálně dotkne trend odstraňování analogového audio konektoru typu 3,5mm jack z „chytrých telefonů“?
 (13%)
 (2%)
 (0%)
 (2%)
 (73%)
 (11%)
Celkem 62 hlasů
 Komentářů: 4, poslední včera 21:50
    Rozcestník

    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: 233×
    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: 46 | 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.