← Back to branch summary

~ubuntu-branches/debian/sid/shorewall/sid

« back to all changes in this revision

Viewing changes to Perl/Shorewall/IPAddrs.pm

  • Committer: Package Import Robot
  • Author(s): Roberto C. Sanchez
  • Date: 2013-05-03 08:17:42 UTC
  • mfrom: (1.3.52)
  • Revision ID: package-import@ubuntu.com-20130503081742-qo8p6k2z0dnbfqo8
Tags: 4.5.16.1-1
* New Upstream Version
* debian/patches/01_debian_configuration.patch: Refreshed
* debian/patches/02_correct_dnat_snat_behavior.patch: Removed
* Update lintian overrides

Show diffs side-by-side

added added

removed removed

Lines of Context:
Perl/Shorewall/IPAddrs.pm
26
26
#
27
27
package Shorewall::IPAddrs;
28
28
require Exporter;
29
 
use Shorewall::Config qw( :DEFAULT split_list require_capability in_hex8 numeric_value F_IPV4 F_IPV6 );
 
29
use Shorewall::Config qw( :DEFAULT split_list require_capability in_hex8 numeric_value F_IPV4 F_IPV6 :protocols %config );
30
30
use Socket;
31
31
 
32
32
use strict;
33
33
 
34
34
our @ISA = qw(Exporter);
35
 
our @EXPORT = qw( ALLIPv4
 
35
our @EXPORT = ( qw( ALLIPv4
36
36
                  ALLIPv6
37
37
                  NILIPv4
38
38
                  NILIPv6
48
48
                  ALLIP
49
49
                  NILIP
50
50
                  ALL
51
 
                  TCP
52
 
                  UDP
53
 
                  UDPLITE
54
 
                  ICMP
55
 
                  DCCP
56
 
                  IPv6_ICMP
57
 
                  SCTP
58
 
                  GRE
 
51
                  VLSMv4
 
52
                  VLSMv6
 
53
                  VLSM
59
54
 
 
55
                  valid_address
60
56
                  validate_address
61
57
                  validate_net
62
58
                  decompose_net
73
69
                  nilip
74
70
                  rfc1918_networks
75
71
                  resolve_proto
 
72
                  resolve_dnsname
76
73
                  proto_name
77
74
                  validate_port
78
75
                  validate_portpair
80
77
                  validate_port_list
81
78
                  validate_icmp
82
79
                  validate_icmp6
83
 
                 );
 
80
                 ) );
84
81
our @EXPORT_OK = qw( );
85
 
our $VERSION = '4.4_2';
 
82
our $VERSION = '4.5_15';
86
83
 
87
84
#
88
85
# Some IPv4/6 useful stuff
89
86
#
90
 
my @allipv4 = ( '0.0.0.0/0' );
91
 
my @allipv6 = ( '::/0' );
92
 
my $allip;
93
 
my @allip;
94
 
my @nilipv4 = ( '0.0.0.0' );
95
 
my @nilipv6 = ( '::' );
96
 
my $nilip;
97
 
my @nilip;
98
 
my $valid_address;
99
 
my $validate_address;
100
 
my $validate_net;
101
 
my $validate_range;
102
 
my $validate_host;
103
 
my $family;
 
87
our @allipv4 = ( '0.0.0.0/0' );
 
88
our @allipv6 = ( '::/0' );
 
89
our $allip;
 
90
our @allip;
 
91
our @nilipv4 = ( '0.0.0.0' );
 
92
our @nilipv6 = ( '::' );
 
93
our $nilip;
 
94
our @nilip;
 
95
our $vlsm_width;
 
96
our $valid_address;
 
97
our $validate_address;
 
98
our $validate_net;
 
99
our $resolve_dnsname;
 
100
our $validate_range;
 
101
our $validate_host;
 
102
our $family;
104
103
 
105
104
use constant { ALLIPv4             => '0.0.0.0/0' ,
106
105
               ALLIPv6             => '::/0' ,
115
114
               IPv6_LINK_ALLRTRS   => 'ff01::2' ,
116
115
               IPv6_SITE_ALLNODES  => 'ff02::1' ,
117
116
               IPv6_SITE_ALLRTRS   => 'ff02::2' ,
118
 
               ICMP                => 1,
119
 
               TCP                 => 6,
120
 
               UDP                 => 17,
121
 
               DCCP                => 33,
122
 
               GRE                 => 47,
123
 
               IPv6_ICMP           => 58,
124
 
               SCTP                => 132,
125
 
               UDPLITE             => 136 };
 
117
               VLSMv4              => 32,
 
118
               VLSMv6              => 128,
 
119
           };
126
120
 
127
 
my @rfc1918_networks = ( "10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16" );
 
121
our @rfc1918_networks = ( "10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16" );
128
122
 
