Image

head

code

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

Net::Netmask - Parse, manipulate and lookup IPv4 network blocks


=begin code :lang<raku>

use Net::Netmask;

my $net = Net::Netmask.new('192.168.75.8/29');

say $net.desc;        # 192.168.75.8/29 (same as ~$net or $net.Str)
say $net.base;        # 192.168.75.8
say $net.mask;        # 255.255.255.248

say $net.broadcast;   # 192.168.75.15
say $net.hostmask;    # 0.0.0.7

say $net.bits;        # 29
say $net.size;        # 8

if $net.match('192.168.75.10') -> $pos {
    say "$peer is in $net and is at index $pos.";
}

# Enumerate subnet
for $net.enumerate -> $ip {
    say $ip;
}

# Split subnet into smaller blocks
for $net.enumerate(:30bit :nets) -> $addr {
    say $addr;
}

=end code


C<Net::Netmask> parses and understands IPv4 and IPv6 CIDR blocks. The interface
is inspired by the Perl module of the same name.


Not all methods support IPv6 yet.  The IPv6 interface is subject to change and
should be considered experimental.


This module does not have full method parity with it's Perl cousin. Pull
requests are welcome.


C<Net::Netmask> objects are created with an IP address and mask.


Currently, the following forms are recognized


=begin code :lang<raku>

# CIDR notation (1 positional arg)
Net::Netmask.new('192.168.75.8/29');

# Address and netmask (1 positional arg)
Net::Netmask.new('192.168.75.8 255.255.255.248');

# Address and netmask (2 positional args)
Net::Netmask.new('192.168.75.8', '255.255.255.248');

# Named arguments
Net::Netmask.new( :address('192.168.75.8') :netmask('255.255.255.248') );

=end code


Using a 'hostmask' (aka, 'wildcard mask') in place of the netmask will also work.


If you create a C<Net::Netmask> object from one of the host addresses in the subnet, it will still work


=begin code :lang<raku>

my $net = Net::Netmask.new('192.168.75.10/29');
say $net.desc;    # 192.168.75.8/29

=end code


IPv4 Addresses are validated against the following subset


=begin code :lang<raku>

token octet   { (\d+) <?{ $0 <= 255 }>  }
regex address { <octet> ** 4 % '.'      }
subset IPv4 of Str where /<address>/;

=end code


Returns the first address of the network block, aka the network address.


Returns the subnet mask in dotted-quad notation.


Returns the inverse of the netmask, aka wildcard mask.


Returns the last address of the network block, aka the broadcast address.


Returns the number of bits in the network portion of the netmask, which is the same number that appears at the end of a network written in CIDR notation.


=begin code :lang<raku>

say Net::Netmask.new('192.168.0.0', '255.255.255.0').bits;   # 24
say Net::Netmask.new('192.168.0.0', '255.255.255.252').bits; # 30

=end code


Returns the number of IP address in the block


=begin code :lang<raku>

say Net::Netmask.new('192.168.0.0', '255.255.255.0').size;   # 256
say Net::Netmask.new('192.168.0.0', '255.255.255.252').size; # 4

=end code


=begin code :lang<raku>

method match(IPv4 $ip)

=end code


Given a valid IPv4 address, returns a true value if the address is contained within the subnet. That is to say, it will return the addresses index in the subnet.


=begin code :lang<raku>

my $net = Net::Netmask.new('192.168.0.0/24');
if $net.match('192.168.0.0') -> $pos {
    say "IP is at index $pos.";
}

=end code


In the above example, C<match> returns C<0 but True>, so even if you are matching on the network address (at position C<0>) it still evaluates as C<True>. If the address is not in the subnet, it will return C<False>.


You could also build a ridumentary blacklist (or whitelist) checker out of an array of C<Net::Netmask> objects.


=begin code :lang<raku>

my @blacklist = map { Net::Netmask.new($_) },
  < 10.0.0.0/8 172.16.0.0/12 192.168.0.0/16 >;

my $host = '192.168.0.15';
if ( any @blacklist».match($host) ) {
    say "$host is blacklisted";
}

=end code


=begin code :lang<raku>

method enumerate(Int :$bit = 32, Bool :$nets)

