Changeset 27837


Ignore:
Timestamp:
2011-07-30T02:53:09+02:00 (7 years ago)
Author:
jow
Message:

[backfire] firewall: sync with trunk

Location:
branches/backfire/package/firewall
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • branches/backfire/package/firewall/Makefile

    r27197 r27837  
    1010 
    1111PKG_VERSION:=2 
    12 PKG_RELEASE:=26 
     12PKG_RELEASE:=33 
    1313 
    1414include $(INCLUDE_DIR)/package.mk 
  • branches/backfire/package/firewall/files/firewall.config

    r26962 r27837  
    99config zone 
    1010        option name             lan 
    11         option network  'lan' 
    12         option input    ACCEPT  
    13         option output   ACCEPT  
    14         option forward  REJECT 
     11        option network          'lan' 
     12        option input            ACCEPT  
     13        option output           ACCEPT  
     14        option forward          REJECT 
    1515 
    1616config zone 
    1717        option name             wan 
    18         option network  'wan' 
    19         option input    REJECT 
    20         option output   ACCEPT  
    21         option forward  REJECT 
     18        option network          'wan' 
     19        option input            REJECT 
     20        option output           ACCEPT  
     21        option forward          REJECT 
    2222        option masq             1  
    23         option mtu_fix  1 
     23        option mtu_fix          1 
    2424 
    2525config forwarding  
    26         option src      lan 
    27         option dest     wan 
     26        option src              lan 
     27        option dest             wan 
    2828 
    2929# We need to accept udp packets on port 68, 
     
    3434        option dest_port        68 
    3535        option target           ACCEPT 
    36         option family   ipv4 
     36        option family           ipv4 
    3737 
    38 #Allow ping 
     38# Allow IPv4 ping 
    3939config rule 
    40         option src wan 
    41         option proto icmp 
    42         option icmp_type echo-request 
    43         option target ACCEPT 
     40        option src              wan 
     41        option proto            icmp 
     42        option icmp_type        echo-request 
     43        option family           ipv4 
     44        option target           ACCEPT 
     45 
     46# Allow essential incoming IPv6 ICMP traffic 
     47config rule                                    
     48        option src              wan 
     49        option dest             * 
     50        option proto            icmp 
     51        list icmp_type          echo-request 
     52        list icmp_type          destination-unreachable 
     53        list icmp_type          packet-too-big 
     54        list icmp_type          time-exceeded 
     55        list icmp_type          bad-header 
     56        list icmp_type          unknown-header-type 
     57        option limit            1000/sec 
     58        option family           ipv6 
     59        option target           ACCEPT 
    4460 
    4561# include a file with users custom iptables rules 
  • branches/backfire/package/firewall/files/lib/core_interface.sh

    r26741 r27837  
    1 # Copyright (C) 2009-2010 OpenWrt.org 
     1# Copyright (C) 2009-2011 OpenWrt.org 
    22 
    33fw__uci_state_add() { 
     
    55        local item="$2" 
    66 
    7         local val=" $(uci_get_state firewall core $var) " 
    8         val="${val// $item / }" 
    9         val="${val# }" 
    10         val="${val% }" 
    11         uci_revert_state firewall core $var 
    12         uci_set_state firewall core $var "${val:+$val }$item" 
     7        local val="$(uci_get_state firewall core $var)" 
     8        local e1; for e1 in $item; do 
     9                local e2; for e2 in $val; do 
     10                        [ "$e1" = "$e2" ] && e1="" 
     11                done 
     12                val="${val:+$val${e1:+ }}$e1" 
     13        done 
     14 
     15        uci_toggle_state firewall core $var "$val" 
    1316} 
    1417 
     
    1720        local item="$2" 
    1821 
    19         local val=" $(uci_get_state firewall core $var) " 
    20         val="${val// $item / }" 
    21         val="${val# }" 
    22         val="${val% }" 
    23         uci_revert_state firewall core $var 
    24         uci_set_state firewall core $var "$val" 
     22        local rest="" 
     23        local val="$(uci_get_state firewall core $var)" 
     24        local e1; for e1 in $val; do 
     25                local e2; for e2 in $item; do 
     26                        [ "$e1" = "$e2" ] && e1="" 
     27                done 
     28                rest="${rest:+$rest${e1:+ }}$e1" 
     29        done 
     30 
     31        uci_toggle_state firewall core $var "$val" 
    2532} 
    2633 
     
    155162                fw_callback post interface 
    156163 
    157                 uci_set_state firewall core "${iface}_aliases" "$aliases" 
     164                uci_toggle_state firewall core "${iface}_aliases" "$aliases" 
    158165        } || { 
    159166                local subnets= 
     
    162169 
    163170                config_set core "${iface}_subnets" "$subnets" 
    164                 uci_set_state firewall core "${iface}_subnets" "$subnets" 
     171                uci_toggle_state firewall core "${iface}_subnets" "$subnets" 
    165172        } 
    166173 
     
    181188        config_foreach load_zone zone 
    182189 
    183         uci_set_state firewall core "${iface}_zone" "$new_zones" 
    184         uci_set_state firewall core "${iface}_ifname" "$ifname" 
     190        uci_toggle_state firewall core "${iface}_zone" "$new_zones" 
     191        uci_toggle_state firewall core "${iface}_ifname" "$ifname" 
    185192} 
    186193 
  • branches/backfire/package/firewall/files/lib/core_redirect.sh

    r23318 r27837  
    1414                string dest "" \ 
    1515                ipaddr dest_ip "" \ 
    16                 string dest_mac "" \ 
    1716                string dest_port "" \ 
    1817                string proto "tcpudp" \ 
    1918                string family "" \ 
    2019                string target "DNAT" \ 
     20                string extra "" \ 
    2121        } || return 
    2222        [ -n "$redirect_name" ] || redirect_name=$redirect__name 
     
    3030        local fwdchain natchain natopt nataddr natports srcdaddr srcdports 
    3131        if [ "$redirect_target" == "DNAT" ]; then 
    32                 [ -n "$redirect_src" -a -n "$redirect_dest_ip$redirect_dest_port" ] || { 
     32                [ -n "${redirect_src#*}" -a -n "$redirect_dest_ip$redirect_dest_port" ] || { 
    3333                        fw_log error "DNAT redirect ${redirect_name}: needs src and dest_ip or dest_port, skipping" 
    3434                        return 0 
    3535                } 
    3636 
    37                 fwdchain="zone_${redirect_src}_forward" 
     37                fwdchain="zone_${redirect_src}${redirect_dest_ip:+_forward}" 
    3838 
    3939                natopt="--to-destination" 
    4040                natchain="zone_${redirect_src}_prerouting" 
    4141                nataddr="$redirect_dest_ip" 
    42                 fw_get_port_range natports "$redirect_dest_port" "-" 
     42                fw_get_port_range natports "${redirect_dest_port#!}" "-" 
    4343 
    4444                fw_get_negation srcdaddr '-d' "${redirect_src_dip:+$redirect_src_dip/$redirect_src_dip_prefixlen}" 
    4545                fw_get_port_range srcdports "$redirect_src_dport" ":" 
     46                fw_get_negation srcdports '--dport' "$srcdports" 
    4647 
    4748                list_contains FW_CONNTRACK_ZONES $redirect_src || \ 
     
    4950 
    5051        elif [ "$redirect_target" == "SNAT" ]; then 
    51                 [ -n "$redirect_dest" -a -n "$redirect_src_dip" ] || { 
     52                [ -n "${redirect_dest#*}" -a -n "$redirect_src_dip" ] || { 
    5253                        fw_log error "SNAT redirect ${redirect_name}: needs dest and src_dip, skipping" 
    5354                        return 0 
     
    5960                natchain="zone_${redirect_dest}_nat" 
    6061                nataddr="$redirect_src_dip" 
    61                 fw_get_port_range natports "$redirect_src_dport" "-" 
     62                fw_get_port_range natports "${redirect_src_dport#!}" "-" 
    6263 
    6364                fw_get_negation srcdaddr '-d' "${redirect_dest_ip:+$redirect_dest_ip/$redirect_dest_ip_prefixlen}" 
    6465                fw_get_port_range srcdports "$redirect_dest_port" ":" 
     66                fw_get_negation srcdports '--dport' "$srcdports" 
    6567 
    6668                list_contains FW_CONNTRACK_ZONES $redirect_dest || \ 
     
    8082        local srcports 
    8183        fw_get_port_range srcports "$redirect_src_port" ":" 
     84        fw_get_negation srcports '--sport' "$srcports" 
    8285 
    8386        local destaddr 
     
    8689        local destports 
    8790        fw_get_port_range destports "${redirect_dest_port:-$redirect_src_dport}" ":" 
     91        fw_get_negation destports '--dport' "$destports" 
    8892 
    8993        [ "$redirect_proto" == "tcpudp" ] && redirect_proto="tcp udp" 
    90         for redirect_proto in $redirect_proto; do 
    91                 local pos 
    92                 eval 'pos=$((++FW__REDIR_COUNT_'${mode#G}'_'$natchain'))' 
     94        local pr; for pr in $redirect_proto; do 
     95                fw_get_negation pr '-p' "$pr" 
     96                local sm; for sm in ${redirect_src_mac:-""}; do 
     97                        fw_get_negation sm '--mac-source' "$sm" 
     98                        fw add $mode n $natchain $redirect_target + \ 
     99                                { $redirect_src_ip $redirect_dest_ip } { \ 
     100                                $srcaddr $srcdaddr $pr \ 
     101                                $srcports $srcdports \ 
     102                                ${sm:+-m mac $sm} \ 
     103                                $natopt $nataddr${natports:+:$natports} \ 
     104                                $redirect_options \ 
     105                        } 
    93106 
    94                 fw add $mode n $natchain $redirect_target $pos { $redirect_src_ip $redirect_dest_ip } { \ 
    95                         $srcaddr $srcdaddr \ 
    96                         ${redirect_proto:+-p $redirect_proto} \ 
    97                         ${srcports:+--sport $srcports} \ 
    98                         ${srcdports:+--dport $srcdports} \ 
    99                         ${redirect_src_mac:+-m mac --mac-source $redirect_src_mac} \ 
    100                         $natopt $nataddr${natports:+:$natports} \ 
    101                 } 
    102  
    103                 [ -n "$destaddr" ] && \ 
    104                 fw add $mode f ${fwdchain:-forward} ACCEPT ^ { $redirect_src_ip $redirect_dest_ip } { \ 
    105                         $srcaddr $destaddr \ 
    106                         ${redirect_proto:+-p $redirect_proto} \ 
    107                         ${srcports:+--sport $srcports} \ 
    108                         ${destports:+--dport $destports} \ 
    109                         ${redirect_src_mac:+-m mac --mac-source $redirect_src_mac} \ 
    110                 } 
     107                        fw add $mode f ${fwdchain:-forward} ACCEPT + \ 
     108                                { $redirect_src_ip $redirect_dest_ip } { \ 
     109                                $srcaddr ${destaddr:--m conntrack --ctstate DNAT} \ 
     110                                $pr \ 
     111                                $srcports $destports \ 
     112                                ${sm:+-m mac $sm} \ 
     113                                $redirect_extra \ 
     114                        } 
     115                done 
    111116        done 
    112117 
  • branches/backfire/package/firewall/files/lib/core_rule.sh

    r25179 r27837  
    1717                string target "" \ 
    1818                string family "" \ 
     19                string limit "" \ 
     20                string limit_burst "" \ 
     21                string extra "" \ 
    1922        } || return 
    2023        [ -n "$rule_name" ] || rule_name=$rule__name 
    21         [ "$rule_proto" == "icmp" ] || rule_icmp_type= 
    2224} 
    2325 
     
    2527        fw_config_get_rule "$1" 
    2628 
    27         [ "$rule_target" != "NOTRACK" ] || [ -n "$rule_src" ] || { 
     29        [ "$rule_target" != "NOTRACK" ] || [ -n "$rule_src" ] || [ "$rule_src" != "*" ] || { 
    2830                fw_log error "NOTRACK rule ${rule_name}: needs src, skipping" 
    2931                return 0 
     
    3133 
    3234        fw_callback pre rule 
    33  
    34         fw_get_port_range rule_src_port $rule_src_port 
    35         fw_get_port_range rule_dest_port $rule_dest_port 
    3635 
    3736        local table=f 
     
    4241                chain="zone_${rule_src}_notrack" 
    4342        else 
    44                 [ -n "$rule_src" ] && chain="zone_${rule_src}${rule_dest:+_forward}" 
    45                 [ -n "$rule_dest" ] && target="zone_${rule_dest}_${target}" 
     43                if [ -n "$rule_src" ]; then 
     44                        if [ "$rule_src" != "*" ]; then 
     45                                chain="zone_${rule_src}${rule_dest:+_forward}" 
     46                        else 
     47                                chain="${rule_dest:+forward}" 
     48                                chain="${chain:-input}" 
     49                        fi 
     50                fi 
     51 
     52                if [ -n "$rule_dest" ]; then 
     53                        if [ "$rule_dest" != "*" ]; then 
     54                                target="zone_${rule_dest}_${target}" 
     55                        elif [ "$target" = REJECT ]; then 
     56                                target=reject 
     57                        fi 
     58                fi 
    4659        fi 
    4760 
     
    5467 
    5568        [ "$rule_proto" == "tcpudp" ] && rule_proto="tcp udp" 
    56         for rule_proto in $rule_proto; do 
    57                 local rule_pos 
    58                 eval 'rule_pos=$((++FW__RULE_COUNT_'${mode#G}'_'$chain'))' 
    59  
    60                 fw add $mode $table $chain $target $rule_pos { $rule_src_ip $rule_dest_ip } { \ 
    61                         $src_spec $dest_spec \ 
    62                         ${rule_proto:+-p $rule_proto} \ 
    63                         ${rule_src_port:+--sport $rule_src_port} \ 
    64                         ${rule_src_mac:+-m mac --mac-source $rule_src_mac} \ 
    65                         ${rule_dest_port:+--dport $rule_dest_port} \ 
    66                         ${rule_icmp_type:+--icmp-type $rule_icmp_type} \ 
    67                 } 
     69        local pr; for pr in $rule_proto; do 
     70                local sports dports itypes 
     71                case "$pr" in 
     72                        icmp|icmpv6|1|58) 
     73                                sports=""; dports="" 
     74                                itypes="$rule_icmp_type" 
     75                        ;; 
     76                        *) 
     77                                sports="$rule_src_port" 
     78                                dports="$rule_dest_port" 
     79                                itypes="" 
     80                        ;; 
     81                esac 
     82         
     83                fw_get_negation pr '-p' "$pr" 
     84                local sp; for sp in ${sports:-""}; do 
     85                        fw_get_port_range sp $sp 
     86                        fw_get_negation sp '--sport' "$sp" 
     87                        local dp; for dp in ${dports:-""}; do 
     88                                fw_get_port_range dp $dp 
     89                                fw_get_negation dp '--dport' "$dp" 
     90                                local sm; for sm in ${rule_src_mac:-""}; do 
     91                                        fw_get_negation sm '--mac-source' "$sm" 
     92                                        local it; for it in ${itypes:-""}; do 
     93                                                fw_get_negation it '--icmp-type' "$it" 
     94                                                fw add $mode $table $chain $target + \ 
     95                                                        { $rule_src_ip $rule_dest_ip } { \ 
     96                                                        $src_spec $dest_spec \ 
     97                                                        $pr $sp $dp $it \ 
     98                                                        ${sm:+-m mac $sm} \ 
     99                                                        ${rule_limit:+-m limit --limit $rule_limit \ 
     100                                                                ${rule_limit_burst:+--limit-burst $rule_limit_burst}} \ 
     101                                                        $rule_extra \ 
     102                                                } 
     103                                        done 
     104                                done 
     105                        done 
     106                done 
    68107        done 
    69108 
  • branches/backfire/package/firewall/files/lib/fw.sh

    r27199 r27837  
    138138                -) tgt= ;; 
    139139        esac 
     140 
     141        local rule_offset 
    140142        case "$pos" in 
    141143                ^) pos=1 ;; 
    142144                $) pos= ;; 
    143145                -) pos= ;; 
     146                +) eval "rule_offset=\${FW__RULE_OFS_${app}_${tab}_${chn}:-1}" ;; 
    144147        esac 
    145148 
     
    160163        fi 
    161164 
    162         local cmdline="$app --table ${tab} --${cmd} ${chn} ${pol} ${pos} ${tgt:+--jump "$tgt"}" 
     165        local cmdline="$app --table ${tab} --${cmd} ${chn} ${pol} ${rule_offset:-${pos}} ${tgt:+--jump "$tgt"}" 
    163166        while [ $# -gt 1 ]; do 
    164                 case "$app:$1" in 
    165                         ip6tables:--icmp-type) cmdline="$cmdline --icmpv6-type" ;; 
    166                         ip6tables:icmp|ip6tables:ICMP) cmdline="$cmdline icmpv6" ;; 
    167                         iptables:--icmpv6-type) cmdline="$cmdline --icmp-type" ;; 
    168                         iptables:icmpv6) cmdline="$cmdline icmp" ;; 
     167                # special parameter handling 
     168                case "$1:$2" in 
     169                        -p:icmp*|-p:1|-p:58|--protocol:icmp*|--protocol:1|--protocol:58) 
     170                                [ "$app" = ip6tables ] && \ 
     171                                        cmdline="$cmdline -p icmpv6" || \ 
     172                                        cmdline="$cmdline -p icmp" 
     173                                shift 
     174                        ;; 
     175                        --icmp-type:*|--icmpv6-type:*) 
     176                                local icmp_type 
     177                                if [ "$app" = ip6tables ] && fw_check_icmptype6 icmp_type "$2"; then 
     178                                        cmdline="$cmdline $icmp_type" 
     179                                elif [ "$app" = iptables ] && fw_check_icmptype4 icmp_type "$2"; then 
     180                                        cmdline="$cmdline $icmp_type" 
     181                                else 
     182                                        local fam=IPv4; [ "$app" = ip6tables ] && fam=IPv6 
     183                                        fw_log info "ICMP type '$2' is not valid for $fam address family, skipping rule" 
     184                                        return 1 
     185                                fi 
     186                                shift    
     187                        ;; 
    169188                        *) cmdline="$cmdline $1" ;; 
    170189                esac 
     
    176195        $cmdline 
    177196 
    178         fw__rc $? 
     197        local rv=$? 
     198        [ $rv -eq 0 ] && [ -n "$rule_offset" ] && \ 
     199                export -- "FW__RULE_OFS_${app}_${tab}_${chn}=$(($rule_offset + 1))" 
     200        fw__rc $rv 
    179201} 
    180202 
     
    190212        local _first=${_ports%-*} 
    191213        local _last=${_ports#*-} 
    192         if [ "$_first" != "$_last" ]; then 
    193                 export -- "$_var=$_first$_delim$_last" 
     214        if [ "${_first#!}" != "${_last#!}" ]; then 
     215                export -- "$_var=$_first$_delim${_last#!}" 
    194216        else 
    195217                export -- "$_var=$_first" 
     
    222244        local _var="$1" 
    223245        local _flag="$2" 
    224         local _ipaddr="$3" 
    225  
    226         [ "${_ipaddr#!}" != "$_ipaddr" ] && \ 
    227                 export -n -- "$_var=! $_flag ${_ipaddr#!}" || \ 
    228                 export -n -- "$_var=${_ipaddr:+$_flag $_ipaddr}" 
     246        local _value="$3" 
     247 
     248        [ "${_value#!}" != "$_value" ] && \ 
     249                export -n -- "$_var=! $_flag ${_value#!}" || \ 
     250                export -n -- "$_var=${_value:+$_flag $_value}" 
    229251} 
    230252 
     
    246268        esac 
    247269} 
     270 
     271fw_check_icmptype4() { 
     272        local _var="$1" 
     273        local _type="$2" 
     274        case "$_type" in 
     275                ![0-9]*) export -n -- "$_var=! --icmp-type ${_type#!}"; return 0 ;; 
     276                [0-9]*)  export -n -- "$_var=--icmp-type $_type";       return 0 ;; 
     277        esac 
     278 
     279        [ -z "$FW_ICMP4_TYPES" ] && \ 
     280                export FW_ICMP4_TYPES=$( 
     281                        iptables -p icmp -h 2>/dev/null | \ 
     282                        sed -n -e '/^Valid ICMP Types:/ { 
     283                                n; :r; 
     284                                /router-advertisement/d; 
     285                                /router-solicitation/d; 
     286                                s/[()]/ /g; s/[[:space:]]\+/\n/g; p; n; b r 
     287                        }' | sort -u 
     288                ) 
     289 
     290        local _check 
     291        for _check in $FW_ICMP4_TYPES; do 
     292                if [ "$_check" = "${_type#!}" ]; then 
     293                        [ "${_type#!}" != "$_type" ] && \ 
     294                                export -n -- "$_var=! --icmp-type ${_type#!}" || \ 
     295                                export -n -- "$_var=--icmp-type $_type" 
     296                        return 0 
     297                fi 
     298        done 
     299 
     300        export -n -- "$_var=" 
     301        return 1 
     302} 
     303 
     304fw_check_icmptype6() { 
     305        local _var="$1" 
     306        local _type="$2" 
     307        case "$_type" in 
     308                ![0-9]*) export -n -- "$_var=! --icmpv6-type ${_type#!}"; return 0 ;; 
     309                [0-9]*)  export -n -- "$_var=--icmpv6-type $_type";       return 0 ;; 
     310        esac 
     311 
     312        [ -z "$FW_ICMP6_TYPES" ] && \ 
     313                export FW_ICMP6_TYPES=$( 
     314                        ip6tables -p icmpv6 -h 2>/dev/null | \ 
     315                        sed -n -e '/^Valid ICMPv6 Types:/ { 
     316                                n; :r; s/[()]/ /g; s/[[:space:]]\+/\n/g; p; n; b r 
     317                        }' | sort -u 
     318                ) 
     319 
     320        local _check 
     321        for _check in $FW_ICMP6_TYPES; do 
     322                if [ "$_check" = "${_type#!}" ]; then 
     323                        [ "${_type#!}" != "$_type" ] && \ 
     324                                export -n -- "$_var=! --icmpv6-type ${_type#!}" || \ 
     325                                export -n -- "$_var=--icmpv6-type $_type" 
     326                        return 0 
     327                fi 
     328        done 
     329 
     330        export -n -- "$_var=" 
     331        return 1 
     332} 
  • branches/backfire/package/firewall/files/reflection.hotplug

    r23201 r27837  
    5757                        local dest 
    5858                        config_get dest "$cfg" dest "lan" 
     59                        [ "$dest" != "*" ] || return 
    5960 
    6061                        local net 
     
    7172 
    7273                                epmin="${extport%[-:]*}"; epmax="${extport#*[-:]}" 
    73                                 [ "$epmin" != "$epmax" ] || epmax="" 
     74                                [ "${epmin#!}" != "$epmax" ] || epmax="" 
    7475 
    7576                                local ipmin ipmax intport 
     
    7778 
    7879                                ipmin="${intport%[-:]*}"; ipmax="${intport#*[-:]}" 
    79                                 [ "$ipmin" != "$ipmax" ] || ipmax="" 
     80                                [ "${ipmin#!}" != "$ipmax" ] || ipmax="" 
    8081 
    8182                                local exthost 
     
    9192                                [ "${exthost#!}" = "$exthost" ] || return 0 
    9293 
     94                                [ "${epmin#!}" != "$epmin" ] && \ 
     95                                        extport="! --dport ${epmin#!}${epmax:+:$epmax}" || \ 
     96                                        extport="--dport $epmin${epmax:+:$epmax}" 
     97 
     98                                [ "${ipmin#!}" != "$ipmin" ] && \ 
     99                                        intport="! --dport ${ipmin#!}${ipmax:+:$ipmax}" || \ 
     100                                        intport="--dport $ipmin${ipmax:+:$ipmax}" 
     101 
    93102                                local p 
    94103                                for p in ${proto:-tcp udp}; do 
     
    97106                                                        iptables -t nat -A nat_reflection_in \ 
    98107                                                                -s $lanip/$lanmk -d $exthost \ 
    99                                                                 -p $p --dport $epmin${epmax:+:$epmax} \ 
    100                                                                 -j DNAT --to $inthost:$ipmin${ipmax:+-$ipmax} 
     108                                                                -p $p $extport \ 
     109                                                                -j DNAT --to $inthost:${ipmin#!}${ipmax:+-$ipmax} 
    101110 
    102111                                                        iptables -t nat -A nat_reflection_out \ 
    103112                                                                -s $lanip/$lanmk -d $inthost \ 
    104                                                                 -p $p --dport $ipmin${ipmax:+:$ipmax} \ 
     113                                                                -p $p $intport \ 
    105114                                                                -j SNAT --to-source $lanip 
    106115 
    107116                                                        iptables -t filter -A nat_reflection_fwd \ 
    108117                                                                -s $lanip/$lanmk -d $inthost \ 
    109                                                                 -p $p --dport $ipmin${ipmax:+:$ipmax} \ 
     118                                                                -p $p $intport \ 
    110119                                                                -j ACCEPT 
    111120                                                ;; 
Note: See TracChangeset for help on using the changeset viewer.