129
123
#
130
124
# Note: initialize() is declared at the bottom of the file
132
126
sub vlsm_to_mask( $ ) {
133
127
    my $vlsm = $_[0];
134
128
 
135
 
    in_hex8 ( ( 0xFFFFFFFF << ( 32 - $vlsm ) ) & 0xFFFFFFFF );
 
129
    in_hex8 ( ( 0xFFFFFFFF << ( VLSMv4 - $vlsm ) ) & 0xFFFFFFFF );
136
130
}
137
131
 
138
132
sub valid_4address( $ ) {
167
161
    defined wantarray ? wantarray ? @addrs : $addrs[0] : undef;
168
162
}
169
163
 
 
164
sub resolve_4dnsname( $ ) {
 
165
    my $net = $_[0];
 
166
    my @addrs;
 
167
 
 
168
    fatal_error "Unknown Host ($net)" unless  @addrs = gethostbyname( $net );
 
169
 
 
170
    shift @addrs for (1..4);
 
171
    for ( @addrs ) {
 
172
        $_ = ( inet_ntoa( $_ ) );
 
173
    }
 
174
 
 
175
    @addrs;
 
176
} 
 
177
    
 
178
 
170
179
sub decodeaddr( $ ) {
171
180
    my $address = $_[0];
172
181
 
212
221
    }
213
222
 
214
223
    if ( defined $vlsm ) {
215
 
        fatal_error "Invalid VLSM ($vlsm)"            unless $vlsm =~ /^\d+$/ && $vlsm <= 32;
 
224
        fatal_error "Invalid VLSM ($vlsm)"            unless $vlsm =~ /^\d+$/ && $vlsm <= VLSMv4;
216
225
        fatal_error "Invalid Network address ($_[0])" if defined $rest;
217
226
        fatal_error "Invalid IP address ($net)"       unless valid_4address $net;
218
227
    } else {
219
228
        fatal_error "Invalid Network address ($_[0])" if $_[0] =~ '/' || ! defined $net;
220
 
        validate_4address $net, $_[1];
221
 
        $vlsm = 32;
 
229
        my $net1 = validate_4address $net, $allow_name;
 
230
        $net  = $net1 unless $config{DEFER_DNS_RESOLUTION};
 
231
        $vlsm = VLSMv4;
222
232
    }
223
233
 
224
234
    if ( defined wantarray ) {
225
 
        assert ( ! $allow_name );
226
235
        if ( wantarray ) {
 
236
            assert( ! $allow_name );
227
237
            ( decodeaddr( $net ) , $vlsm );
 
238
        } elsif ( valid_4address $net ) {
 
239
            $vlsm == VLSMv4 ? $net : "$net/$vlsm";
228
240
        } else {
229
 
            "$net/$vlsm";
 
241
            $net;
230
242
        }
231
243
    }
232
244
}
241
253
    my $last  = decodeaddr $high;
242
254
 
243
255
    fatal_error "Invalid IP Range ($low-$high)" unless $first <= $last;
 
256
 
 
257
    "$low-$high";
244
258
}
245
259
 
246
260
sub validate_4host( $$ ) {
335
349
        $number = numeric_value ( $proto );
336
350
        defined $number && $number <= 255 ? $number : undef;
337
351
    } else {
 
352
        fatal_error "A protocol list  ($proto) is not allowed in this context" if $proto =~ /,/; 
338
353
        #
339
354
        # Allow 'icmp' as a synonym for 'ipv6-icmp' in IPv6 compilations
340
355
        #
392
407
        $what = 'port';
393
408
    }
394
409
 
395
 
    fatal_error "Using a $what ( $portpair ) requires PROTO TCP, UDP, SCTP or DCCP" unless
396
 
        defined $protonum && ( $protonum == TCP  ||
397
 
                               $protonum == UDP  ||
398
 
                               $protonum == SCTP ||
 
410
    fatal_error "Using a $what ( $portpair ) requires PROTO TCP, UDP, UDPLITE, SCTP or DCCP" unless
 
411
        defined $protonum && ( $protonum == TCP     ||
 
412
                               $protonum == UDP     ||
 
413
                               $protonum == UDPLITE ||
 
414
                               $protonum == SCTP    ||
399
415
                               $protonum == DCCP );
400
416
    join ':', @ports;
401
417
 
621
637
    defined wantarray ? wantarray ? @addrs : $addrs[0] : undef;
622
638
}
623
639
 
 
640
sub resolve_6dnsname( $ ) {
 
641
    my $net = $_[0];
 
642
    my @addrs;
 
643
    
 
644
    require Socket6;
 
645
    fatal_error "Unknown Host ($net)" unless (@addrs = Socket6::gethostbyname2( $net, Socket6::AF_INET6()));
 
646
 
 
647
    shift @addrs for (1..4);
 
648
    for ( @addrs ) {
 
649
        $_ = Socket6::inet_ntop( Socket6::AF_INET6(), $_ );
 
650
    }
 
651
 
 
652
    @addrs;
 
653
} 
 
654
 