=end code


Returns a lazy list of the IP addresses in that subnet. By default, it enumerates over all the 32-bit subnets (ie. single addresses) in the subnet, but by providing an optional named C<Int> argument C<:$bit> , you can split the subnet into smaller blocks


=begin code :lang<raku>

my $net = Net::Netmask.new('192.168.75.8/29');

say $net.enumerate(:30bit);
# OUTPUT: (192.168.75.8 192.168.75.12)

=end code


Additionally, you can also pass an optional named C<Bool> argument C<:$nets>, which will return C<Net::Netmask> objects instead of C<Str>s.


=begin code :lang<raku>

my $net = Net::Netmask.new('192.168.75.8/29');

say $net.enumerate(:30bit :nets).map( *.desc );
# OUTPUT: (192.168.75.8/30 192.168.75.12/30)

=end code



class Net::Netmask:ver<0.2.1>:auth<zef:elcaro> {

    has Int @.address;
    has Int @.netmask;
    has Int $!start;
    has Int $!end;

    #based on http://rosettacode.org/wiki/Parse_an_IP_Address#Raku
    grammar IP_Addr {
        token TOP { ^ [ <IPv4> | <IPv6> ] $ } #allow IPv6 Parsing needs more work to be done
        #token TOP { ^ <IPv4> $ }

        token IPv4 { <ipv4> [ <CIDRv4> | <ipv4mask> ]? }

        token ipv4 {
            [ <d8> +% '.' ] <?{ $<d8> == 4 }>
            { make @$<d8> }
        }

        token ipv4mask {
            \s* [ <d8> +% '.' ] <?{ $<d8> == 4 and ((@$<d8>)».fmt("%08b").join ~~ /^1*0*$/)}>
            { make @$<d8> }
        }

        token CIDRv4 {
            '/' <n5> { my $n = 2**32-1+<(32-$<n5>); make (0x18,0x10...0x0).map({ $n +> $_}) »%» 0x100 }
        }

        token IPv6 {
                 <ipv6> [ <CIDRv6> ]?
        }

        token ipv6 {
            | <h16> +% ':' <?{ $<h16> == 8 }>
            { make @$<h16>.map({.Str.parse-base(16)}) }

            | [ (<h16>) +% ':']? '::' [ (<h16>) +% ':' ]? <?{ @$0 + @$1 <= 8 }>
            { make (|@$0, |( '0' xx 8 - (@$0 + @$1)), |@$1).map({.Str.parse-base(16)}) }

            | :i['::ffff:' | '0:0:0:0:0:ffff:'] <IPv4>
            { make (|(0 xx 5), 0xff , 0xff, by8to16 @$<IPv4>) }
        }

        token CIDRv6 {
            '/' <n7> { my $n = 2**128-1+<(128-$<n7>); make (0x70,0x60...0x0).map({ $n +> $_}) »%» 0x10000 }
        }

        token d8  { (\d+) <?{ $0 < 256   }> }
        token n5  { (\d+) <?{ $0 <= 32    }> }
        token n7  { (\d+) <?{ $0 <= 128   }> }
        token h16 { (<:hexdigit> ** {1..4})  }
    }


    our subset IPv4     of Str   where { IP_Addr.subparse: $_, :rule<ipv4>     };
    our subset IPv4mask of Str   where { IP_Addr.subparse: $_, :rule<ipv4mask> };
    our subset IPv4arr  of Array where { .elems == 4 };
    our subset IPv6     of Str   where { IP_Addr.subparse: $_, :rule<ipv6>     };
    our subset IPv6arr  of Array where { .elems == 8 };
    our subset IParr    of Array where { $_ ~~ IPv4arr || $_ ~~ IPv6arr };


    multi method new(IPv4 $ip){
        my $match = IP_Addr.parse($ip)<IPv4> or die 'failed to parse ' ~ $ip.gist;
        my @netmask = 255 xx 4;
        if $match<ipv4mask> { @netmask = $match<ipv4mask>.made>>.Int }
        if $match<CIDRv4>   { @netmask = $match<CIDRv4>.made>>.Int   }
        my @address = $match<ipv4>.made>>.Int;
        self.bless :@address :@netmask;
    }

