view release on metacpan or search on metacpan
lib/Net/Address/Ethernet.pm view on Meta::CPAN
fwe0: flags=108802<BROADCAST,SIMPLEX,MULTICAST,NEEDSGIANT> mtu 1500
options=8<VLAN_MTU>
ether 02:31:38:31:35:35
ch 1 dma -1
vr0: flags=8843<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> mtu 1500
inet6 fe8d::2500:bafd:fecd:cdcd%vr0 prefixlen 64 scopeid 0x2
inet 19.16.12.52 netmask 0xffffff00 broadcast 19.16.12.255
ether 00:53:b3:c3:3d:39
media: Ethernet autoselect (100baseTX <full-duplex>)
status: active
nfe0: flags=8843<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> mtu 1500
options=8<VLAN_MTU>
inet6 fe8e::21e:31ef:fee1:26eb%nfe0 prefixlen 64 scopeid 0x3
ether 00:13:33:53:23:13
media: Ethernet autoselect (100baseTX <full-duplex>)
status: active
plip0: flags=108810<POINTOPOINT,SIMPLEX,MULTICAST,NEEDSGIANT> mtu 1500
lo0: flags=8049<UP,LOOPBACK,RUNNING,MULTICAST> mtu 16384
inet6 ::1 prefixlen 128
inet6 fe80::1%lo0 prefixlen 64 scopeid 0x5
inet 127.0.0.1 netmask 0xff000000
inet 127.0.0.2 netmask 0xffffffff
inet 127.0.0.3 netmask 0xffffffff
tun0: flags=8051<UP,POINTOPOINT,RUNNING,MULTICAST> mtu 1492
inet 83.173.73.3 --> 233.131.83.3 netmask 0xffffffff
view release on metacpan or search on metacpan
debian/control view on Meta::CPAN
Standards-Version: 3.8.0
Package: libnet-address-ip-local-perl
Architecture: all
Depends: ${perl:Depends}, liberror-perl
Suggests: libio-socket-inet6-perl
Description: A class for discovering the local system's IP address
Net::Address::IP::Local discovers the local system's IP address that would
be used as the source address when contacting "the internet" or a certain
specified remote IP address.
view release on metacpan or search on metacpan
examples/hello-world.pl view on Meta::CPAN
$loop->add( $httpserver );
$httpserver->listen(
addr => {
family => "inet6",
socktype => "stream",
port => $SSL ? 8443 : 8080,
},
on_listen_error => sub { die "Cannot listen - $_[-1]\n" },
( $SSL ? (
view release on metacpan or search on metacpan
examples/GET.pl view on Meta::CPAN
GetOptions(
'local-host=s' => \my $LOCAL_HOST,
'local-port=i' => \my $LOCAL_PORT,
'timeout=f' => \my $TIMEOUT,
'ipv4|4' => sub { $FAMILY = "inet" },
'ipv6|6' => sub { $FAMILY = "inet6" },
) or exit 1;
my $loop = IO::Async::Loop->new;
my $ua = Net::Async::HTTP->new(
view release on metacpan or search on metacpan
lib/Net/Async/Tangence/Client.pm view on Meta::CPAN
server. See the documentation the L<Tangence::Client> C<tangence_connected>
method.
=item family => STRING
Optional. May be set to C<inet4> or C<inet6> to force IPv4 or IPv6 if
relevant. Ignored by C<exec:> and C<unix:> schemes.
=back
The following URL schemes are recognised:
lib/Net/Async/Tangence/Client.pm view on Meta::CPAN
my $self = shift;
my ( $authority, %args ) = @_;
my $family;
$family = Socket::PF_INET() if $args{family} and $args{family} eq "inet4";
$family = Socket::PF_INET6() if $args{family} and $args{family} eq "inet6";
my ( $host, $port ) = $authority =~ m/^(.*):(.*)$/;
$self->connect(
host => $host,
view release on metacpan or search on metacpan
lib/Net/Async/WebService/lxd.pm view on Meta::CPAN
description: IP address
example: fd42:4c81:5770:1eaf:216:3eff:fe0c:eedd
type: string
x-go-name: Address
family:
description: Network family (inet or inet6)
example: inet6
type: string
x-go-name: Family
netmask:
description: Network mask
example: "64"
view release on metacpan or search on metacpan
my $oneday = 86400; # WARNING, set in XS also
my $unique = $$ -1; # dns sequence number
my($match,$nomatch,$payoff);
my $af_inet6 = eval { AF_INET6() };
$af_inet6 = 0 if $@;
#################################################
##### global vars reset by HUP
my ($purge,$nxpurge);
my @ifs = interfaces Net::Interface ();
IF:
foreach my $if (@ifs) {
my @addrs = $if->address(AF_INET());
my @netms = $if->netmask(AF_INET());
if ($af_inet6) {
push @addrs, $if->address($af_inet6);
push @netms, $if->netmask($af_inet6);
}
foreach (0..$#addrs) {
my $iddr = ipanyto6($addrs[$_]);
my $name = $if->name();
if ($naddr eq $iddr) {
view release on metacpan or search on metacpan
lib/Net/DNS/Lite.pm view on Meta::CPAN
} elsif (/^attempts:(\d+)$/) {
$attempts = $1;
} elsif (/^ndots:(\d+)$/) {
$self->{ndots} = $1;
} else {
# debug, rotate, no-check-names, inet6
}
}
}
}
view release on metacpan or search on metacpan
lib/Net/DNS/Resolver.pm view on Meta::CPAN
The default domain.
=head2 RES_OPTIONS
# Bourne Shell
RES_OPTIONS="retrans:3 retry:2 inet6"
export RES_OPTIONS
# C Shell
setenv RES_OPTIONS "retrans:3 retry:2 inet6"
A space-separated list of resolver options to set. Options that
take values are specified as C<option:value>.
view release on metacpan or search on metacpan
# $Id: TODO 904 2011-10-17 18:10:43Z pro $ $URL: svn://svn.setun.net/dcppp/trunk/TODO $
debian: libio-socket-inet6-perl libio-socket-ssl-perl
dont add to share downloaded filelists
better nick-port-ip-lists
udp UPSR
view release on metacpan or search on metacpan
bin/nfd-print-routes6.pl view on Meta::CPAN
($ip6 && lc($ip6)) || '::1';
}
sub _getRoutesLinux {
my %ifRoutes;
my $buf = `netstat -rnA inet6`;
my %devIps;
if ($buf) {
my @lines = split('\n', $buf);
for (@lines) {
my @elts = split(/\s+/);
view release on metacpan or search on metacpan
lib/Net/Frame/Layer/CDP/Address.pm view on Meta::CPAN
$raw .= $self->SUPER::pack('a4',
inetAton($self->address)
) or return;
} elsif ($self->protocol eq NF_CDP_ADDRESS_PROTOCOL_IPv6) {
$raw .= $self->SUPER::pack('a16',
inet6Aton($self->address)
) or return;
} else {
$raw .= $self->SUPER::pack("a$addressLength",
$self->address
) or return;
lib/Net/Frame/Layer/CDP/Address.pm view on Meta::CPAN
$self->address(inetNtoa($address));
} elsif ($self->protocol eq NF_CDP_ADDRESS_PROTOCOL_IPv6) {
($address, $payload) =
$self->SUPER::unpack('a16 a*', $tail)
or return;
$self->address(inet6Ntoa($address));
} else {
($address, $payload) =
$self->SUPER::unpack("a$addressLength a*", $tail)
or return;
$self->address($address);
view release on metacpan or search on metacpan
lib/Net/Frame/Layer/DNS/RR/AAAA.pm view on Meta::CPAN
sub pack {
my $self = shift;
$self->raw($self->SUPER::pack('a*',
inet6Aton($self->address)
)) or return;
return $self->raw;
}
sub unpack {
my $self = shift;
$self->address(inet6Ntoa(substr $self->raw, 0, 16));
$self->payload(substr $self->raw, 16);
return $self;
}
view release on metacpan or search on metacpan
lib/Net/Frame/Layer/ICMPv6/MLD.pm view on Meta::CPAN
my $self = shift;
my $raw = $self->SUPER::pack('nna*',
$self->maxResp,
$self->reserved,
inet6Aton($self->groupAddress)
) or return;
return $self->raw($raw);
}
lib/Net/Frame/Layer/ICMPv6/MLD.pm view on Meta::CPAN
$self->SUPER::unpack('nna16 a*', $self->raw)
or return;
$self->maxResp($maxResp);
$self->reserved($reserved);
$self->groupAddress(inet6Ntoa($group));
$self->payload($payload);
return $self;
}
view release on metacpan or search on metacpan
lib/Net/Frame/Layer/ICMPv6.pm view on Meta::CPAN
my $zero = Bit::Vector->new_Dec(24, 0);
my $nextHeader = Bit::Vector->new_Dec( 8, $lastNextHeader);
my $v32 = $zero->Concat_List($nextHeader);
my $packed = $self->SUPER::pack('a*a*NNCCn',
inet6Aton($ip->src), inet6Aton($lastIpDst), $ipPayloadLength,
$v32->to_Dec, $self->type, $self->code, 0
) or return;
if (defined($last->payload) && length($last->payload)) {
$payload .= $last->payload;
view release on metacpan or search on metacpan
examples/hopbyhop.pl view on Meta::CPAN
type => 128,
);
my $mld = Net::Frame::Layer::ICMPv6::Echo->new(
identifier => 16,
sequenceNumber => 0,
payload => inet6Aton('::'),
);
# Create packet
my $packet = Net::Frame::Simple->new(
layers => [ $ether, $ipv6, $hop, $icmpv6, $mld, ],
view release on metacpan or search on metacpan
examples/lltd-discover.pl view on Meta::CPAN
}
elsif ($_->type == NF_LLTD_TLV_TYPE_IPv4ADDRESS) {
$ip = inetNtoa($_->value);
}
elsif ($_->type == NF_LLTD_TLV_TYPE_IPv6ADDRESS) {
$ip6 = inet6Ntoa($_->value);
}
#elsif ($_->type == NF_LLTD_TLV_TYPE_PERFCOUNTER) {
#$perfCounter = unpack('N', $_->value << 32);
#}
elsif ($_->type == NF_LLTD_TLV_TYPE_MACHINENAME) {
view release on metacpan or search on metacpan
lib/Net/Frame/Layer/RIPng/v1.pm view on Meta::CPAN
sub pack {
my $self = shift;
$self->raw($self->SUPER::pack('a16nCC',
inet6Aton($self->prefix),
$self->routeTag,
$self->prefixLength,
$self->metric
)) or return;
lib/Net/Frame/Layer/RIPng/v1.pm view on Meta::CPAN
my ($prefix, $routeTag, $prefixLength, $metric, $payload) =
$self->SUPER::unpack('a16nCC a*', $self->raw)
or return;
$self->prefix(inet6Ntoa($prefix));
$self->routeTag($routeTag);
$self->prefixLength($prefixLength);
$self->metric($metric);
$self->payload($payload);
view release on metacpan or search on metacpan
lib/Net/Frame/Layer/SNMP.pm view on Meta::CPAN
return
}
} elsif ($self->pdu_type == NF_SNMP_PDUTYPE_TRAP) {
my $agent_addr;
if ($self->agentAddr =~ /:/) {
$agent_addr = inet6Aton($self->agentAddr)
} else {
$agent_addr = inetAton($self->agentAddr)
}
$raw = $snmpasn->encode(
version => $self->version,
lib/Net/Frame/Layer/SNMP.pm view on Meta::CPAN
sub _inetNtoa {
my ($addr) = @_;
if (length($addr) == 4) {
return inet_ntoa($addr)
} else {
return inet6Ntoa($addr)
}
}
1;
view release on metacpan or search on metacpan
lib/Net/Frame/Layer/UDPLite.pm view on Meta::CPAN
inetAton($h->{src}), inetAton($h->{dst}), 0, 17, $self->getLength,
) or return;
}
elsif ($h->{type} eq 'IPv6') {
$phpkt = $self->SUPER::pack('a*a*NnCC',
inet6Aton($h->{src}),
inet6Aton($h->{dst}), $self->getLength, 0, 0, 17,
) or return
}
$phpkt .= $self->SUPER::pack('nnnn',
$self->src, $self->dst, $self->getLength, 0,
view release on metacpan or search on metacpan
lib/Net/Frame/Layer.pm view on Meta::CPAN
getHostIpv4Addr
getHostIpv4Addrs
getHostIpv6Addr
inetAton
inetNtoa
inet6Aton
inet6Ntoa
getRandomHighPort
getRandom32bitsInt
getRandom16bitsInt
convertMac
inetChecksum
lib/Net/Frame/Layer.pm view on Meta::CPAN
return $ipv6;
}
sub inetAton { Socket::inet_aton(shift()) }
sub inetNtoa { Socket::inet_ntoa(shift()) }
sub inet6Aton { _inet_pton(AF_INET6, shift()) }
sub inet6Ntoa { _inet_ntop(AF_INET6, shift()) }
sub getRandomHighPort {
my $highPort = int rand 0xffff;
$highPort += 1024 if $highPort < 1025;
$highPort;
lib/Net/Frame/Layer.pm view on Meta::CPAN
=item B<getHostIpv6Addr> (hostname)
Resolves IPv6 address of specified hostname.
=item B<inet6Aton> (IPv6 address)
Takes IPv6 address and returns the network form.
=item B<inet6Ntoa> (IPv6 network form)
Takes IPv6 address in network format, and returns the IPv6 human form.
=item B<inetAton> (IPv4 address)
view release on metacpan or search on metacpan
0.604 2021/02/26
- change bugtracker in Makefile.PL to github
0.603 2014/09/07
- mark Net::FTP 2.79 as a valid base too, based on patch from
kimmo[AT]suominen[DOT]com, https://github.com/noxxi/p5-net-inet6glue/pull/3
0.602 2014/01/17
- fix t/01_inet_is_inet6.t
0.601 2014/01/14
- add support for IO::Socket::IP instead of IO::Socket::INET6 and prefer it
0.600_1 2013/05/31
- set AUTHOR in Makefile.PL back from array to string, because array is
only supported in newer ExtUtils::MakeMaker versions
view release on metacpan or search on metacpan
lib/Net/IP/Identifier/WhoisParser.pm view on Meta::CPAN
qr[^route([s6])?:]i,
qr[^mnt-routes:]i,
);
my @whois_range_regexs = ( # lines which might contain the range
qr[^inet6?num:\s*(.+)]i,
qr[^NetRange:\s*(.+)]i,
qr[^CIDR:\s*(\S+)]i,
qr[^Network:IP-Network(?:-Block)?:\s*(.+)]i,
qr/^a\.\s*\[Network Number\]\s*(.*)/i,
);
view release on metacpan or search on metacpan
lib/Net/ISC/DHCPClient.pm view on Meta::CPAN
$self->{INTERFACE} = defined($opts{interface}) ? $opts{interface} : undef;
$self->{leases_path} = $opts{leases_path};
# Internal storage:
$self->{leases_af_inet} = undef;
$self->{leases_af_inet6} = undef;
bless ($self, $class);
return $self;
}
lib/Net/ISC/DHCPClient.pm view on Meta::CPAN
sub is_dhcp($$;$)
{
my ($self, $af, $inteface_to_query) = @_;
die "Address family is: inet or inet6!" if (!($af eq 'inet' || $af eq 'inet6'));
if (defined($inteface_to_query) &&
defined($self->{INTERFACE}) &&
$self->{INTERFACE} ne $inteface_to_query) {
die sprintf("Cannot query interface %s, has %s.", $inteface_to_query, $self->{INTERFACE});
lib/Net/ISC/DHCPClient.pm view on Meta::CPAN
if (defined($self->{INTERFACE})) {
if ($af eq 'inet') {
$self->leases_af_inet();
return scalar(@{$self->{leases_af_inet}}) > 0;
}
if ($af eq 'inet6') {
$self->leases_af_inet6();
return scalar(@{$self->{leases_af_inet6}}) > 0;
}
return 0;
}
die "Need interface!" if (!defined($inteface_to_query));
# Iterate all found leases and look for given interface
my $leases_to_check;
$leases_to_check = $self->{leases_af_inet} if ($af eq 'inet');
$leases_to_check = $self->{leases_af_inet6} if ($af eq 'inet6');
for my $lease (@$leases_to_check) {
return 1 if ($lease->{INTERFACE} eq $inteface_to_query);
}
return 0;
lib/Net/ISC/DHCPClient.pm view on Meta::CPAN
'inet');
return $self->{leases_af_inet};
}
sub leases_af_inet6($)
{
my ($self) = @_;
return $self->{leases_af_inet6} if ($self->{leases_af_inet6});
$self->{leases_af_inet6} = $self->_read_lease_file($self->{leases_path},
$self->{INTERFACE},
'inet6');
return $self->{leases_af_inet6};
}
sub _read_lease_file($$$$)
{
lib/Net/ISC/DHCPClient.pm view on Meta::CPAN
} else {
$leasefile_re1 = qr/^dhclient-(.*)?-(.+)\.lease$/;
$leasefile_re2 = qr/^dhclient\.(.+)\.leases$/;
$leasefile_re3 = qr/^internal-(.*)?-($interface)\.lease$/;
}
} elsif ($af eq 'inet6') {
if ($interface) {
$leasefile_re1 = qr/^dhclient6-(.*)?-($interface)\.lease$/;
$leasefile_re2 = qr/^dhclient6\.($interface)\.leases$/;
} else {
$leasefile_re1 = qr/^dhclient6-(.*)?-(.+)\.lease$/;
lib/Net/ISC/DHCPClient.pm view on Meta::CPAN
next;
}
s/^\s+//; # Eat starting whitespace
$self->_isc_af_inet_lease_parser($currentLease, $_) if ($af eq 'inet');
$self->_isc_af_inet6_lease_parser($currentLease, $ia_type, $_) if ($af eq 'inet6');
} # end while (<LEASEFILE>)
close (LEASEFILE);
}
for my $leaseFile (@netplan_lease_files) {
lib/Net/ISC/DHCPClient.pm view on Meta::CPAN
last SWITCH;
};
}
}
sub _isc_af_inet6_lease_parser($$$$)
{
my ($self, $currentLease, $ia_type, $line) = @_;
my $context = '';
my $addr = '';
view release on metacpan or search on metacpan
t/01.config.t view on Meta::CPAN
my $dummy_data = {
ip_addr_show =><<'EOF',
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
link/ether 00:01:c0:08:3e:38 brd ff:ff:ff:ff:ff:ff
inet 191.3.88.152/27 brd 255.255.255.255 scope global eth0
inet6 fe80::201:c0ff:fe08:3e38/64 scope link
valid_lft forever preferred_lft forever
3: eth1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
link/ether 00:01:c0:08:3e:39 brd ff:ff:ff:ff:ff:ff
inet 192.168.10.1/24 brd 192.168.10.255 scope global eth1
inet6 fe80::201:c0ff:fe08:3e39/64 scope link
valid_lft forever preferred_lft forever
4: eth2: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
link/ether 48:f8:b3:2e:f6:b2 brd ff:ff:ff:ff:ff:ff
inet 192.168.11.11/24 brd 192.168.11.255 scope global eth2
inet6 fe80::4af8:b3ff:fe2e:f6b2/64 scope link
valid_lft forever preferred_lft forever
5: wlan0: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN qlen 1000
link/ether 00:0d:f0:63:95:61 brd ff:ff:ff:ff:ff:ff
6: eth3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
link/ether 48:f8:b3:2e:f6:b2 brd ff:ff:ff:ff:ff:ff
inet 192.168.12.1/24 brd 192.168.12.255 scope global eth3
inet 192.168.13.1/24 brd 192.168.13.255 scope global eth3:0
inet6 fe80::4af8:b3ff:fe2e:f6b2/64 scope link
valid_lft forever preferred_lft forever
7: eth4: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
link/ether 48:f8:b3:2e:f6:b2 brd ff:ff:ff:ff:ff:ff
inet6 fe80::4af8:b3ff:fe2e:f6b2/64 scope link
valid_lft forever preferred_lft forever
8: ppp0: <POINTOPOINT,MULTICAST,NOARP,UP,LOWER_UP> mtu 1492 qdisc pfifo_fast state UNKNOWN qlen 3
link/ppp
inet 11.120.199.108 peer 112.211.154.198/32 scope global ppp0
9: eth5: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
link/ether 48:f8:b3:2e:f6:b4 brd ff:ff:ff:ff:ff:ff
inet 192.168.20.1/24 brd 192.168.20.255 scope global eth5
inet6 fe80::4af8:b3ff:fe2e:f6b2/64 scope link
valid_lft forever preferred_lft forever
31: tun0: <POINTOPOINT,MULTICAST,NOARP,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UNKNOWN qlen 100
link/none
inet 10.8.0.1 peer 10.8.0.2/32 scope global tun0
EOF
view release on metacpan or search on metacpan
lib/Net/Inspect/L3/IP.pm view on Meta::CPAN
use base 'Net::Inspect::Flow';
use fields qw(frag frag_timeout);
use Net::Inspect::Debug;
use Socket;
my $inet6_ntop;
BEGIN {
$inet6_ntop = eval {
Socket->VERSION(1.95);
Socket::inet_ntop( AF_INET6(),"\x0"x16)
&& sub { Socket::inet_ntop(AF_INET6(),shift) };
} || eval {
require Socket6;
Socket6::inet_ntop( Socket6::AF_INET6(),"\x0"x16)
&& sub { Socket6::inet_ntop(Socket6::AF_INET6(),shift) };
};
*pktin6 = $inet6_ntop ? \&_pktin6 : \&_pktin6_unsupported;
}
# field frag: hash indexed by {ip.id,saddr,daddr} with values
# [ $pos, \@fragments, $expire ]
lib/Net/Inspect/L3/IP.pm view on Meta::CPAN
substr($data,0,$len+8,''); # skip extension header
}
return $self->{upper_flow}->pktin( $data, {
time => $time,
saddr => $inet6_ntop->($saddr),
daddr => $inet6_ntop->($daddr),
proto => $proto,
ttl => $ttl,
qos => $tclass,
flowlabel => $flowlabel,
ver => 6,
view release on metacpan or search on metacpan
Interface.pm view on Meta::CPAN
# provide AF family data for use in this module
my $AF_inet = eval { 0 + AF_INET() } || 0;
my $AF_inet6 = eval { 0 + AF_INET6() } || 0;
sub af_inet { return $AF_inet; }
sub af_inet6 { return $AF_inet6; }
sub net_symbols() {
no strict;
my %sym;
my $max = AF_MAX();
Interface.pm view on Meta::CPAN
unless ($f) { # if the family is missing
if (exists $if->{args}->{&af_inet}) {
$fam = &af_inet; # select default, AF_INET
}
else {
$fam = &af_inet6; # or AF_INET6 if present
}
}
if (! exists $if->{args}->{$fam} || # there is no such family
$idx < 0 || $idx > $#{$if->{args}->{$fam}->{addr}}) { # or the index is out of range
return () if wantarray; # PUNT!
Interface.pm view on Meta::CPAN
metric => $metric,
flags => $flags,
mac => $mac,
index => $index,
};
my $af_inet6 = eval { &af_inet6 } || 0;
foreach(&af_inet,$af_inet6) {
next unless $_;
if (exists $if->{args}->{$_}) {
$info->{$_}->{size} = $if->{args}->{$_}->{size};
$info->{$_}->{number} = @{$if->{args}->{$_}->{addr}};
}
Interface.pm view on Meta::CPAN
my $len = length($_[0]);
if ($len == 4) {
return &af_inet;
}
elsif ($len == 16) {
return &af_inet6;
}
return 0;
}
=head1 FUNCTIONS
view release on metacpan or search on metacpan
lib/Net/Libdnet6.pm view on Meta::CPAN
sub _get_routes_other { return; }
sub _get_routes_linux {
return unless $_pathNetstat;
my $buf = `$_pathNetstat -rnA inet6 2> /dev/null`;
return unless $buf;
my @ifRoutes = ();
my %devIps;
for (split('\n', $buf)) {
lib/Net/Libdnet6.pm view on Meta::CPAN
}
sub _get_routes_bsd {
return unless $_pathNetstat;
my $buf = `$_pathNetstat -rnf inet6 2> /dev/null`;
return unless $buf;
my @ifRoutes = ();
my %devIps;
for (split('\n', $buf)) {
view release on metacpan or search on metacpan
lib/Net/OpenSSH/More/Linux.pm view on Meta::CPAN
sub get_remote_ips {
my ( $self, $interface ) = @_;
return (
'v4' => [ $get_addrs_for_iface->( $self, $interface, 'inet' ) ],
'v6' => [ $get_addrs_for_iface->( $self, $interface, 'inet6' ) ],
);
}
sub get_local_ips {
my ( $self, $interface ) = @_;
return (
'v4' => [ $get_addrs_for_iface->( $self, $interface, 'inet', 1 ) ],
'v6' => [ $get_addrs_for_iface->( $self, $interface, 'inet6', 1 ) ],
);
}
sub copy {
view release on metacpan or search on metacpan
lib/Net/Packet/IPv6.pm view on Meta::CPAN
require Net::Packet::Layer3;
our @ISA = qw(Net::Packet::Layer3);
use Net::Packet::Env qw($Env);
use Net::Packet::Utils qw(unpackIntFromNet packIntToNet
inet6Aton inet6Ntoa);
use Net::Packet::Consts qw(:ipv6 :layer);
BEGIN {
*protocol = \&nextHeader;
}
lib/Net/Packet/IPv6.pm view on Meta::CPAN
$self->[$__raw] = $self->SUPER::pack('NnCCa*a*',
$v32->to_Dec,
$self->[$__payloadLength],
$self->[$__nextHeader],
$self->[$__hopLimit],
inet6Aton($self->[$__src]),
inet6Aton($self->[$__dst]),
) or return undef;
1;
}
lib/Net/Packet/IPv6.pm view on Meta::CPAN
$self->[$__trafficClass] = $v32->Chunk_Read( 8, 20);
$self->[$__version] = $v32->Chunk_Read( 4, 28);
$self->[$__payloadLength] = $pl;
$self->[$__nextHeader] = $nh;
$self->[$__hopLimit] = $hl;
$self->[$__src] = inet6Ntoa($sa);
$self->[$__dst] = inet6Ntoa($da);
$self->[$__payload] = $payload;
1;
}