#!/bin/sh 
#
#  This is automatically generated file. DO NOT MODIFY !
#
#  Firewall Builder  fwb_ipt v5.0.2.3596
#
#  Generated Sun Mar 18 21:16:30 2012 PDT by vadim
#
# files: * firewall25.fw /etc/fw/firewall25.fw
#
# Compiled for iptables 1.4.0
#
# this firewall uses iptables-restore format. Firewall has wildcard interface ppp*; script is generated dynamically and then piped to iptables-restore

# two rule sets for the filter table, to make sure there is only
# one COMMIT for both

# firewall25::: error: Dynamic interface ppp* should not have an IP address object attached to it. This IP address object will be ignored.

# firewall25:policy_2_mangle:1: error: Action Reject is not allowed in mangle table

# firewall25::: warning: Can not add virtual address for object address
# firewall25::: warning: Can not add virtual address for object address


FWBDEBUG=""

PATH="/sbin:/usr/sbin:/bin:/usr/bin:${PATH}"
export PATH



LSMOD="/sbin/lsmod"
MODPROBE="/sbin/modprobe"
IPTABLES="/sbin/iptables"
IP6TABLES="/sbin/ip6tables"
IPTABLES_RESTORE="/sbin/iptables-restore"
IP6TABLES_RESTORE="/sbin/ip6tables-restore"
IP="/sbin/ip"
IFCONFIG="/sbin/ifconfig"
VCONFIG="/sbin/vconfig"
BRCTL="/sbin/brctl"
IFENSLAVE="/sbin/ifenslave"
IPSET="/usr/sbin/ipset"
LOGGER="/usr/bin/logger"

log() {
    echo "$1"
    which "$LOGGER" >/dev/null 2>&1 && $LOGGER -p info "$1"
}

getInterfaceVarName() {
    echo $1 | sed 's/\./_/'
}

getaddr_internal() {
    dev=$1
    name=$2
    af=$3
    L=$($IP $af addr show dev $dev |  sed -n '/inet/{s!.*inet6* !!;s!/.*!!p}' | sed 's/peer.*//')
    test -z "$L" && { 
        eval "$name=''"
        return
    }
    eval "${name}_list=\"$L\"" 
}

getnet_internal() {
    dev=$1
    name=$2
    af=$3
    L=$($IP route list proto kernel | grep $dev | grep -v default |  sed 's! .*$!!')
    test -z "$L" && { 
        eval "$name=''"
        return
    }
    eval "${name}_list=\"$L\"" 
}


getaddr() {
    getaddr_internal $1 $2 "-4"
}

getaddr6() {
    getaddr_internal $1 $2 "-6"
}

getnet() {
    getnet_internal $1 $2 "-4"
}

getnet6() {
    getnet_internal $1 $2 "-6"
}

# function getinterfaces is used to process wildcard interfaces
getinterfaces() {
    NAME=$1
    $IP link show | grep ": $NAME" | while read L; do
        OIFS=$IFS
        IFS=" :"
        set $L
        IFS=$OIFS
        echo $2
    done
}

diff_intf() {
    func=$1
    list1=$2
    list2=$3
    cmd=$4
    for intf in $list1
    do
        echo $list2 | grep -q $intf || {
        # $vlan is absent in list 2
            $func $intf $cmd
        }
    done
}

find_program() {
  PGM=$1
  which $PGM >/dev/null 2>&1 || {
    echo "\"$PGM\" not found"
    exit 1
  }
}
check_tools() {
  find_program which
  find_program $IPTABLES 
  find_program $IPTABLES_RESTORE
  find_program $IP 
}
reset_iptables_v4() {
  $IPTABLES -P OUTPUT  DROP
  $IPTABLES -P INPUT   DROP
  $IPTABLES -P FORWARD DROP

cat /proc/net/ip_tables_names | while read table; do
  $IPTABLES -t $table -L -n | while read c chain rest; do
      if test "X$c" = "XChain" ; then
        $IPTABLES -t $table -F $chain
      fi
  done
  $IPTABLES -t $table -X
done
}