    multi method new(IPv6 $ip){
        my $match = IP_Addr.parse($ip)<IPv6> or die 'failed to parse ' ~ $ip.gist;
        my @netmask = 0xFFFF xx 8;
        if $match<CIDRv6>   { @netmask = $match<CIDRv6>.made>>.Int   }
        my @address = $match<ipv6>.made>>.Int;
        self.bless :@address :@netmask;
    }

    multi method new(IPv4 $address, IPv4mask $netmask) {
        self.bless :address(ip2arr($address)) :netmask(ipmask2arr($netmask));
    }

    multi method new(IPv4 :$address, IPv4mask :$netmask) {
        self.bless :address(ip2arr($address)) :netmask(ipmask2arr($netmask));
    }

    submethod BUILD(:@address where {$_ ~~ IParr}, :@netmask where {$_ ~~ IParr}) {
        given @address {
            when IPv4arr  {
                @!netmask = @netmask;
                $!start = ( [Z+&] (@address, @!netmask)).join('.').&ip2dec;
                @!address = ip2arr($!start.&dec2ip);
                $!end = ( [Z+^] (@!address, self.hostmask.split('.'))).join('.').&ip2dec;
            }

            when IPv6arr {
                @!netmask = @netmask;
                $!start = (( [Z+&] (@address, @!netmask)) Z+< (0x70,0x60...0)).sum;
                @!address = (0x70,0x60...0x0).map({ $!start +> $_}) »%» 0x10000;
                $!end = (( [Z+^] (@!address, (@!netmask »+^» 0xFFFF) )) Z+< (0x70,0x60...0)).sum;
            }
        }

    }

    sub ip2dec(\i) is export {
        i.split('.').flatmap({
            ($^a +< 0x18), ($^b +< 0x10), ($^c +< 0x08), $^d
        }).sum;
    }

    sub dec2ip(\d where { 0 <= $_ <= 0xffffffff or die 'not in IPv4 range 0-4294967295'} --> IPv4) is export {
        ( (d +> 0x18, d +> 0x10, d +> 0x08, d) »%» 0x100 ).join('.');
    }

    sub dec2ip6(\d where { 0 <= $_ <= (2**128-1) or die 'not in IPv6 range (128bit)'} --> IPv6) is export {
        (((0x70,0x60...0x0).map({ d +> $_}) »%» 0x10000)».base(16).join(':'));
    }

    sub by8to16     (@m) { gather for @m -> $a,$b { take ($a * 256 + $b).fmt("%04x") } }
    sub ip2arr      ($a) { IP_Addr.subparse($a, :rule<ipv4>    ).made>>.Int            }
    sub ipmask2arr  ($m) { IP_Addr.subparse($m, :rule<ipv4mask>).made>>.Int            }

    sub compress6(@ip) {
        my $matches = 0;
        my $bestspos = Nil;
        my $startpos = Nil;
        for @ip.keys -> $i {
            if @ip[$i] == 0 ff^ @ip[$i] != 0 {
                $startpos //= $i;
                #last element is zero and bestmatch
                if $i == @ip.elems-1 and @ip.elems-$startpos > $matches {
                    $matches  = @ip.elems-$startpos;
                    $bestspos = $startpos;
                }
            } else {
                if defined $startpos and $i-$startpos > $matches {
                    $matches = $i-$startpos;
                    $bestspos = $startpos;
                }
                $startpos = Nil;
            }
        }

        given $bestspos {
            when 0                       { '::' ~ @ip.[$matches .. (@ip.elems-1)]».base(16).join(':') }
            when + $matches == @ip.elems { @ip.[0..$bestspos-1]».base(16).join(':') ~ '::'}
            when $_                      { @ip.[0..$bestspos-1]».base(16).join(':') ~ '::' ~ @ip.[($bestspos+$matches)..(@ip.elems-1)]».base(16).join(':') }
            default                      { @ip».base(16).join(':') }
        }
    }


    method Str     {
        given @!address {
            when IPv4arr { "$.base/$.bits"; }
            when IPv6arr { "$.base/$.bits";}
        }
    }

