3 # $Id: Ping.pm,v 1.27 2002/04/02 02:01:21 rob Exp $
9 use vars qw(@ISA @EXPORT $VERSION
10 $def_timeout $def_proto $max_datasize $pingstring $hires);
12 use Socket qw( SOCK_DGRAM SOCK_STREAM SOCK_RAW PF_INET
13 inet_aton inet_ntoa sockaddr_in );
15 use Errno qw(ECONNREFUSED);
18 @EXPORT = qw(pingecho);
23 $def_timeout = 5; # Default timeout to wait for a reply
24 $def_proto = "udp"; # Default protocol to use for pinging
25 $max_datasize = 1024; # Maximum data bytes in a packet
26 # The data we exchange with the server for the stream protocol
27 $pingstring = "pingschwingping!\n";
29 # Description: The pingecho() subroutine is provided for backward
30 # compatibility with the original Net::Ping. It accepts a host
31 # name/IP and an optional timeout in seconds. Create a tcp ping
32 # object and try pinging the host. The result of the ping is returned.
36 my ($host, # Name or IP number of host to ping
37 $timeout # Optional timeout in seconds
39 my ($p); # A ping object
41 $p = Net::Ping->new("tcp", $timeout);
42 $p->ping($host); # Going out of scope closes the connection
45 # Description: The new() method creates a new ping object. Optional
46 # parameters may be specified for the protocol to use, the timeout in
47 # seconds and the size in bytes of additional data which should be
48 # included in the packet.
49 # After the optional parameters are checked, the data is constructed
50 # and a socket is opened if appropriate. The object is returned.
55 $proto, # Optional protocol to use for pinging
56 $timeout, # Optional timeout in seconds
57 $data_size # Optional additional bytes of data
59 my $class = ref($this) || $this;
61 my ($cnt, # Count through data bytes
62 $min_datasize # Minimum data bytes required
67 $proto = $def_proto unless $proto; # Determine the protocol
68 croak('Protocol for ping must be "icmp", "udp", "tcp", "stream", or "external"')
69 unless $proto =~ m/^(icmp|udp|tcp|stream|external)$/;
70 $self->{"proto"} = $proto;
72 $timeout = $def_timeout unless $timeout; # Determine the timeout
73 croak("Default timeout for ping must be greater than 0 seconds")
75 $self->{"timeout"} = $timeout;
77 $min_datasize = ($proto eq "udp") ? 1 : 0; # Determine data size
78 $data_size = $min_datasize unless defined($data_size) && $proto ne "tcp";
79 croak("Data for ping must be from $min_datasize to $max_datasize bytes")
80 if ($data_size < $min_datasize) || ($data_size > $max_datasize);
81 $data_size-- if $self->{"proto"} eq "udp"; # We provide the first byte
82 $self->{"data_size"} = $data_size;
84 $self->{"data"} = ""; # Construct data bytes
85 for ($cnt = 0; $cnt < $self->{"data_size"}; $cnt++)
87 $self->{"data"} .= chr($cnt % 256);
90 $self->{"local_addr"} = undef; # Don't bind by default
92 $self->{"seq"} = 0; # For counting packets
93 if ($self->{"proto"} eq "udp") # Open a socket
95 $self->{"proto_num"} = (getprotobyname('udp'))[2] ||
96 croak("Can't udp protocol by name");
97 $self->{"port_num"} = (getservbyname('echo', 'udp'))[2] ||
98 croak("Can't get udp echo port by name");
99 $self->{"fh"} = FileHandle->new();
100 socket($self->{"fh"}, PF_INET, SOCK_DGRAM,
101 $self->{"proto_num"}) ||
102 croak("udp socket error - $!");
104 elsif ($self->{"proto"} eq "icmp")
106 croak("icmp ping requires root privilege") if ($> and $^O ne 'VMS');
107 $self->{"proto_num"} = (getprotobyname('icmp'))[2] ||
108 croak("Can't get icmp protocol by name");
109 $self->{"pid"} = $$ & 0xffff; # Save lower 16 bits of pid
110 $self->{"fh"} = FileHandle->new();
111 socket($self->{"fh"}, PF_INET, SOCK_RAW, $self->{"proto_num"}) ||
112 croak("icmp socket error - $!");
114 elsif ($self->{"proto"} eq "tcp" || $self->{"proto"} eq "stream")
116 $self->{"proto_num"} = (getprotobyname('tcp'))[2] ||
117 croak("Can't get tcp protocol by name");
118 $self->{"port_num"} = (getservbyname('echo', 'tcp'))[2] ||
119 croak("Can't get tcp echo port by name");
120 $self->{"fh"} = FileHandle->new();
126 # Description: Set the local IP address from which pings will be sent.
127 # For ICMP and UDP pings, this calls bind() on the already-opened socket;
128 # for TCP pings, just saves the address to be used when the socket is
129 # opened. Returns non-zero if successful; croaks on error.
133 $local_addr # Name or IP number of local interface
135 my ($ip # Packed IP number of $local_addr
138 croak("Usage: \$p->bind(\$local_addr)") unless @_ == 2;
139 croak("already bound") if defined($self->{"local_addr"}) &&
140 ($self->{"proto"} eq "udp" || $self->{"proto"} eq "icmp");
142 $ip = inet_aton($local_addr);
143 croak("nonexistent local address $local_addr") unless defined($ip);
144 $self->{"local_addr"} = $ip; # Only used if proto is tcp
146 if ($self->{"proto"} eq "udp" || $self->{"proto"} eq "icmp")
148 CORE::bind($self->{"fh"}, sockaddr_in(0, $ip)) ||
149 croak("$self->{'proto'} bind error - $!");
151 elsif ($self->{"proto"} ne "tcp")
153 croak("Unknown protocol \"$self->{proto}\" in bind()");
160 # Description: allows the module to use milliseconds as returned by
161 # the Time::HiRes module
167 $hires = 1 unless defined
168 ($hires = ((defined $self) && (ref $self)) ? shift() : $self);
169 require Time::HiRes if $hires;
174 return $hires ? Time::HiRes::time() : CORE::time();
177 # Description: Ping a host name or IP number with an optional timeout.
178 # First lookup the host, and return undef if it is not found. Otherwise
179 # perform the specific ping method based on the protocol. Return the
180 # result of the ping.
185 $host, # Name or IP number of host to ping
186 $timeout, # Seconds after which ping times out
188 my ($ip, # Packed IP number of $host
189 $ret, # The return value
190 $ping_time, # When ping began
193 croak("Usage: \$p->ping(\$host [, \$timeout])") unless @_ == 2 || @_ == 3;
194 $timeout = $self->{"timeout"} unless $timeout;
195 croak("Timeout must be greater than 0 seconds") if $timeout <= 0;
197 $ip = inet_aton($host);
198 return(undef) unless defined($ip); # Does host exist?
200 # Dispatch to the appropriate routine.
201 $ping_time = &time();
202 if ($self->{"proto"} eq "external") {
203 $ret = $self->ping_external($ip, $timeout);
205 elsif ($self->{"proto"} eq "udp") {
206 $ret = $self->ping_udp($ip, $timeout);
208 elsif ($self->{"proto"} eq "icmp") {
209 $ret = $self->ping_icmp($ip, $timeout);
211 elsif ($self->{"proto"} eq "tcp") {
212 $ret = $self->ping_tcp($ip, $timeout);
214 elsif ($self->{"proto"} eq "stream") {
215 $ret = $self->ping_stream($ip, $timeout);
217 croak("Unknown protocol \"$self->{proto}\" in ping()");
220 return wantarray ? ($ret, &time() - $ping_time, inet_ntoa($ip)) : $ret;
223 # Uses Net::Ping::External to do an external ping.
226 $ip, # Packed IP number of the host
227 $timeout # Seconds after which ping times out
230 eval { require Net::Ping::External; }
231 or croak('Protocol "external" not supported on your system: Net::Ping::External not found');
232 return Net::Ping::External::ping(ip => $ip, timeout => $timeout);
235 use constant ICMP_ECHOREPLY => 0; # ICMP packet types
236 use constant ICMP_ECHO => 8;
237 use constant ICMP_STRUCT => "C2 S3 A"; # Structure of a minimal ICMP packet
238 use constant SUBCODE => 0; # No ICMP subcode for ECHO and ECHOREPLY
239 use constant ICMP_FLAGS => 0; # No special flags for send or recv
240 use constant ICMP_PORT => 0; # No port with ICMP
245 $ip, # Packed IP number of the host
246 $timeout # Seconds after which ping times out
249 my ($saddr, # sockaddr_in with port and ip
250 $checksum, # Checksum of ICMP packet
251 $msg, # ICMP packet to send
252 $len_msg, # Length of $msg
253 $rbits, # Read bits, filehandles for reading
254 $nfound, # Number of ready filehandles found
255 $finish_time, # Time ping should be finished
256 $done, # set to 1 when we are done
258 $recv_msg, # Received message including IP header
259 $from_saddr, # sockaddr_in of sender
260 $from_port, # Port packet was sent from
261 $from_ip, # Packed IP of sender
262 $from_type, # ICMP type
263 $from_subcode, # ICMP subcode
264 $from_chk, # ICMP packet checksum
265 $from_pid, # ICMP packet id
266 $from_seq, # ICMP packet sequence
267 $from_msg # ICMP message
270 $self->{"seq"} = ($self->{"seq"} + 1) % 65536; # Increment sequence
271 $checksum = 0; # No checksum for starters
272 $msg = pack(ICMP_STRUCT . $self->{"data_size"}, ICMP_ECHO, SUBCODE,
273 $checksum, $self->{"pid"}, $self->{"seq"}, $self->{"data"});
274 $checksum = Net::Ping->checksum($msg);
275 $msg = pack(ICMP_STRUCT . $self->{"data_size"}, ICMP_ECHO, SUBCODE,
276 $checksum, $self->{"pid"}, $self->{"seq"}, $self->{"data"});
277 $len_msg = length($msg);
278 $saddr = sockaddr_in(ICMP_PORT, $ip);
279 send($self->{"fh"}, $msg, ICMP_FLAGS, $saddr); # Send the message
282 vec($rbits, $self->{"fh"}->fileno(), 1) = 1;
285 $finish_time = &time() + $timeout; # Must be done by this time
286 while (!$done && $timeout > 0) # Keep trying if we have time
288 $nfound = select($rbits, undef, undef, $timeout); # Wait for packet
289 $timeout = $finish_time - &time(); # Get remaining time
290 if (!defined($nfound)) # Hmm, a strange error
295 elsif ($nfound) # Got a packet from somewhere
298 $from_saddr = recv($self->{"fh"}, $recv_msg, 1500, ICMP_FLAGS);
299 ($from_port, $from_ip) = sockaddr_in($from_saddr);
300 ($from_type, $from_subcode, $from_chk,
301 $from_pid, $from_seq, $from_msg) =
302 unpack(ICMP_STRUCT . $self->{"data_size"},
303 substr($recv_msg, length($recv_msg) - $len_msg,
305 if (($from_type == ICMP_ECHOREPLY) &&
307 ($from_pid == $self->{"pid"}) && # Does the packet check out?
308 ($from_seq == $self->{"seq"}))
310 $ret = 1; # It's a winner
314 else # Oops, timed out
322 # Description: Do a checksum on the message. Basically sum all of
323 # the short words and fold the high order bits into the low order bits.
328 $msg # The message to checksum
330 my ($len_msg, # Length of the message
331 $num_short, # The number of short words in the message
332 $short, # One short word
336 $len_msg = length($msg);
337 $num_short = int($len_msg / 2);
339 foreach $short (unpack("S$num_short", $msg))
342 } # Add the odd byte in
343 $chk += (unpack("C", substr($msg, $len_msg - 1, 1)) << 8) if $len_msg % 2;
344 $chk = ($chk >> 16) + ($chk & 0xffff); # Fold high into low
345 return(~(($chk >> 16) + $chk) & 0xffff); # Again and complement
349 # Description: Perform a tcp echo ping. Since a tcp connection is
350 # host specific, we have to open and close each connection here. We
351 # can't just leave a socket open. Because of the robust nature of
352 # tcp, it will take a while before it gives up trying to establish a
353 # connection. Therefore, we use select() on a non-blocking socket to
354 # check against our timeout. No data bytes are actually
355 # sent since the successful establishment of a connection is proof
356 # enough of the reachability of the remote host. Also, tcp is
357 # expensive and doesn't need our help to add to the overhead.
362 $ip, # Packed IP number of the host
363 $timeout # Seconds after which ping times out
365 my ($ret # The return value
369 $ret = $self -> tcp_connect( $ip, $timeout);
370 $ret = 1 if $! == ECONNREFUSED # Connection refused
371 || $@ =~ /Unknown Error/i; # Special Win32 response?
372 $self->{"fh"}->close();
379 $ip, # Packed IP number of the host
380 $timeout # Seconds after which connect times out
382 my ($saddr); # Packed IP and Port
384 $saddr = sockaddr_in($self->{"port_num"}, $ip);
386 my $ret = 0; # Default to unreachable
388 my $do_socket = sub {
389 socket($self->{"fh"}, PF_INET, SOCK_STREAM, $self->{"proto_num"}) ||
390 croak("tcp socket error - $!");
391 if (defined $self->{"local_addr"} &&
392 !CORE::bind($self->{"fh"}, sockaddr_in(0, $self->{"local_addr"}))) {
393 croak("tcp bind error - $!");
396 my $do_connect = sub {
398 die $! unless connect($self->{"fh"}, $saddr);
405 if ($^O =~ /Win32/i) {
407 # Buggy Winsock API doesn't allow us to use alarm() calls.
408 # Hence, if our OS is Windows, we need to create a separate
409 # process to do the blocking connect attempt.
411 $| = 1; # Clear buffer prior to fork to prevent duplicate flushing.
416 warn "Win32 Fork error: $!";
421 # Try a slow blocking connect() call
422 # and report the status to the pipe.
423 if ( &{ $do_connect }() ) {
424 $self->{"fh"}->close();
428 # Pass the error status to the parent
435 my $patience = &time() + $timeout;
440 # Wait up to the timeout
441 # And clean off the zombie
443 $child = waitpid($pid, &POSIX::WNOHANG);
446 select(undef, undef, undef, 0.1);
447 } while &time() < $patience && $child != $pid;
449 if ($child == $pid) {
450 # Since she finished within the timeout,
451 # it is probably safe for me to try it too
454 # Time must have run out.
456 # Put that choking client out of its misery
458 # Clean off the zombie
463 # Otherwise don't waste the resources to fork
467 $SIG{'ALRM'} = sub { die "Timed out!"; };
468 alarm($timeout); # Interrupt connect() if we have to
477 # This writes the given string to the socket and then reads it
478 # back. It returns 1 on success, 0 on failure.
483 my $pingstring = shift;
487 my $wrstr = $pingstring;
493 vec($rin, $self->{"fh"}->fileno(), 1) = 1;
498 vec($rout, $self->{"fh"}->fileno(), 1) = 1;
501 if(select($rin, $rout, undef, ($time + $timeout) - &time())) {
503 if($rout && vec($rout,$self->{"fh"}->fileno(),1)) {
504 my $num = syswrite($self->{"fh"}, $wrstr);
506 # If it was a partial write, update and try again.
507 $wrstr = substr($wrstr,$num);
509 # There was an error.
514 if(vec($rin,$self->{"fh"}->fileno(),1)) {
516 if(sysread($self->{"fh"},$reply,length($pingstring)-length($rdstr))) {
518 $ret = 1 if $rdstr eq $pingstring;
520 # There was an error.
526 } until &time() > ($time + $timeout) || defined($ret);
535 # Description: Perform a stream ping. If the tcp connection isn't
536 # already open, it opens it. It then sends some data and waits for
537 # a reply. It leaves the stream open on exit.
542 $ip, # Packed IP number of the host
543 $timeout # Seconds after which ping times out
546 # Open the stream if it's not already open
547 if(!defined $self->{"fh"}->fileno()) {
548 $self->tcp_connect($ip, $timeout) or return 0;
551 croak "tried to switch servers while stream pinging"
552 if $self->{"ip"} ne $ip;
554 return $self->tcp_echo($timeout, $pingstring);
557 # Description: opens the stream. You would do this if you want to
558 # separate the overhead of opening the stream from the first ping.
563 $host, # Host or IP address
564 $timeout # Seconds after which open times out
567 my ($ip); # Packed IP number of the host
568 $ip = inet_aton($host);
569 $timeout = $self->{"timeout"} unless $timeout;
571 if($self->{"proto"} eq "stream") {
572 if(defined($self->{"fh"}->fileno())) {
573 croak("socket is already open");
575 $self->tcp_connect($ip, $timeout);
581 # Description: Perform a udp echo ping. Construct a message of
582 # at least the one-byte sequence number and any additional data bytes.
583 # Send the message out and wait for a message to come back. If we
584 # get a message, make sure all of its parts match. If they do, we are
585 # done. Otherwise go back and wait for the message until we run out
586 # of time. Return the result of our efforts.
588 use constant UDP_FLAGS => 0; # Nothing special on send or recv
593 $ip, # Packed IP number of the host
594 $timeout # Seconds after which ping times out
597 my ($saddr, # sockaddr_in with port and ip
598 $ret, # The return value
599 $msg, # Message to be echoed
600 $finish_time, # Time ping should be finished
601 $ping_time, # Time ping took to complete
602 $done, # Set to 1 when we are done pinging
603 $rbits, # Read bits, filehandles for reading
604 $nfound, # Number of ready filehandles found
605 $from_saddr, # sockaddr_in of sender
606 $from_msg, # Characters echoed by $host
607 $from_port, # Port message was echoed from
608 $from_ip # Packed IP number of sender
611 $saddr = sockaddr_in($self->{"port_num"}, $ip);
612 $self->{"seq"} = ($self->{"seq"} + 1) % 256; # Increment sequence
613 $msg = chr($self->{"seq"}) . $self->{"data"}; # Add data if any
614 send($self->{"fh"}, $msg, UDP_FLAGS, $saddr); # Send it
617 vec($rbits, $self->{"fh"}->fileno(), 1) = 1;
618 $ret = 0; # Default to unreachable
620 $ping_time = $timeout;
621 $finish_time = &time() + $timeout; # Ping needs to be done by then
622 while (!$done && $timeout > 0)
624 $nfound = select($rbits, undef, undef, $timeout); # Wait for response
625 $timeout = $finish_time - &time(); # Get remaining time
627 if (!defined($nfound)) # Hmm, a strange error
632 elsif ($nfound) # A packet is waiting
635 $from_saddr = recv($self->{"fh"}, $from_msg, 1500, UDP_FLAGS)
636 or last; # For example an unreachable host will make recv() fail.
637 ($from_port, $from_ip) = sockaddr_in($from_saddr);
638 if (($from_ip eq $ip) && # Does the packet check out?
639 ($from_port == $self->{"port_num"}) &&
642 $ret = 1; # It's a winner
646 else # Oops, timed out
651 $ping_time -= $timeout;
652 return wantarray ? ($ret, $ping_time) : $ret;
655 # Description: Close the connection unless we are using the tcp
656 # protocol, since it will already be closed.
662 $self->{"fh"}->close() unless $self->{"proto"} eq "tcp";
671 Net::Ping - check a remote host for reachability
673 $Id: Ping.pm,v 1.27 2002/04/02 02:01:21 rob Exp $
679 $p = Net::Ping->new();
680 print "$host is alive.\n" if $p->ping($host);
683 $p = Net::Ping->new("icmp");
684 $p->bind($my_addr); # Specify source interface of pings
685 foreach $host (@host_array)
688 print "NOT " unless $p->ping($host, 2);
689 print "reachable.\n";
694 $p = Net::Ping->new("tcp", 2);
695 # Try connecting to the www port instead of the echo port
696 $p->{port_num} = getservbyname("http", "tcp");
697 while ($stop_time > time())
699 print "$host not reachable ", scalar(localtime()), "\n"
700 unless $p->ping($host);
705 # High precision syntax (requires Time::HiRes)
706 $p = Net::Ping->new();
708 ($ret, $duration, $ip) = $p->ping($host, 5.5);
709 printf("$host [ip: $ip] is alive (packet return time: %.2f ms)\n", 1000 * $duration)
713 # For backward compatibility
714 print "$host is alive.\n" if pingecho($host);
718 This module contains methods to test the reachability of remote
719 hosts on a network. A ping object is first created with optional
720 parameters, a variable number of hosts may be pinged multiple
721 times and then the connection is closed.
723 You may choose one of four different protocols to use for the
724 ping. The "udp" protocol is the default. Note that a live remote host
725 may still fail to be pingable by one or more of these protocols. For
726 example, www.microsoft.com is generally alive but not pingable.
728 With the "tcp" protocol the ping() method attempts to establish a
729 connection to the remote host's echo port. If the connection is
730 successfully established, the remote host is considered reachable. No
731 data is actually echoed. This protocol does not require any special
732 privileges but has higher overhead than the other two protocols.
734 Specifying the "udp" protocol causes the ping() method to send a udp
735 packet to the remote host's echo port. If the echoed packet is
736 received from the remote host and the received packet contains the
737 same data as the packet that was sent, the remote host is considered
738 reachable. This protocol does not require any special privileges.
739 It should be borne in mind that, for a udp ping, a host
740 will be reported as unreachable if it is not running the
741 appropriate echo service. For Unix-like systems see L<inetd(8)>
742 for more information.
744 If the "icmp" protocol is specified, the ping() method sends an icmp
745 echo message to the remote host, which is what the UNIX ping program
746 does. If the echoed message is received from the remote host and
747 the echoed information is correct, the remote host is considered
748 reachable. Specifying the "icmp" protocol requires that the program
749 be run as root or that the program be setuid to root.
751 If the "external" protocol is specified, the ping() method attempts to
752 use the C<Net::Ping::External> module to ping the remote host.
753 C<Net::Ping::External> interfaces with your system's default C<ping>
754 utility to perform the ping, and generally produces relatively
755 accurate results. If C<Net::Ping::External> if not installed on your
756 system, specifying the "external" protocol will result in an error.
762 =item Net::Ping->new([$proto [, $def_timeout [, $bytes]]]);
764 Create a new ping object. All of the parameters are optional. $proto
765 specifies the protocol to use when doing a ping. The current choices
766 are "tcp", "udp" or "icmp". The default is "udp".
768 If a default timeout ($def_timeout) in seconds is provided, it is used
769 when a timeout is not given to the ping() method (below). The timeout
770 must be greater than 0 and the default, if not specified, is 5 seconds.
772 If the number of data bytes ($bytes) is given, that many data bytes
773 are included in the ping packet sent to the remote host. The number of
774 data bytes is ignored if the protocol is "tcp". The minimum (and
775 default) number of data bytes is 1 if the protocol is "udp" and 0
776 otherwise. The maximum number of data bytes that can be specified is
779 =item $p->hires( { 0 | 1 } );
781 Causes this module to use Time::HiRes module, allowing milliseconds
782 to be returned by subsequent calls to ping().
784 =item $p->bind($local_addr);
786 Sets the source address from which pings will be sent. This must be
787 the address of one of the interfaces on the local host. $local_addr
788 may be specified as a hostname or as a text IP address such as
791 If the protocol is set to "tcp", this method may be called any
792 number of times, and each call to the ping() method (below) will use
793 the most recent $local_addr. If the protocol is "icmp" or "udp",
794 then bind() must be called at most once per object, and (if it is
795 called at all) must be called before the first call to ping() for that
798 =item $p->ping($host [, $timeout]);
800 Ping the remote host and wait for a response. $host can be either the
801 hostname or the IP number of the remote host. The optional timeout
802 must be greater than 0 seconds and defaults to whatever was specified
803 when the ping object was created. Returns a success flag. If the
804 hostname cannot be found or there is a problem with the IP number, the
805 success flag returned will be undef. Otherwise, the success flag will
806 be 1 if the host is reachable and 0 if it is not. For most practical
807 purposes, undef and 0 and can be treated as the same case. In array
808 context, the elapsed time is also returned. The elapsed time value will
809 be a float, as retuned by the Time::HiRes::time() function, if hires()
810 has been previously called, otherwise it is returned as an integer.
812 =item $p->open($host);
814 When you are using the stream protocol, this call pre-opens the
815 tcp socket. It's only necessary to do this if you want to
816 provide a different timeout when creating the connection, or
817 remove the overhead of establishing the connection from the
818 first ping. If you don't call C<open()>, the connection is
819 automatically opened the first time C<ping()> is called.
820 This call simply does nothing if you are using any protocol other
825 Close the network connection for this ping object. The network
826 connection is also closed by "undef $p". The network connection is
827 automatically closed if the ping object goes out of scope (e.g. $p is
828 local to a subroutine and you leave the subroutine).
830 =item pingecho($host [, $timeout]);
832 To provide backward compatibility with the previous version of
833 Net::Ping, a pingecho() subroutine is available with the same
834 functionality as before. pingecho() uses the tcp protocol. The
835 return values and parameters are the same as described for the ping()
836 method. This subroutine is obsolete and may be removed in a future
837 version of Net::Ping.
843 pingecho() or a ping object with the tcp protocol use alarm() to
844 implement the timeout. So, don't use alarm() in your program while
845 you are using pingecho() or a ping object with the tcp protocol. The
846 udp and icmp protocols do not use alarm() to implement the timeout.
850 There will be less network overhead (and some efficiency in your
851 program) if you specify either the udp or the icmp protocol. The tcp
852 protocol will generate 2.5 times or more traffic for each ping than
853 either udp or icmp. If many hosts are pinged frequently, you may wish
854 to implement a small wait (e.g. 25ms or more) between each ping to
855 avoid flooding your network with packets.
857 The icmp protocol requires that the program be run as root or that it
858 be setuid to root. The other protocols do not require special
859 privileges, but not all network devices implement tcp or udp echo.
861 Local hosts should normally respond to pings within milliseconds.
862 However, on a very congested network it may take up to 3 seconds or
863 longer to receive an echo packet from the remote host. If the timeout
864 is set too low under these conditions, it will appear that the remote
865 host is not reachable (which is almost the truth).
867 Reachability doesn't necessarily mean that the remote host is actually
868 functioning beyond its ability to echo packets. tcp is slightly better
869 at indicating the health of a system than icmp because it uses more
870 of the networking stack to respond.
872 Because of a lack of anything better, this module uses its own
873 routines to pack and unpack ICMP packets. It would be better for a
874 separate module to be written which understands all of the different
875 kinds of ICMP packets.
880 bbb@cpan.org (Rob Brown)
883 colinm@cpan.org (Colin McMillen)
886 bronson@trestle.com (Scott Bronson)
889 karrer@bernina.ethz.ch (Andreas Karrer)
890 pmarquess@bfsec.bt.co.uk (Paul Marquess)
892 Original Net::Ping author:
893 mose@ns.ccsn.edu (Russell Mosemann)
897 Copyright (c) 2002, Rob Brown. All rights reserved.
899 Copyright (c) 2001, Colin McMillen. All rights reserved.
901 This program is free software; you may redistribute it and/or
902 modify it under the same terms as Perl itself.