reset_iptables_v6() {
  $IP6TABLES -P OUTPUT  DROP
  $IP6TABLES -P INPUT   DROP
  $IP6TABLES -P FORWARD DROP

cat /proc/net/ip6_tables_names | while read table; do
  $IP6TABLES -t $table -L -n | while read c chain rest; do
      if test "X$c" = "XChain" ; then
        $IP6TABLES -t $table -F $chain
      fi
  done
  $IP6TABLES -t $table -X
done
}


P2P_INTERFACE_WARNING=""

missing_address() {
    address=$1
    cmd=$2

    oldIFS=$IFS
    IFS="@"
    set $address
    addr=$1
    interface=$2
    IFS=$oldIFS



    $IP addr show dev $interface | grep -q POINTOPOINT && {
        test -z "$P2P_INTERFACE_WARNING" && echo "Warning: Can not update address of interface $interface. fwbuilder can not manage addresses of point-to-point interfaces yet"
        P2P_INTERFACE_WARNING="yes"
        return
    }

    test "$cmd" = "add" && {
      echo "# Adding ip address: $interface $addr"
      echo $addr | grep -q ':' && {
          $FWBDEBUG $IP addr $cmd $addr dev $interface
      } || {
          $FWBDEBUG $IP addr $cmd $addr broadcast + dev $interface
      }
    }

    test "$cmd" = "del" && {
      echo "# Removing ip address: $interface $addr"
      $FWBDEBUG $IP addr $cmd $addr dev $interface || exit 1
    }

    $FWBDEBUG $IP link set $interface up
}

list_addresses_by_scope() {
    interface=$1
    scope=$2
    ignore_list=$3
    $IP addr ls dev $interface | \
      awk -v IGNORED="$ignore_list" -v SCOPE="$scope" \
        'BEGIN {
           split(IGNORED,ignored_arr);
           for (a in ignored_arr) {ignored_dict[ignored_arr[a]]=1;}
         }
         (/inet |inet6 / && $0 ~ SCOPE && !($2 in ignored_dict)) {print $2;}' | \
        while read addr; do
          echo "${addr}@$interface"
	done | sort
}


update_addresses_of_interface() {
    ignore_list=$2
    set $1 
    interface=$1 
    shift

    FWB_ADDRS=$(
      for addr in $*; do
        echo "${addr}@$interface"
      done | sort
    )

    CURRENT_ADDRS_ALL_SCOPES=""
    CURRENT_ADDRS_GLOBAL_SCOPE=""

    $IP link show dev $interface >/dev/null 2>&1 && {
      CURRENT_ADDRS_ALL_SCOPES=$(list_addresses_by_scope $interface 'scope .*' "$ignore_list")
      CURRENT_ADDRS_GLOBAL_SCOPE=$(list_addresses_by_scope $interface 'scope global' "$ignore_list")
    } || {
      echo "# Interface $interface does not exist"
      # Stop the script if we are not in test mode
      test -z "$FWBDEBUG" && exit 1
    }

    diff_intf missing_address "$FWB_ADDRS" "$CURRENT_ADDRS_ALL_SCOPES" add
    diff_intf missing_address "$CURRENT_ADDRS_GLOBAL_SCOPE" "$FWB_ADDRS" del
}

clear_addresses_except_known_interfaces() {
    $IP link show | sed 's/://g' | awk -v IGNORED="$*" \
        'BEGIN {
           split(IGNORED,ignored_arr);
           for (a in ignored_arr) {ignored_dict[ignored_arr[a]]=1;}
         }
         (/state/ && !($2 in ignored_dict)) {print $2;}' | \
         while read intf; do
            echo "# Removing addresses not configured in fwbuilder from interface $intf"
            $FWBDEBUG $IP addr flush dev $intf scope global
            $FWBDEBUG $IP link set $intf down
         done
}

check_file() {
    test -r "$2" || {
        echo "Can not find file $2 referenced by address table object $1"
        exit 1
    }
}

check_run_time_address_table_files() {
    :
    
}

load_modules() {
    :
    
}

verify_interfaces() {
    :
    echo "Verifying interfaces: eth0 eth2"
    for i in eth0 eth2 ; do
        $IP link show "$i" > /dev/null 2>&1 || {
            log "Interface $i does not exist"
            exit 1
        }
    done
}

prolog_commands() {
    echo "Running prolog script"
    
}

epilog_commands() {
    echo "Running epilog script"
    
}

