From 13132cb416f477df01aa99a09f32d8a53d91734a Mon Sep 17 00:00:00 2001 From: Daniel Hilst <392820+dhilst@users.noreply.github.com> Date: Thu, 5 Nov 2026 09:44:31 -0300 Subject: [PATCH 1/2] test(discovery): nothing asks how xcatd resolves an IPv6 findme or calls an IPv6 node back Sequential discovery resolves the address a findme arrived from to a MAC and looks that MAC up in the mac table. Five plugins carry the same arp(8) parse, which reads the IPv4 table only and interpolates the address into a regular expression. After the match xcatd opens a TCP connection back to the node with IO::Socket::INET, which cannot reach an IPv6 address. No test covers either step. networkutils_neighbour_mac.t drives the parse against the text of an arp(8) table and of an ip(8) neighbour table, both fixtures, so it measures the parse and not the test host's own cache. networkutils_tcp_callback_family.t replaces both socket classes and asks which one the callback uses. Both files report that the subroutines do not exist on this commit, which is why the fix commit follows. Signed-off-by: Daniel Hilst <392820+dhilst@users.noreply.github.com> --- xCAT-test/unit/networkutils_neighbour_mac.t | 137 ++++++++++++++++++ .../unit/networkutils_tcp_callback_family.t | 112 ++++++++++++++ 2 files changed, 249 insertions(+) create mode 100644 xCAT-test/unit/networkutils_neighbour_mac.t create mode 100644 xCAT-test/unit/networkutils_tcp_callback_family.t diff --git a/xCAT-test/unit/networkutils_neighbour_mac.t b/xCAT-test/unit/networkutils_neighbour_mac.t new file mode 100644 index 0000000000..e64110521c --- /dev/null +++ b/xCAT-test/unit/networkutils_neighbour_mac.t @@ -0,0 +1,137 @@ +#!/usr/bin/env perl +# Sequential discovery resolves the address a findme arrived from to a MAC, and looks that +# MAC up in the mac table. Five plugins carried the same arp(8) parse, which reads the IPv4 +# table and matched the address as a regular expression. The parse now takes the table text, +# so a table from either tool is a fixture here instead of the test host's own cache. +use strict; +use warnings; +## no critic (Modules::RequireFilenameMatchesPackage, TestingAndDebugging::ProhibitNoWarnings) + +use FindBin; +use lib "$FindBin::Bin/../../perl-xCAT"; +use Test::More; + +BEGIN { + package xCAT::Table; + sub new { return bless {}, shift; } + sub getAllAttribs { return; } + $INC{'xCAT/Table.pm'} = __FILE__; + + package xCAT::TableUtils; + sub get_site_attribute { return; } + $INC{'xCAT/TableUtils.pm'} = __FILE__; +} + +require xCAT::NetworkUtils; + +my $arp_table = <<'TABLE'; +Address HWtype HWaddress Flags Mask Iface +192.168.201.10 ether 52:54:00:aa:bb:cc C ens7 +192.168.201.11 (incomplete) ens7 +192.168.201.120 ether 52:54:00:11:22:33 C ens7 +TABLE + +my $ip6_table = <<'TABLE'; +2001:db8:177::2 dev ens7 lladdr 52:54:00:aa:bb:cc router REACHABLE +2001:db8:177::3 dev ens7 FAILED +fe80::5054:ff:feaa:bbcc dev ens7 lladdr 52:54:00:aa:bb:cc router STALE +2001:db8:177::4 dev ens7 lladdr 52:54:00:de:ad:be STALE +TABLE + +my $ip4_table = <<'TABLE'; +192.168.201.10 dev ens7 lladdr 52:54:00:aa:bb:cc REACHABLE +192.168.201.11 dev ens7 INCOMPLETE +TABLE + +# IPv4, from arp(8): the format the five plugins read before. +is( + xCAT::NetworkUtils->mac_from_neighbour_table($arp_table, '192.168.201.10'), + '52:54:00:aa:bb:cc', + 'the MAC of an IPv4 neighbour comes out of the arp table', +); +is( + xCAT::NetworkUtils->mac_from_neighbour_table($arp_table, '192.168.201.11'), + undef, + 'an incomplete arp entry has no MAC', +); +# The address used to be interpolated into a regular expression, where a dot matched +# any character, so 192.168.201.1 matched the row of 192.168.201.120 and the wrong +# node was named. +is( + xCAT::NetworkUtils->mac_from_neighbour_table($arp_table, '192.168.201.1'), + undef, + 'an address that is a prefix of another row does not match that row', +); +is( + xCAT::NetworkUtils->mac_from_neighbour_table($arp_table, '192.168.201.99'), + undef, + 'an address the table does not hold has no MAC', +); + +# IPv6, from ip(8): the case that returned nothing at all. +is( + xCAT::NetworkUtils->mac_from_neighbour_table($ip6_table, '2001:db8:177::2'), + '52:54:00:aa:bb:cc', + 'the MAC of an IPv6 neighbour comes out of the IPv6 neighbour table', +); +is( + xCAT::NetworkUtils->mac_from_neighbour_table($ip6_table, '2001:0db8:0177:0000:0000:0000:0000:0002'), + '52:54:00:aa:bb:cc', + 'the same address written in full matches the same row', +); +is( + xCAT::NetworkUtils->mac_from_neighbour_table($ip6_table, '2001:db8:177::3'), + undef, + 'a failed IPv6 entry carries no lladdr and so no MAC', +); +is( + xCAT::NetworkUtils->mac_from_neighbour_table($ip6_table, 'fe80::5054:ff:feaa:bbcc%ens7'), + '52:54:00:aa:bb:cc', + 'a scoped link-local address matches its unscoped row', +); +is( + xCAT::NetworkUtils->mac_from_neighbour_table($ip6_table, '2001:db8:177::9'), + undef, + 'an IPv6 address the table does not hold has no MAC', +); + +# ip(8) also prints the IPv4 table in that format. +is( + xCAT::NetworkUtils->mac_from_neighbour_table($ip4_table, '192.168.201.10'), + '52:54:00:aa:bb:cc', + 'an IPv4 row printed by ip(8) is read as well', +); +is( + xCAT::NetworkUtils->mac_from_neighbour_table($ip4_table, '192.168.201.11'), + undef, + 'an incomplete ip(8) entry has no MAC', +); + +# An upper-case table is one table. +is( + xCAT::NetworkUtils->mac_from_neighbour_table( + "2001:DB8:177::2 dev ens7 lladdr 52:54:00:AA:BB:CC REACHABLE\n", + '2001:db8:177::2', + ), + '52:54:00:aa:bb:cc', + 'the MAC is returned in lower case, as the mac table holds it', +); + +# A twenty-byte InfiniBand address is a link-layer address too. +is( + xCAT::NetworkUtils->mac_from_neighbour_table( + "192.168.201.10 dev ib0 lladdr 80:00:02:08:fe:80:00:00:00:00:00:00:00:02:c9:03:00:1a:2b:3c REACHABLE\n", + '192.168.201.10', + ), + '80:00:02:08:fe:80:00:00:00:00:00:00:00:02:c9:03:00:1a:2b:3c', + 'an InfiniBand link-layer address is read whole', +); + +is(xCAT::NetworkUtils->mac_from_neighbour_table(undef, '192.168.201.10'), undef, + 'no table means no MAC'); +is(xCAT::NetworkUtils->mac_from_neighbour_table($arp_table, undef), undef, + 'no address means no MAC'); +is(xCAT::NetworkUtils->mac_from_neighbour_table($arp_table, 'not-an-address'), undef, + 'an address that does not parse means no MAC'); + +done_testing(); diff --git a/xCAT-test/unit/networkutils_tcp_callback_family.t b/xCAT-test/unit/networkutils_tcp_callback_family.t new file mode 100644 index 0000000000..df6ca49bfe --- /dev/null +++ b/xCAT-test/unit/networkutils_tcp_callback_family.t @@ -0,0 +1,112 @@ +#!/usr/bin/env perl +# After discovery xcatd opens a TCP connection back to the node and sends "restart". +# nodediscover.pm and send_tcp_msg built that socket with IO::Socket::INET, which cannot +# reach an IPv6 address, so an IPv6 node never got the message and exited on the discovery +# timeout. open_tcp_socket chooses the class. Both classes are replaced here, so nothing +# connects to anything. +use strict; +use warnings; +## no critic (Modules::RequireFilenameMatchesPackage, TestingAndDebugging::ProhibitNoWarnings) + +use FindBin; +use lib "$FindBin::Bin/../../perl-xCAT"; +use Test::More; + +BEGIN { + package xCAT::Table; + sub new { return bless {}, shift; } + sub getAllAttribs { return; } + $INC{'xCAT/Table.pm'} = __FILE__; + + package xCAT::TableUtils; + sub get_site_attribute { return; } + $INC{'xCAT/TableUtils.pm'} = __FILE__; +} + +require xCAT::NetworkUtils; + +my @attempts; +my %answer; +my $written = ''; + +{ + no warnings 'redefine'; + foreach my $class (qw(IO::Socket::INET IO::Socket::INET6)) { + no strict 'refs'; + *{"${class}::new"} = sub { + my (undef, %args) = @_; + push @attempts, { class => $class, %args }; + return undef unless $answer{$class}; + # An IO::Socket is a filehandle, and send_tcp_msg prints to it. An + # in-memory handle collects what it writes. + open(my $handle, '>', \$written) or die "Unable to open a scratch handle: $!"; + return $handle; + }; + $INC{ join('/', split(/::/, $class)) . '.pm' } = __FILE__; + } +} + +sub attempt { + @attempts = (); + my $sock = xCAT::NetworkUtils->open_tcp_socket(@_); + return ($sock, [@attempts]); +} + +# An IPv6 node: the family-neutral class is asked, and it is the one that can reach it. +local $xCAT::NetworkUtils::inet6support = 1; +%answer = ('IO::Socket::INET6' => 1); +my ($sock, $tried) = attempt('2001:db8:177::2', 3001, 1); +ok($sock, 'a connection to an IPv6 node is opened'); +is(scalar(@{$tried}), 1, 'one class is asked for it'); +is($tried->[0]{class}, 'IO::Socket::INET6', 'and it is the one that carries AF_INET6'); +is($tried->[0]{PeerAddr}, '2001:db8:177::2', 'the node address is passed unbracketed'); +is($tried->[0]{PeerPort}, 3001, 'the port is passed'); +is($tried->[0]{Proto}, 'tcp', 'the connection is TCP'); +is($tried->[0]{Timeout}, 1, 'the connect timeout is passed'); + +# An IPv4 node keeps working through whichever class answers. +%answer = ('IO::Socket::INET6' => 1); +($sock, $tried) = attempt('192.168.201.10', 3001, 1); +ok($sock, 'a connection to an IPv4 node is opened'); +is($tried->[0]{PeerAddr}, '192.168.201.10', 'the IPv4 address is passed'); + +# A management node without the IPv6 modules keeps the original IPv4 path. +{ + local $xCAT::NetworkUtils::inet6support = undef; + %answer = ('IO::Socket::INET' => 1); + ($sock, $tried) = attempt('192.168.201.10', 3001, 1); + ok($sock, 'a connection is opened without the IPv6 modules'); + is_deeply([ map { $_->{class} } @{$tried} ], ['IO::Socket::INET'], + 'only the IPv4 class is asked when the IPv6 modules are absent'); +} + +# The IPv4 class is the fallback when the family-neutral attempt fails. +%answer = ('IO::Socket::INET' => 1); +($sock, $tried) = attempt('192.168.201.10', 3001, 1); +ok($sock, 'the IPv4 class answers after the family-neutral one does not'); +is_deeply([ map { $_->{class} } @{$tried} ], + [ 'IO::Socket::INET6', 'IO::Socket::INET' ], + 'the family-neutral class is asked first and the IPv4 one second'); + +# Nothing answers. +%answer = (); +($sock, $tried) = attempt('2001:db8:177::2', 3001, 1); +ok(!$sock, 'a node that cannot be reached returns no socket'); + +is(xCAT::NetworkUtils->open_tcp_socket(undef, 3001), undef, 'no address opens nothing'); +is(xCAT::NetworkUtils->open_tcp_socket('192.168.201.10', undef), undef, 'no port opens nothing'); + +# send_tcp_msg is the other caller, and it writes the message it was given. +%answer = ('IO::Socket::INET6' => 1); +@attempts = (); +$written = ''; +is(xCAT::NetworkUtils->send_tcp_msg('2001:db8:177::2', 3001, 'restart'), 0, + 'send_tcp_msg reports success for an IPv6 node'); +is($attempts[0]{class}, 'IO::Socket::INET6', 'and it reached that node through the IPv6 class'); +is($written, 'restart', 'the message is written to the socket'); + +%answer = (); +is(xCAT::NetworkUtils->send_tcp_msg('2001:db8:177::2', 3001, 'restart'), 1, + 'send_tcp_msg reports failure when nothing answers'); + +done_testing(); From 0373cd656893318221718b716d59125602fa827a Mon Sep 17 00:00:00 2001 From: Daniel Hilst <392820+dhilst@users.noreply.github.com> Date: Thu, 5 Nov 2026 09:44:41 -0300 Subject: [PATCH 2/2] fix(xcat-core): discovery cannot resolve an IPv6 findme and never calls an IPv6 node back A node that sends its findme request over IPv6 is never discovered. Two steps fail. seqdiscovery.pm reads the arp(8) table to turn the client address into a MAC and looks that MAC up in the mac table. arp(8) prints the IPv4 table only, so the table holds no row for the client and the plugin logs "Could not find mac of the
" and returns. aaadiscovery.pm, profilednodes.pm, blade.pm and hpblade.pm carry the same parse. All five interpolate the address into a regular expression as well, so a dot matches any character and 192.168.201.1 matches the row of 192.168.201.120. nodediscover.pm then opens a TCP connection to the node to send "restart", and NetworkUtils::send_tcp_msg does the same for its callers. Both build the socket with IO::Socket::INET, which has no AF_INET6, so the node receives nothing and Genesis exits on DISCOVERY_TIMEOUT after 36 attempts. NetworkUtils gains mac_from_neighbour_table, which takes the text of a neighbour table and the address and returns the MAC; neighbour_table_text, which reads arp(8) for IPv4 and "ip -6 neigh show" for IPv6; and mac_of_neighbour, which joins them. The addresses are compared after both are normalized, so 2001:db8::2 and its full form are one address. The five plugins call mac_of_neighbour. open_tcp_socket opens the callback through IO::Socket::INET6 when it is installed and keeps IO::Socket::INET as the fallback, the way credentials.pm already does; nodediscover.pm and send_tcp_msg use it. networkutils_neighbour_mac.t and networkutils_tcp_callback_family.t fail without this change. Signed-off-by: Daniel Hilst <392820+dhilst@users.noreply.github.com> --- perl-xCAT/xCAT/NetworkUtils.pm | 200 +++++++++++++++++- xCAT-server/lib/xcat/plugins/aaadiscovery.pm | 17 +- xCAT-server/lib/xcat/plugins/blade.pm | 18 +- xCAT-server/lib/xcat/plugins/hpblade.pm | 18 +- xCAT-server/lib/xcat/plugins/nodediscover.pm | 9 +- xCAT-server/lib/xcat/plugins/profilednodes.pm | 17 +- xCAT-server/lib/xcat/plugins/seqdiscovery.pm | 18 +- 7 files changed, 212 insertions(+), 85 deletions(-) diff --git a/perl-xCAT/xCAT/NetworkUtils.pm b/perl-xCAT/xCAT/NetworkUtils.pm index c73c1527db..b0671b25a4 100644 --- a/perl-xCAT/xCAT/NetworkUtils.pm +++ b/perl-xCAT/xCAT/NetworkUtils.pm @@ -23,6 +23,9 @@ use Sys::Hostname; use strict; use warnings "all"; my $socket6support = eval { require Socket6 }; +# IO::Socket::INET6 is optional on an older management node. Without it a +# callback to an IPv6 node cannot be opened at all. +our $inet6support = eval { require IO::Socket::INET6; 1; }; my $core_socket_resolver = defined(&Socket::getaddrinfo) && defined(&Socket::getnameinfo) && defined(&Socket::inet_pton) @@ -4138,6 +4141,155 @@ sub gen_net_boot_params return $net_params; } +#------------------------------------------------------------------------------- + +# A link-layer address, as both tools print it: ethernet is six bytes, and +# InfiniBand is twenty. +our $MAC_ADDRESS_PATTERN = qr/[0-9a-fA-F]{1,2}(?::[0-9a-fA-F]{1,2}){5,19}/; + +=head3 mac_from_neighbour_table + + Description: + The link-layer address a neighbour table holds for one address. + + Arguments: + The text of the table, and the address to look up. + Returns: + The address in lower case, or undef when the table holds none. + + Comments: + Three tools write three formats, and this sub reads all three: + arp -n 192.0.2.10 ether 52:54:00:aa:bb:cc C eth0 + ip neigh show 192.0.2.10 dev eth0 lladdr 52:54:00:aa:bb:cc REACHABLE + ip -6 neigh show 2001:db8::2 dev eth0 lladdr 52:54:00:aa:bb:cc router REACHABLE + The address is compared after both sides are normalized, because + 2001:db8::2 and 2001:0db8:0:0:0:0:0:2 are one address written two ways. + The callers used to interpolate the address into a regular expression, + where every dot matched any character. + +=cut + +#------------------------------------------------------------------------------- +sub mac_from_neighbour_table +{ + my $text = shift; + if (defined($text) && $text eq __PACKAGE__) + { + $text = shift; + } + my $address = shift; + + return unless defined($text) && defined($address); + my $wanted = _canonical_neighbour_address($address); + return unless defined($wanted); + + foreach my $line (split(/\n/, $text)) + { + next unless $line =~ /^\s*(\S+)\s+(\S.*)$/; + my ($entry, $rest) = ($1, $2); + my $found = _canonical_neighbour_address($entry); + next unless defined($found) && $found eq $wanted; + + # ip(8) names the column; arp(8) puts it third, and writes + # "(incomplete)" in place of the type and the address. + return lc($1) if $rest =~ /\blladdr\s+($MAC_ADDRESS_PATTERN)(?:\s|$)/o; + return lc($1) if $rest =~ /^\S+\s+($MAC_ADDRESS_PATTERN)(?:\s|$)/o; + } + return; +} + +#------------------------------------------------------------------------------- + +=head3 neighbour_table_text + + Description: + Reads the neighbour table that holds one address. + + Arguments: + The address to look up. + Returns: + The text of the table, or undef when no tool is available. + + Comments: + arp(8) prints the IPv4 table only, so an IPv6 address needs + "ip -6 neigh show". This keeps the IPv4 path on arp(8). + +=cut + +#------------------------------------------------------------------------------- +sub neighbour_table_text +{ + my $address = shift; + if (defined($address) && $address eq __PACKAGE__) + { + $address = shift; + } + return unless defined($address) && length($address); + + if (xCAT::NetworkUtils->isIpv6addr($address)) + { + my $ipcmd = _neighbour_command('ip'); + return unless $ipcmd; + return scalar(`$ipcmd -6 neigh show`); + } + my $arpcmd = _neighbour_command('arp'); + return unless $arpcmd; + return scalar(`$arpcmd -n`); +} + +#------------------------------------------------------------------------------- + +=head3 mac_of_neighbour + + Description: + The link-layer address of a neighbour, for either address family. + + Arguments: + The address of the neighbour. + Returns: + The address in lower case, or undef. + +=cut + +#------------------------------------------------------------------------------- +sub mac_of_neighbour +{ + my $address = shift; + if (defined($address) && $address eq __PACKAGE__) + { + $address = shift; + } + return mac_from_neighbour_table(neighbour_table_text($address), $address); +} + +sub _neighbour_command +{ + my $name = shift; + foreach my $dir ('/usr/sbin', '/sbin', '/usr/bin', '/bin') + { + return "$dir/$name" if -x "$dir/$name"; + } + return; +} + +# One address written two ways is one address. An IPv6 literal is compared +# after it is packed; an IPv4 one has a single spelling already. +sub _canonical_neighbour_address +{ + my $address = shift; + return unless defined($address) && length($address); + $address =~ s/\%.*//; # a scoped literal, as in fe80::1%eth0 + + if (index($address, ':') >= 0) + { + my $packed = _pack_ip_address($address, 6); + return unless defined($packed) && length($packed) == 16; + return unpack('H*', $packed); + } + return unless xCAT::NetworkUtils->isIpaddr($address); + return $address; +} + #-------------------------------------------------------------------------------- =head3 send_tcp_msg establish a tcp socket to the specified IP address and port, then send the specifid message via the socket @@ -4155,12 +4307,7 @@ sub send_tcp_msg { my $destport=shift; my $msg=shift; - my $sock = new IO::Socket::INET( - PeerAddr => $destip, - PeerPort => $destport, - Timeout => '1', - Proto => 'tcp' - ); + my $sock = xCAT::NetworkUtils->open_tcp_socket($destip, $destport, 1); if ($sock) { print $sock $msg; close($sock); @@ -4170,6 +4317,47 @@ sub send_tcp_msg { } } +#-------------------------------------------------------------------------------- +=head3 open_tcp_socket + Opens a TCP connection to an address of either family. + Arguments: + $address : the destination address, IPv4 or IPv6 + $port : the destination TCP port + $timeout : the connect timeout in seconds, optional + Returns: + the socket, or undef with $! set. + + IO::Socket::INET cannot reach an IPv6 address, so a node discovered over + IPv6 never received its restart message and timed out. IO::Socket::INET6 + is optional on an older management node, so the IPv4 path is the + fallback. +=cut +#-------------------------------------------------------------------------------- +sub open_tcp_socket { + my $address = shift; + if (defined($address) && $address eq __PACKAGE__) + { + $address = shift; + } + my $port = shift; + my $timeout = shift; + + return unless defined($address) && length($address) && defined($port); + my %socket_args = ( + PeerAddr => $address, + PeerPort => $port, + Proto => 'tcp', + ); + $socket_args{Timeout} = $timeout if defined($timeout); + + if ($inet6support) + { + my $sock = IO::Socket::INET6->new(%socket_args); + return $sock if $sock; + } + return IO::Socket::INET->new(%socket_args); +} + #----------------------------------------------------------------------------- =head3 uri_authority diff --git a/xCAT-server/lib/xcat/plugins/aaadiscovery.pm b/xCAT-server/lib/xcat/plugins/aaadiscovery.pm index 55f44162eb..47706cf30b 100644 --- a/xCAT-server/lib/xcat/plugins/aaadiscovery.pm +++ b/xCAT-server/lib/xcat/plugins/aaadiscovery.pm @@ -29,21 +29,10 @@ sub process_request { } my $client_ip = $req->{'_xcat_clientip'}; - my $arptable; - if (-x "/usr/sbin/arp") { - $arptable = `/usr/sbin/arp -n`; - } - else { - $arptable = `/sbin/arp -n`; - } - my @arpents = split /\n/, $arptable; + # arp(8) prints the IPv4 table only, and the address used to be interpolated + # into a regular expression, where every dot matched any character. my $mac; - foreach (@arpents) { - if (m/^($client_ip)\s+\S+\s+(\S+)\s/) { - $mac = $2; - last; - } - } + $mac = xCAT::NetworkUtils->mac_of_neighbour($client_ip); unless ($mac) { xCAT::MsgUtils->message("S", "xcat.discovery.aaadiscovery: Failed to get MAC address for $client_ip in arp cache."); $mac = "$req->{mtm}->[0]*$req->{serial}->[0]"; diff --git a/xCAT-server/lib/xcat/plugins/blade.pm b/xCAT-server/lib/xcat/plugins/blade.pm index a13604c538..b055f47ffd 100644 --- a/xCAT-server/lib/xcat/plugins/blade.pm +++ b/xCAT-server/lib/xcat/plugins/blade.pm @@ -4492,21 +4492,9 @@ sub process_request { $invreq{command} = ['rinv']; my $mac; my $ip = $request->{'_xcat_clientip'}; - my $arptable; - - if (-x "/usr/sbin/arp") { - $arptable = `/usr/sbin/arp -n`; - } - else { - $arptable = `/sbin/arp -n`; - } - my @arpents = split /\n/, $arptable; - foreach (@arpents) { - if (m/^($ip)\s+\S+\s+(\S+)\s/) { - $mac = $2; - last; - } - } + # arp(8) prints the IPv4 table only, and the address used to be interpolated + # into a regular expression, where every dot matched any character. + $mac = xCAT::NetworkUtils->mac_of_neighbour($ip); #Only refresh the the cache when the request permits and no useful answer if ($macmaptimestamp < (time() - 300)) { #after five minutes, invalidate cache diff --git a/xCAT-server/lib/xcat/plugins/hpblade.pm b/xCAT-server/lib/xcat/plugins/hpblade.pm index aceb5d4305..4510ae135c 100644 --- a/xCAT-server/lib/xcat/plugins/hpblade.pm +++ b/xCAT-server/lib/xcat/plugins/hpblade.pm @@ -727,21 +727,9 @@ sub process_request { $invreq{command} = ['rinv']; my $mac; my $ip = $request->{'_xcat_clientip'}; - my $arptable; - - if (-x "/usr/sbin/arp") { - $arptable = `/usr/sbin/arp -n`; - } - else { - $arptable = `/sbin/arp -n`; - } - my @arpents = split /\n/, $arptable; - foreach (@arpents) { - if (m/^($ip)\s+\S+\s+(\S+)\s/) { - $mac = $2; - last; - } - } + # arp(8) prints the IPv4 table only, and the address used to be interpolated + # into a regular expression, where every dot matched any character. + $mac = xCAT::NetworkUtils->mac_of_neighbour($ip); unless ($mac) { return } #Only refresh the the cache when the request permits and no useful answer diff --git a/xCAT-server/lib/xcat/plugins/nodediscover.pm b/xCAT-server/lib/xcat/plugins/nodediscover.pm index 46031bc66a..6812d56b4f 100644 --- a/xCAT-server/lib/xcat/plugins/nodediscover.pm +++ b/xCAT-server/lib/xcat/plugins/nodediscover.pm @@ -537,12 +537,9 @@ sub process_request { } #now, notify the node to continue life - my $sock = new IO::Socket::INET( - PeerAddr => $clientip, - PeerPort => '3001', - Timeout => '1', - Proto => 'tcp' - ); + # IO::Socket::INET cannot reach an IPv6 address, so a node discovered over IPv6 + # never received this message and exited on the discovery timeout. + my $sock = xCAT::NetworkUtils->open_tcp_socket($clientip, 3001, 1); unless ($sock) { xCAT::MsgUtils->message("S", "xcat.discovery.nodediscover: Failed to notify $clientip that it's actually $node. $node has not been discovered: $!"); return; } print $sock $restartstring; close($sock); diff --git a/xCAT-server/lib/xcat/plugins/profilednodes.pm b/xCAT-server/lib/xcat/plugins/profilednodes.pm index 7b97ec5a77..5028d36922 100644 --- a/xCAT-server/lib/xcat/plugins/profilednodes.pm +++ b/xCAT-server/lib/xcat/plugins/profilednodes.pm @@ -1969,20 +1969,9 @@ sub findme { my $ip = $request->{'_xcat_clientip'}; xCAT::MsgUtils->message('S', "Profield nodes discover: _xcat_clientip is $ip.\n"); my $mac = ''; - my $arptable; - if (-x "/usr/sbin/arp") { - $arptable = `/usr/sbin/arp -n`; - } - else { - $arptable = `/sbin/arp -n`; - } - my @arpents = split /\n/, $arptable; - foreach (@arpents) { - if (m/^($ip)\s+\S+\s+(\S+)\s/) { - $mac = $2; - last; - } - } + # arp(8) prints the IPv4 table only, and the address used to be interpolated + # into a regular expression, where every dot matched any character. + $mac = xCAT::NetworkUtils->mac_of_neighbour($ip); if (!$mac) { setrsp_errormsg("Profiled nodes discover: Can not get mac address of this node."); return; diff --git a/xCAT-server/lib/xcat/plugins/seqdiscovery.pm b/xCAT-server/lib/xcat/plugins/seqdiscovery.pm index ddd0c2df2a..625c4e8828 100644 --- a/xCAT-server/lib/xcat/plugins/seqdiscovery.pm +++ b/xCAT-server/lib/xcat/plugins/seqdiscovery.pm @@ -80,21 +80,9 @@ sub findme { xCAT::MsgUtils->message("S", "xcat.discovery.seqdiscovery: ($request->{_xcat_clientmac}->[0]) Error: virtual machines is not supported"); return; } - my $arptable; - if (-x "/usr/sbin/arp") { - $arptable = `/usr/sbin/arp -n`; - } - else { - $arptable = `/sbin/arp -n`; - } - - my @arpents = split /\n/, $arptable; - foreach (@arpents) { - if (m/^($ip)\s+\S+\s+(\S+)\s/) { - $mac = $2; - last; - } - } + # arp(8) prints the IPv4 table only, and the address used to be interpolated + # into a regular expression, where every dot matched any character. + $mac = xCAT::NetworkUtils->mac_of_neighbour($ip); unless ($mac) { xCAT::MsgUtils->message("S", "xcat.discovery.seqdiscovery: ($request->{_xcat_clientmac}->[0]) Error: Could not find mac of the $ip");