    method gist    { qq[Net::Netmask.new("$.Str")]; }
    method Numeric { $!start; }
    method Int     { $!start; }
    method Real    { $!start; }
    method desc    { self.Str;  }

    method mask    {
        given @!address {
            when IPv4arr { @.netmask.join('.') }
            when IPv6arr { @!netmask.&compress6 }
        }
    }

    method hostmask {
        given @!address {
            when IPv4arr { (@!netmask »+^» 0xFF).join('.')  } #bitflip
            when IPv6arr { (@!netmask »+^» 0xFFFF).&compress6}
            #when IPv6arr { (@!netmask »+^» 0xFFFF)».base(16).join(':')}

        }
    }

    method broadcast {
        given @!address {
            when IPv4arr { $!end.&dec2ip }
            when IPv6arr { $!end.&dec2ip6}
        }
     }

    method last {
        $.broadcast;
    }

    method base {
        given @!address {
            when IPv4arr { @!address.join('.') }
            when IPv6arr { @!address.&compress6 }
        }
    }

    method first {
        $.base;
    }

    method bits {
        @!netmask.map(*.base: 2).comb('1').elems;
    }

    method size {
        $!end - $!start + 1;
    }

    method enumerate(Int :$bit, Bool :$nets) {
        given @!address {
            when IPv4arr {
                my $b = $bit // 32;
                $b > 32 and fail('Cannot split network into smaller than /32 blocks');
                my $inc = 2 ** ( 32 - $b );
                ($!start, * + $inc ... * > $!end - $inc).map(&dec2ip).map(-> $ip {
                     $nets ?? self.new( "$ip/$b" ) !! $ip
                });
            }
            when IPv6arr {
                my $b = $bit // 128;
                $b > 128 and fail('Cannot split network into smaller than /128 blocks');
                my $inc = 2 ** ( 128 - $b );
                ($!start, * + $inc ... * > $!end - $inc).map(&dec2ip6).map(-> $ip {
                    $nets ?? self.new( "$ip/$b" ) !! self.new($ip).base
                });
            }
        }
    }

    method nth($n, Int :$bit, Bool :$nets) {
        given @!address {
            when IPv4arr {
                my $b = $bit // 32;
                $b > 32 and fail('Cannot split network into smaller than /32 blocks');
                my $inc = 2 ** ( 32 - $b ) × 1;
                my @n = $n.flatmap(* × $inc);
                if ( my $i = @n.max ) >= $.size {
                    return fail(
                        "Index out of range. Is: { $i ÷ $inc }, "
                        ~ "should be in 0..{ ($.size ÷ $inc) - 1 }"
                    );
                }
                ($!start .. $!end)[@n].map(&dec2ip).map(-> $ip {
                     $nets ?? self.new( "$ip/$b" ) !! $ip
                });
            }
            when IPv6arr {
                my $b = $bit // 128;
                $b > 128 and fail('Cannot split network into smaller than /128 blocks');
                my $inc = 2 ** ( 128 - $b ) × 1;
                my @n = $n.flatmap(* × $inc);
                if ( my $i = @n.max ) >= $.size {
                    return fail(
                            "Index out of range. Is: { $i ÷ $inc }, "
                            ~ "should be in 0..{ ($.size ÷ $inc) - 1 }"
                            );
                }
                ($!start .. $!end)[@n].map(&dec2ip6).map(-> $ip {
                    $nets ?? self.new( "$ip/$b" ) !! self.new($ip).base
                });
            }
        }



    }

    method match(IPv4 $ip) {
        my $dec = self.new($ip).Int;
        $!end >= $dec >= $!start ?? ($dec - $!start) but True !! False;
    }

    method next {
        given @!address {
            when IPv4arr { self.new(($!start + $.size).&dec2ip, self.mask) }
            when IPv6arr { self.new(($!start + $.size).&dec2ip6 ~ '/' ~ self.bits) }
        }
    }

    method prev {
        given @!address {
            when IPv4arr { self.new(($!start - $.size).&dec2ip, self.mask) }
            when IPv6arr { self.new(($!start - $.size).&dec2ip6  ~ '/' ~ self.bits) }
        }
    }

    method succ {
        $.next;
    }

    method pred {
        $.prev
    }