run_epilog_and_exit() {
    epilog_commands
    exit $1
}

configure_interfaces() {
    :
    # Configure interfaces
    update_addresses_of_interface "eth0 192.168.1.1/24" ""
    update_addresses_of_interface "eth2 192.168.2.1/24" ""
}

script_body() {
    echo 30 > /proc/sys/net/ipv4/tcp_fin_timeout 
     echo 1800 > /proc/sys/net/ipv4/tcp_keepalive_intvl 


    # ================ IPv4



    (

    echo '*filter'
    # ================ Table 'filter', automatic rules
    echo :INPUT DROP [0:0]
    echo :FORWARD DROP [0:0]
    echo :OUTPUT DROP [0:0]
    # accept established sessions
    echo "-A INPUT   -m state --state ESTABLISHED,RELATED -j ACCEPT "
    echo "-A OUTPUT  -m state --state ESTABLISHED,RELATED -j ACCEPT "
    echo "-A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT "
    # backup ssh access
    echo "-A INPUT  -p tcp -m tcp  -s 192.168.1.1/255.255.255.255  --dport 22  -m state --state NEW,ESTABLISHED -j  ACCEPT "
    echo "-A OUTPUT  -p tcp -m tcp  -d 192.168.1.1/255.255.255.255  --sport 22  -m state --state ESTABLISHED,RELATED -j ACCEPT "
    # drop TCP sessions opened prior firewall restart
    echo "-A INPUT   -p tcp -m tcp ! --tcp-flags SYN,RST,ACK SYN -m state --state NEW -j DROP "
    echo "-A OUTPUT  -p tcp -m tcp ! --tcp-flags SYN,RST,ACK SYN -m state --state NEW -j DROP "
    echo "-A FORWARD -p tcp -m tcp ! --tcp-flags SYN,RST,ACK SYN -m state --state NEW -j DROP "
    # drop packets that do not match any valid state 
    echo "-A OUTPUT   -m state --state INVALID  -j DROP "
    echo "-A INPUT    -m state --state INVALID  -j DROP "
    echo "-A FORWARD  -m state --state INVALID  -j DROP "
    # ================ Table 'filter', rule set policy_2
    # 
    # Rule  policy_2 0 (eth2)
    echo ":policy_2 - [0:0]"
    echo "-A policy_2 -o eth2   -m state --state NEW  -j ACCEPT "
    # 
    # Rule  policy_2 1 (global)
    echo ":policy_2_1 - [0:0]"
    echo "-A policy_2  -j policy_2_1 "
    echo "-A policy_2_1  -j LOG "
    echo "-A policy_2_1  -j DROP "
    #
    # ================ Table 'filter', rule set mangle_ruleset
    # 
    # Rule  mangle_ruleset 0 (global)
    echo ":mangle_ruleset - [0:0]"
    echo ":mangle_ruleset_0 - [0:0]"
    echo "-A mangle_ruleset  -j mangle_ruleset_0 "
    echo "-A mangle_ruleset_0  -j LOG "
    echo "-A mangle_ruleset_0  -j DROP "
    #
    # ================ Table 'filter', rule set Policy
    # 
    # Rule  0 (ppp*)
    # ppp clients get addresses on 10.1.1.0
    echo ":In_RULE_0 - [0:0]"
    echo "-A INPUT -i ppp+   -s ! 10.1.1.0/24   -j In_RULE_0 "
    echo "-A FORWARD -i ppp+   -s ! 10.1.1.0/24   -j In_RULE_0 "
    echo "-A In_RULE_0  -j LOG "
    echo "-A In_RULE_0  -j DROP "
    # 
    # Rule  1 (ppp*)
    # ppp clients can not connect to the firewall
    echo ":In_RULE_1 - [0:0]"
    getinterfaces ppp | while read I; do
        ivar=$(getInterfaceVarName $I)
        getaddr $I $ivar
        cmd="$"${ivar}_list
        eval "addr_list=$cmd"
        for addr in $addr_list
        do
            test -n "$addr" && echo "-A INPUT -i ppp+   -d $addr   -j In_RULE_1 "
        done
    done
    echo "-A In_RULE_1  -j LOG "
    echo "-A In_RULE_1  -j DROP "
    # 
    # Rule  2 (ppp*)
    echo ":In_RULE_2 - [0:0]"
    echo "-A INPUT -i ppp+   -j In_RULE_2 "
    echo "-A In_RULE_2  -j LOG "
    echo "-A In_RULE_2  -j DROP "
    # 
    # Rule  3 (ppp*)
    # ppp clients can only connect to the mail
    # server and web proxy on DMZ
    echo "-A FORWARD -i ppp+  -p tcp -m tcp  -m multiport  -d 192.168.2.10   --dports 25,3128  -m state --state NEW  -j ACCEPT "
    # 
    # Rule  4 (ppp*)
    # ppp clients can not connect to
    # anything else on DMZ and
    # internal net
    echo ":In_RULE_4 - [0:0]"
    echo "-A INPUT -i ppp+   -d 192.168.1.0/24   -j In_RULE_4 "
    echo "-A INPUT -i ppp+   -d 192.168.2.0/24   -j In_RULE_4 "
    echo "-A FORWARD -i ppp+   -d 192.168.1.0/24   -j In_RULE_4 "
    echo "-A FORWARD -i ppp+   -d 192.168.2.0/24   -j In_RULE_4 "
    echo "-A In_RULE_4  -j LOG "
    echo "-A In_RULE_4  -j DROP "
    # 
    # Rule  5 (eth2)
    echo ":In_RULE_5 - [0:0]"
    echo "-A INPUT -i eth2   -s ! 192.168.2.0/24   -j In_RULE_5 "
    echo "-A FORWARD -i eth2   -s ! 192.168.2.0/24   -j In_RULE_5 "
    echo "-A In_RULE_5  -j LOG "
    echo "-A In_RULE_5  -j DROP "
    # 
    # Rule  6 (global)
    # hostF has the same IP address as firewal.
    echo ":RULE_6 - [0:0]"
    echo "-A OUTPUT -p icmp  -m icmp  -d 192.168.1.1   --icmp-type 8/0   -m state --state NEW  -j RULE_6 "
    echo "-A INPUT -p icmp  -m icmp  -d 192.168.1.1   --icmp-type 8/0   -m state --state NEW  -j RULE_6 "
    echo "-A RULE_6  -j LOG "
    echo "-A RULE_6  -j ACCEPT "
    # 
    # Rule  7 (global)
    echo ":Cid417C681B.0 - [0:0]"
    echo "-A OUTPUT -p tcp -m tcp  --dport 22  -m state --state NEW  -j Cid417C681B.0 "
    getinterfaces ppp | while read I; do
        ivar=$(getInterfaceVarName $I)
        getaddr $I $ivar
        cmd="$"${ivar}_list
        eval "addr_list=$cmd"
        for addr in $addr_list
        do
            test -n "$addr" && echo "-A Cid417C681B.0  -d $addr   -j ACCEPT "
        done
    done
    echo "-A Cid417C681B.0  -d 192.168.1.1   -j ACCEPT "
    echo "-A Cid417C681B.0  -d 192.168.2.1   -j ACCEPT "
    echo "-A INPUT -p tcp -m tcp  --dport 22  -m state --state NEW  -j ACCEPT "
    # 
    # Rule  8 (global)
    getinterfaces ppp | while read I; do
        ivar=$(getInterfaceVarName $I)
        getaddr $I $ivar
        cmd="$"${ivar}_list
        eval "addr_list=$cmd"
        for addr in $addr_list
        do
            test -n "$addr" && echo "-A OUTPUT -p tcp -m tcp  -d $addr   --dport 22  -m state --state NEW  -j ACCEPT "
        done
    done
    getinterfaces ppp | while read I; do
        ivar=$(getInterfaceVarName $I)
        getaddr $I $ivar
        cmd="$"${ivar}_list
        eval "addr_list=$cmd"
        for addr in $addr_list
        do
            test -n "$addr" && echo "-A INPUT -p tcp -m tcp  -d $addr   --dport 22  -m state --state NEW  -j ACCEPT "
        done
    done
    # 
    # Rule  9 (global)
    echo "-A OUTPUT -p tcp -m tcp  -d 192.168.1.1   --dport 22  -m state --state NEW  -j ACCEPT "
    echo "-A INPUT -p tcp -m tcp  -d 192.168.1.1   --dport 22  -m state --state NEW  -j ACCEPT "
    # 
    # Rule  10 (global)
    echo "-A OUTPUT -p tcp -m tcp  -m multiport  -d 192.168.1.1   --dports 22,23  -m state --state NEW  -j ACCEPT "
    echo "-A INPUT -p tcp -m tcp  -m multiport  -d 192.168.1.1   --dports 22,23  -m state --state NEW  -j ACCEPT "
    # 
    # Rule  11 (global)
    echo ":Cid417C6844.0 - [0:0]"
    echo "-A OUTPUT -p tcp -m tcp  -m multiport  --dports 22,23  -m state --state NEW  -j Cid417C6844.0 "
    echo "-A Cid417C6844.0  -d 192.168.1.1   -j ACCEPT "
    echo "-A Cid417C6844.0  -d 192.168.2.1   -j ACCEPT "
    echo ":Cid417C6844.1 - [0:0]"
    echo "-A INPUT -p tcp -m tcp  -m multiport  --dports 22,23  -m state --state NEW  -j Cid417C6844.1 "
    echo "-A Cid417C6844.1  -d 192.168.1.1   -j ACCEPT "
    echo "-A Cid417C6844.1  -d 192.168.2.1   -j ACCEPT "
    # 
    # Rule  12 (global)
    echo ":Cid417C684F.0 - [0:0]"
    echo "-A OUTPUT -p tcp -m tcp  -m multiport  --dports 22,23  -m state --state NEW  -j Cid417C684F.0 "
    echo ":RULE_12 - [0:0]"
    echo "-A Cid417C684F.0  -d 192.168.1.1   -j RULE_12 "
    echo "-A Cid417C684F.0  -d 192.168.2.1   -j RULE_12 "
    echo ":Cid417C684F.1 - [0:0]"
    echo "-A INPUT -p tcp -m tcp  -m multiport  --dports 22,23  -m state --state NEW  -j Cid417C684F.1 "
    echo "-A Cid417C684F.1  -d 192.168.1.1   -j RULE_12 "
    echo "-A Cid417C684F.1  -d 192.168.2.1   -j RULE_12 "
    echo "-A RULE_12  -j LOG "
    echo "-A RULE_12  -j ACCEPT "
    # 
    # Rule  13 (global)
    # firewall is part of Any, so compiler should
    # generate code in both FORWARD and
    # OUTPUT chains
    echo "-A OUTPUT  -d 200.200.200.200   -m state --state NEW  -j ACCEPT "
    echo "-A FORWARD  -d 200.200.200.200   -m state --state NEW  -j ACCEPT "
    # 
    # Rule  14 (global)
    # firewall is part of Any, compiler should
    # generate code for both FORWARD and
    # INPUT chains
    echo "-A INPUT  -s 200.200.200.200   -m state --state NEW  -j ACCEPT "
    echo "-A FORWARD  -s 200.200.200.200   -m state --state NEW  -j ACCEPT "
    # 
    # Rule  15 (global)
    # because firewall has interface on network
    # internal_net, compiler should generate code
    # for both FORWARD and INPUT chains
    echo "-A INPUT  -s 192.168.1.10   -d 192.168.1.0/24   -m state --state NEW  -j ACCEPT "
    echo "-A FORWARD  -s 192.168.1.10   -d 192.168.1.0/24   -m state --state NEW  -j ACCEPT "
    # 
    # Rule  16 (global)
    echo ":Cid417C6878.0 - [0:0]"
    echo "-A OUTPUT  -d 200.200.200.200   -m state --state NEW  -j Cid417C6878.0 "
    echo "-A Cid417C6878.0  -s 192.168.1.0/24   -j ACCEPT "
    echo "-A Cid417C6878.0  -s 192.168.2.0/24   -j ACCEPT "
    echo ":Cid417C6878.1 - [0:0]"
    echo "-A FORWARD  -d 200.200.200.200   -m state --state NEW  -j Cid417C6878.1 "
    echo "-A Cid417C6878.1  -s 192.168.1.0/24   -j ACCEPT "
    echo "-A Cid417C6878.1  -s 192.168.2.0/24   -j ACCEPT "
    # 
    # Rule  17 (global)
    # this rule should go to mangle table,
    # since we also have default rule that goes to mangle (TCPMSS)
    # and pure mangle ruleset, making sure all rules for 
    # mangle table end up with one COMMIT
    echo "-A OUTPUT  -m state --state NEW  -j LOG "
    echo "-A INPUT  -m state --state NEW  -j LOG "
    echo "-A FORWARD  -m state --state NEW  -j LOG "
    # 
    # Rule  18 (global)
    echo "-A OUTPUT  -j policy_2 "
    echo "-A INPUT  -j policy_2 "
    echo "-A FORWARD  -j policy_2 "
    # 
    # Rule  20 (eth0)
    echo "-A INPUT -i eth0   -j policy_2 "
    echo "-A FORWARD -i eth0   -j policy_2 "
    # 
    # Rule  22 (global)
    # Automatically generated 'catch all' rule
    echo ":RULE_22 - [0:0]"
    echo "-A OUTPUT  -j RULE_22 "
    echo "-A INPUT  -j RULE_22 "
    echo "-A FORWARD  -j RULE_22 "
    echo "-A RULE_22  -j LOG "
    echo "-A RULE_22  -j DROP "
    #
    echo COMMIT


    echo '*mangle'
    # ================ Table 'mangle', automatic rules
    echo "-A FORWARD -p tcp -m tcp --tcp-flags SYN,RST SYN -j TCPMSS --clamp-mss-to-pmtu"
    # ================ Table 'mangle', rule set policy_2_mangle
    # 
    # Rule  policy_2_mangle 0 (eth2)
    echo ":policy_2_mangle - [0:0]"
    echo "-A policy_2_mangle -o eth2   -m state --state NEW  -j ACCEPT "
    # 
    # Rule  policy_2_mangle 1 (global)
    # SF bug report 3034628
    # "iptables does not allow target REJECT in mangle table"
    # firewall25:policy_2_mangle:1: error: Action Reject is not allowed in mangle table

    echo ":policy_2_mangle_1 - [0:0]"
    echo "-A policy_2_mangle -p tcp -m tcp  --dport 70  -j policy_2_mangle_1 "
    echo "-A policy_2_mangle_1  -j LOG "
    # 
    # Rule  policy_2_mangle 2 (global)
    echo ":policy_2_mangle_2 - [0:0]"
    echo "-A policy_2_mangle  -j policy_2_mangle_2 "
    echo "-A policy_2_mangle_2  -j LOG "
    echo "-A policy_2_mangle_2  -j DROP "
    #
    # ================ Table 'mangle', rule set Policy
    # 
    # Rule  17 (global)
    # this rule should go to mangle table,
    # since we also have default rule that goes to mangle (TCPMSS)
    # and pure mangle ruleset, making sure all rules for 
    # mangle table end up with one COMMIT
    echo "-A OUTPUT  -m state --state NEW  -j MARK --set-mark 10"
    echo "-A PREROUTING  -m state --state NEW  -j MARK --set-mark 10"
    # 
    # Rule  18 (global)
    echo ":policy_2 - [0:0]"
    echo "-A PREROUTING  -j policy_2 "
    echo "-A POSTROUTING  -j policy_2 "
    echo "-A FORWARD  -j policy_2 "
    # 
    # Rule  19 (global)
    echo "-A PREROUTING  -j policy_2_mangle "
    echo "-A POSTROUTING  -j policy_2_mangle "
    echo "-A FORWARD  -j policy_2_mangle "
    # 
    # Rule  20 (eth0)
    echo "-A PREROUTING -i eth0   -j policy_2 "
    echo "-A FORWARD -i eth0   -j policy_2 "
    # 
    # Rule  21 (eth0)
    echo "-A PREROUTING -i eth0   -j policy_2_mangle "
    echo "-A FORWARD -i eth0   -j policy_2_mangle "
    #
    echo COMMIT


    echo '*nat'
    # ================ Table 'nat',  rule set NAT
    echo :PREROUTING ACCEPT [0:0]
    echo :POSTROUTING ACCEPT [0:0]
    echo :OUTPUT ACCEPT [0:0]
    # 
    # Rule  0 (NAT)
    echo "-A POSTROUTING -o ppp+   -s 192.168.1.0/24  -j MASQUERADE  "
    echo "-A POSTROUTING -o eth2   -s 192.168.1.0/24  -j SNAT --to-source 192.168.2.1 "
    # 
    # Rule  1 (NAT)
    echo "-A POSTROUTING -o eth+   -s 192.168.1.0/24  -j SNAT --to-source 22.22.22.23 "
    echo "-A POSTROUTING -o ppp+   -s 192.168.1.0/24  -j SNAT --to-source 22.22.22.23 "
    # 
    # Rule  2 (NAT)
    getinterfaces ppp | while read I; do
        ivar=$(getInterfaceVarName $I)
        getaddr $I $ivar
        cmd="$"${ivar}_list
        eval "addr_list=$cmd"
        for addr in $addr_list
        do
            test -n "$addr" && echo "-A PREROUTING -p tcp -m tcp   -d $addr   --dport 22 -j DNAT --to-destination 192.168.1.10:22 "
        done
    done
    echo "-A PREROUTING -p tcp -m tcp   -d 192.168.1.1  --dport 22 -j DNAT --to-destination 192.168.1.10:22 "
    echo "-A PREROUTING -p tcp -m tcp   -d 192.168.2.1  --dport 22 -j DNAT --to-destination 192.168.1.10:22 "
    # 
    # Rule  3 (NAT)
    echo "-A PREROUTING  -s 192.168.1.0/24  -d ! 200.200.200.200  -j DNAT --to-destination 192.168.2.10 "
    echo "-A POSTROUTING -o eth2   -s 192.168.1.0/24  -d 192.168.2.10  -j SNAT --to-source 192.168.2.1 "
    #
    echo COMMIT


    ) | $IPTABLES_RESTORE; IPTABLES_RESTORE_RES=$?
    test $IPTABLES_RESTORE_RES != 0 && run_epilog_and_exit $IPTABLES_RESTORE_RES
}