624
655
sub validate_6net( $$ ) {
625
 
    my ($net, $vlsm, $rest) = split( '/', $_[0], 3 );
626
 
    my $allow_name = $_[1];
 
656
    my ( $net, $allow_name ) = @_;
 
657
 
 
658
    if ( $net =~ /^\[(.+)]$/ ) {
 
659
        $net = $1;
 
660
    } elsif ( $net =~ /^\[(.+)\]\/(\d+)$/ ) {
 
661
        $net = join( '/', $1, $2 );
 
662
    }
 
663
 
 
664
    fatal_error "Invalid Network Address($net)" if $net =~ /\[/;
 
665
 
 
666
    ($net, my $vlsm, my $rest) = split( '/', $net, 3 );
 
667
 
 
668
    fatal_error 'Invalid Network Address(' . join( '/', $net, $vlsm, $rest ) if defined $rest;
627
669
 
628
670
    if ( $net =~ /\+(\[?)/ ) {
629
671
        if ( $1 ) {
635
677
        }
636
678
    }
637
679
 
 
680
    fatal_error "Invalid Network address ($_[0])" unless supplied $net;
 
681
 
 
682
 
638
683
    if ( defined $vlsm ) {
639
 
        fatal_error "Invalid VLSM ($vlsm)"              unless $vlsm =~ /^\d+$/ && $vlsm <= 128;
 
684
        fatal_error "Invalid VLSM ($vlsm)"              unless $vlsm =~ /^\d+$/ && $vlsm <= VLSMv6;
640
685
        fatal_error "Invalid Network address ($_[0])"   if defined $rest;
641
686
        fatal_error "Invalid IPv6 address ($net)"       unless valid_6address $net;
642
687
    } else {
643
 
        fatal_error "Invalid Network address ($_[0])" if $_[0] =~ '/' || ! defined $net;
644
 
        validate_6address $net, $allow_name;
645
 
        $vlsm = 128;
 
688
        fatal_error "Invalid Network address ($_[0])" if $_[0] =~ '/';
 
689
        my $net1 = validate_6address $net, $allow_name;
 
690
        $net  = $net1 unless $config{DEFER_DNS_RESOLUTION};
 
691
        $vlsm = VLSMv6;
646
692
    }
647
693
 
648
694
    if ( defined wantarray ) {
649
 
        assert ( ! $allow_name );
650
695
        if ( wantarray ) {
 
696
            assert( ! $allow_name );
651
697
            ( $net , $vlsm );
 
698
        } elsif ( valid_6address ( $net ) ) {
 
699
            $vlsm == VLSMv6 ? $net : "$net/$vlsm";
652
700
        } else {
653
 
            "$net/$vlsm";
 
701
            $net;
654
702
        }
655
703
    }
656
704
}
697
745
    while ( @low ) {
698
746
        my ( $l, $h) = ( shift @low, shift @high );
699
747
        next     if hex "0x$l" == hex "0x$h";
700
 
        return 1 if hex "0x$l"  < hex "0x$h";
 
748
        return "$low-$high" if hex "0x$l"  < hex "0x$h";
701
749
        last;
702
750
    }
703
751
 
704
752
    fatal_error "Invalid IPv6 Range ($low-$high)";
 
753
 
 
754
    
705
755
}
706
756
 
707
757
sub validate_6host( $$ ) {
768
818
    @nilip;
769
819
}
770
820
 
 
821
sub VLSM() {
 
822
    $vlsm_width;
 
823
}
 
824
 
771
825
sub valid_address ( $ ) {
772
826
    $valid_address->(@_);
773
827
}
780
834
    $validate_net->(@_);
781
835
}
782
836
 
 
837
sub resolve_dnsname( $ ) {
 
838
    $resolve_dnsname->(@_);
 
839
}
 
840
 
783
841
sub validate_range ($$ ) {
784
842
    $validate_range->(@_);
785
843
}
806
864
        @allip            = @allipv4;
807
865
        $nilip            = NILIPv4;
808
866
        @nilip            = @nilipv4;
 
867
        $vlsm_width       = VLSMv4;
809
868
        $valid_address    = \&valid_4address;
810
869
        $validate_address = \&validate_4address;
811
870
        $validate_net     = \&validate_4net;
812
871
        $validate_range   = \&validate_4range;
813
872
        $validate_host    = \&validate_4host;
 
873
        $resolve_dnsname  = \&resolve_4dnsname;
814
874
    } else {
815
875
        $allip            = ALLIPv6;
816
876
        @allip            = @allipv6;
817
877
        $nilip            = NILIPv6;
818
878
        @nilip            = @nilipv6;
 
879
        $vlsm_width       = VLSMv6;
819
880
        $valid_address    = \&valid_6address;
820
881
        $validate_address = \&validate_6address;
821
882
        $validate_net     = \&validate_6net;
822
883
        $validate_range   = \&validate_6range;
823
884
        $validate_host    = \&validate_6host;
 
885
        $resolve_dnsname  = \&resolve_6dnsname;
824
886
    }
825
887
}
826
888