    method sort(*@a) {
        if defined self { die "Cannot call sort() as an instance method"; }
        @a.sort( *.sortkey );
    }

    method sortkey {
        given @!address {
            when IPv4arr { $!start +  $.bits/32 }
            when IPv6arr { $!start +  $.bits/128}
        }
    }

    method sk { $.sortkey; }
}



Netmask

use v6.*;

our $n_name     is export(:FIELDS);
our @n_aliases  is export(:FIELDS);
our $n_addrtype is export(:FIELDS);
our $n_net      is export(:FIELDS);

class Net::netent:ver<0.0.5>:auth<zef:lizmat> {
    has Str $.name;
    has     @.aliases;
    has Int $.addrtype;
    has Int $.net
}

sub populate(@fields) {
    if @fields {
        Net::netent.new(
          name     => ($n_name     = @fields[0]),
          aliases  => (@n_aliases  = @fields[1]),
          addrtype => ($n_addrtype = @fields[2]),
          net      => ($n_net      = @fields[3]),
        )
    }
    else {
          $n_name     = Str;
          @n_aliases  = ();
          $n_addrtype = Int;
          $n_net      = Int;
          Nil
    }
}

my sub getnetbyname(Str() $name) is export(:DEFAULT:FIELDS) {
    use P5getnetbyname:ver<0.0.7>:auth<zef:lizmat>;
    populate(getnetbyname($name))
}

my sub getnetbyaddr(Int:D $addrtype, Int:D $net) is export(:DEFAULT:FIELDS) {
    use P5getnetbyname:ver<0.0.7>:auth<zef:lizmat>;
    populate(getnetbyaddr($addrtype,$net))
}

my sub getnetent() is export(:DEFAULT:FIELDS) {
    use P5getnetbyname:ver<0.0.7>:auth<zef:lizmat>;
    populate(getnetent)
}

my proto sub getnet(|) is export(:DEFAULT:FIELDS) {*}
my multi sub getnet(Int:D $addr) is export(:DEFAULT:FIELDS) {
    getnetbyaddr($addr)
}
my multi sub getnet(Str:D $nam) is export(:DEFAULT:FIELDS) {
    getnetbyname($nam)
}

my constant &setnetent is export(:DEFAULT:FIELDS) = do {
    use P5getnetbyname:ver<0.0.7>:auth<zef:lizmat>;
    &setnetent
}
my constant &endnetent is export(:DEFAULT:FIELDS) = do {
    use P5getnetbyname:ver<0.0.7>:auth<zef:lizmat>;
    &endnetent
}



my $n = getnetbyname("loopback")       or die "bad net";
printf "%s is %08X\n", $n.name, $n.net;


use Net::netent qw(:FIELDS);
getnetbyname("loopback")               or die "bad net";
printf "%s is %08X\n", $n_name, $n_net;


This module tries to mimic the behaviour of Perl's C<Net::netent> module
as closely as possible in the Raku Programming Language.


This module's exports C<getnetbyname>, C<getnetbyaddrd>, and C<getnetent>
functions that return C<Netr::netent> objects. This object has methods that
return the similarly named structure field name from the C's netent structure
from netdb.h, stripped of their leading "n_" parts, namely name, aliases,
addrtype and net.


You may also import all the structure fields directly into your namespace as
regular variables using the :FIELDS import tag.  Access these fields as
variables named with a preceding n_ in front their method names. Thus,
$net_obj.name corresponds to $n_name if you import the fields.


The C<getnet> function is a simple front-end that forwards a numeric argument
to C<getnetbyaddr> and the rest to C<getnetbyname>.


This module depends on the availability of POSIX semantics.  This is
generally not available on Windows, so this module will probably not work
on Windows.


Source can be located at: https://github.com/lizmat/Net-netent . Comments and
Pull Requests are welcome.


Re-imagined from Perl as part of the CPAN Butterfly Plan.


This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.


netent

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

NAME

SYNOPSIS

DESCRIPTION

PORTING CAVEATS

AUTHOR

COPYRIGHT AND LICENSE

Net::netent v0.0.5

Authors

License

Dependencies

Test Dependencies

Provides

Documentation