ip_forward() {
    :
    
}

reset_all() {
    :
    reset_iptables_v4
}

block_action() {
    reset_all
}

stop_action() {
    reset_all
    $IPTABLES -P OUTPUT  ACCEPT
    $IPTABLES -P INPUT   ACCEPT
    $IPTABLES -P FORWARD ACCEPT
}

check_iptables() {
    IP_TABLES="$1"
    [ ! -e $IP_TABLES ] && return 151
    NF_TABLES=$(cat $IP_TABLES 2>/dev/null)
    [ -z "$NF_TABLES" ] && return 152
    return 0
}
status_action() {
    check_iptables "/proc/net/ip_tables_names"
    ret_ipv4=$?
    check_iptables "/proc/net/ip6_tables_names"
    ret_ipv6=$?
    [ $ret_ipv4 -eq 0 -o $ret_ipv6 -eq 0 ] && return 0
    [ $ret_ipv4 -eq 151 -o $ret_ipv6 -eq 151 ] && {
        echo "iptables modules are not loaded"
    }
    [ $ret_ipv4 -eq 152 -o $ret_ipv6 -eq 152 ] && {
        echo "Firewall is not configured"
    }
    exit 3
}

# See how we were called.
# For backwards compatibility missing argument is equivalent to 'start'

cmd=$1
test -z "$cmd" && {
    cmd="start"
}

case "$cmd" in
    start)
        log "Activating firewall script generated Sun Mar 18 21:16:30 2012 by vadim"
        check_tools
         prolog_commands 
        check_run_time_address_table_files
        
        load_modules "nat "
        configure_interfaces
        verify_interfaces
        
        
        
        script_body
        ip_forward
        epilog_commands
        RETVAL=$?
        ;;

    stop)
        stop_action
        RETVAL=$?
        ;;

    status)
        status_action
        RETVAL=$?
        ;;

    block)
        block_action
        RETVAL=$?
        ;;

    reload)
        $0 stop
        $0 start
        RETVAL=$?
        ;;

    interfaces)
        configure_interfaces
        RETVAL=$?
        ;;

    test_interfaces)
        FWBDEBUG="echo"
        configure_interfaces
        RETVAL=$?
        ;;



    *)
        echo "Usage $0 [start|stop|status|block|reload|interfaces|test_interfaces]"
        ;;

esac

exit $RETVAL