AROS changes

Remove heap manipulation from fast path.

.gitignore

@@ -1,20 +1,3 @@
-*.tar.gz
-*~
-.deps
 Makefile
-Makefile.in
-aclocal.m4
-autom4te.cache
-config.guess
-config.h
-config.h.in
-config.log
-config.status
-config.sub
-configure
-depcomp
-install-sh
-missing
-src/*.o
-src/fping
-stamp-h1
+*.o
+*.kdev4

.travis.yml

@@ -0,0 +1,23 @@
+# travis-ci.org configuration
+# 
+language: c
+env:
+    global:
+        - secure: "CoI8hwHH1yfQoQxIfWGRS0WfTyScox+5aJn0fDDgz2uKrrIxmBvIw/WKX8wcSiV6fLmLuwgNkKqSM3hdO4qaG+JxfWcuEiZZHm+kxSGMkWbGb/fvAI+gHg8ldKyYttcIX71O5rlZiC2QpNKQi2v18S6pI5p8eqnx7DYx4YrmguQ="
+compiler:
+    - gcc
+before_install:
+    - sudo apt-get install libcap2-bin
+    - sudo apt-get install traceroute
+    - traceroute google.com
+install:
+    - ci/build-1-autotools.sh
+    - curl -L http://cpanmin.us | perl - --sudo App::cpanminus
+    - cpanm --sudo Test::Command
+script:
+    - ci/build-2-install.sh
+    - env PATH=`pwd`/src:$PATH prove ci/test-*.pl
+    - ci/test-tarball.sh
+after_success:
+    - ci/coveralls.sh
+    - ci/deploy-bintray.sh

COPYING

@@ -1,5 +1,9 @@
-
-/*
+ * Original author:  Roland Schemers  <schemers@stanford.edu>
+ * IPv6 Support:     Jeroen Massar    <jeroen@unfix.org / jeroen@ipng.nl>
+ * Improved main loop: David Schweikert <david@schweikert.ch>
+ * Debian Merge, TOS settings: Tobi Oetiker <tobi@oetiker.ch>
+ * Bugfixes, byte order & senseful seq.-numbers: Stephan Fuhrmann (stephan.fuhrmann AT 1und1.de)
+ *
  * Redistribution and use in source and binary forms are permitted
  * provided that the above copyright notice and this paragraph are
  * duplicated in all such forms and that any documentation,
@@ -11,5 +15,3 @@
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
- */
-

ChangeLog

@@ -1,5 +1,92 @@
-2012-05-22  David Schweikert  <david@schweikert.ch>
-  * Version 3.2rc1
+2015-10-21  David Schweikert  <david@schweikert.ch>
+  * Version 3.13
+  * (bugfix) Fix ICMP errors sometimes causing crashes with fping >= 3.11
+             (fixes #85, reported by Jamie Heilman and Bill Blough)
+
+2015-10-14  David Schweikert  <david@schweikert.ch>
+  * Version 3.12
+  * (bugfix) Fix fping6 -R (fixes #84, reported by Stuart Henderson)
+
+2015-10-12  David Schweikert  <david@schweikert.ch>
+  * Version 3.11
+  * (feature)  New option -R to use random bytes instead of NULLs (#72, Anthony DeRobertis)
+  * (feature)  Small documentation and performance improvements (Ryan Underwood)
+  * (bugfix)   Fix double entries with fping -u and unreachable hosts
+  * (internal) Use sockaddr_storage and simplify code, so that we can one day support both IPv4 and IPv6 with the same binary
+
+2014-05-03  David Schweikert  <david@schweikert.ch>
+  * Version 3.10
+  * Fix confusing error message with -g and IPv6 addresses (#58, reported by Axel Beckert)
+  * Allow option '-f' also for non-root (since setuid privileges are dropped)
+  * Do not retry twice DNS lookup on DNS lookup problem
+  * Remove support for NIS groups
+  * Better document -B backoff-factor and when it can be used (#33, Oleksiy Zagorskyi)
+  * More tests added
+
+2014-03-08  David Schweikert  <david@schweikert.ch>
+  * Version 3.9
+  * Fix random output on socket error (reported by Aleksandrs Saveljevs, #56)
+  * Support ppc64le architecture by including alpha libtool version
+    (reported by Amit Kumar Gupta and Aravinda B Thunug)
+  * Fix compilation problem on FreeBSD (#57)
+  * Initial test suite and continous intergration (with travis-ci.org / coveralls.io)
+  * Don't output usage information on error
+
+2013-11-08  David Schweikert  <david@schweikert.ch>
+  * Version 3.8
+  * Fix segmentation fault introduced in version 3.7 with loop mode (reported
+    by Vlad Glagolev, #55)
+
+2013-11-04  David Schweikert  <david@schweikert.ch>
+  * Version 3.7
+  * Allow running as non-root on Mac OS X by using non-privileged ICMP (#7)
+  * Remove unnecessary IPv6 socket options
+  * Fix again compatibility issue with FreeBSD (Shawn Chu)
+  * Fix fping hanging forever on permanent sendto failure (Shawn Chu)
+  * Fix duplicate echo reply packets causing early stop in count mode
+    (reported by Ramon Schwammberger, #53)
+
+2013-10-10  David Schweikert  <david@schweikert.ch>
+  * Version 3.6
+  * Fix loop issue after 65536 pings (reported by Peter Folk and GBert, #12)
+  * Minimum ping data size is now 0
+  * Removed setsockopt IPV6_CHECKSUM, which shouldn't be set and breaks
+    compiling on Solaris (reported by Juergen Arndt)
+  * Fix wrong min RTT value with -Q option (reported by Alexander Ivanov, #51)
+
+2013-05-22  David Schweikert  <david@schweikert.ch>
+  * Version 3.5
+  * Fix sprint_tm buffer size crash (reported by Japheth Cleaver)
+  * Addded -D flag to print timestamps (Toke Høiland-Jørgensen)
+  * Fix fping6 build on OS X 10.8 (unknown contributor)
+  * Fix compatibility issue with FreeBSD (Alexandre Raynaud, Jason Harris, #39)
+  * Fping.spec: fix setuid permissions and provides fping6 (Marcus Vinicius Ferreira)
+  * Re-create configure script with autoconf 2.69 for aarch64 support (Chuck Anderson, #45)
+
+2012-09-04  David Schweikert  <david@schweikert.ch>
+  * Version 3.4
+  * Revert "Output statistics to stdout instead of stderr", because it breaks
+    tools assuming the output goes to stderr
+
+2012-08-19  David Schweikert  <david@schweikert.ch>
+  * Version 3.3
+  * Do not output icmp errors with -q (#1)
+  * Add --enable-ipv4 and --enable-ipv6 options to configure (Niclas Zeising)
+  * Fix removing of unreachable hosts when doing loop (Thomas Liske, #13 #23)
+  * Fix -A for fping6 (reported by Matt LaPlante, #14)
+  * Fix "options inet6" breaking IPv4 name resolution (reported by Matt LaPlante, #17)
+  * Output statistics to stdout instead of stderr (suggested by Simon Leinen, #9)
+  * Set default data size to 56 bytes on all architectures (#18)
+  * Added contrib/fping.spec (Stephen Schaefer, #24)
+  * Convert man-page source to POD for easier maintenance
+  * Fix error message on DNS error for IPv6 hosts (#27)
+  * Fix -n flag in fping6 (#28)
+  * Man-page fix: TOS option typo (Thomas Liske, #23)
+  * Man-page fix: inconsistency in regards to numeric arguments (Robert Henney)
+  * Man-page fix: better description of option -q (#15)
+
+2012-05-29  David Schweikert  <david@schweikert.ch>
+  * Version 3.2
   * Improve documentation for -g option (G.W. Haywood)
   * Performance optimization for big select timeouts (#10, Andrey Bondarenko)
   * Fix restart of select call after interrupt signal (#8, Boian Bonev)

README

@@ -1,35 +0,0 @@
-fping 3 README
---------------
-fping is a program to send ICMP echo probes to network hosts, similar to ping,
-but much better performing when pinging multiple hosts. fping has a long long
-story: Roland Schemers did publish a first version of it in 1992 and it has
-established itself since then as a standard tool.
-
-Current maintainer:
-   David Schweikert <david@schweikert.ch>
-
-Website:
-   http://www.fping.org
-
-Installation
-------------
-If you want to install fping from source, proceed as follows:
-
-1. Run ./configure with the correct arguments
-   (see: ./configure --help)
-
-2. Run make; make install
-
-3. Make fping either setuid, or, if under Linux:
-
-   sudo setcap cap_net_raw+ep fping
-
-4. Have a look at the fping(1) manual for usage help
-   (fping -h will also give a minimal help output)
-
-Credits
--------
-Original author:  Roland Schemers (schemers@stanford.edu)
-Previous maintainer:  RL "Bob" Morgan (morgan@stanford.edu)
-IPv6 Support: Jeroen Massar (jeroen@unfix.org / jeroen@ipng.nl)
-              to enable IPV6 compile with -DIPV6                          

README.md

@@ -0,0 +1,21 @@
+# fping 3
+
+fping is a program to send ICMP echo probes to network hosts, similar to ping,
+but much better performing when pinging multiple hosts. fping has a long long
+story: Roland Schemers did publish a first version of it in 1992 and it has
+established itself since then as a standard tool.
+
+_Current maintainer_:  
+  David Schweikert \<david@schweikert.ch\>
+
+_Website_:  
+  http://fping.org/
+
+_Mailing-list_:  
+  https://groups.google.com/group/fping-users
+
+## Credits
+Original author:  Roland Schemers (schemers@stanford.edu)
+Previous maintainer:  RL "Bob" Morgan (morgan@stanford.edu)
+Initial IPv6 Support: Jeroen Massar (jeroen@unfix.org / jeroen@ipng.nl)
+Other contributors: see ChangeLog

autoclean.sh

@@ -1,4 +1,5 @@
 #!/bin/sh
+[ -f Makefile ] && make clean
 rm -f Makefile
 rm -f Makefile.in
 rm -f aclocal.m4
@@ -17,3 +18,7 @@ rm -f mkinstalldirs
 rm -f stamp-h1
 rm -f doc/Makefile.in
 rm -f src/Makefile.in
+rm -f doc/fping.8
+rm -f src/*.gcda
+rm -f src/*.gcno
+rm -f src/*.gcov

ci/build-1-autotools.sh

@@ -0,0 +1,54 @@
+#!/bin/bash -e
+
+AUTOCONF=http://ftp.gnu.org/gnu/autoconf/autoconf-2.69.tar.gz
+AUTOMAKE=http://ftp.gnu.org/gnu/automake/automake-1.14.1.tar.gz
+LIBTOOL=http://alpha.gnu.org/gnu/libtool/libtool-2.4.2.418.tar.gz
+PREFIX=$(pwd)/ci/build
+PATH=$(pwd)/ci/build/bin:$PATH
+
+if [ ! -d ci ]; then
+    echo "you must run this in the root fping directory" >&2
+    exit 1
+fi
+
+# remove standard versions
+sudo apt-get remove -qq autoconf automake autotools-dev libtool
+
+# prepare build environment
+cd ci
+rm -rf build
+mkdir -p build/src
+cd build/src
+
+# autoconf
+(
+AUTOCONF_FILE=$(basename $AUTOCONF)
+AUTOCONF_DIR=$(echo $AUTOCONF_FILE | sed -e 's/\.tar.*//')
+wget $AUTOCONF
+tar xf $AUTOCONF_FILE
+cd $AUTOCONF_DIR
+./configure --prefix=$PREFIX
+make install
+)
+
+# automake
+(
+AUTOMAKE_FILE=$(basename $AUTOMAKE)
+AUTOMAKE_DIR=$(echo $AUTOMAKE_FILE | sed -e 's/\.tar.*//')
+wget $AUTOMAKE
+tar xf $AUTOMAKE_FILE
+cd $AUTOMAKE_DIR
+./configure --prefix=$PREFIX
+make install
+)
+
+# libtool
+(
+LIBTOOL_FILE=$(basename $LIBTOOL)
+LIBTOOL_DIR=$(echo $LIBTOOL_FILE | sed -e 's/\.tar.*//')
+wget $LIBTOOL
+tar xf $LIBTOOL_FILE
+cd $LIBTOOL_DIR
+./configure --prefix=$PREFIX
+make install
+)

ci/build-2-install.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+set -x
+
+PATH=$(pwd)/ci/build/bin:$PATH
+
+if [ ! -d ci ]; then
+    echo "you must run this in the root fping directory" >&2
+    exit 1
+fi
+
+autoreconf -i
+./configure --enable-ipv4 --enable-ipv6 --prefix=/opt/fping
+make CFLAGS="-g -fprofile-arcs -ftest-coverage"
+## setcap currently doesn't worn anymore on travis-ci
+#sudo setcap cap_net_raw+ep src/fping
+#sudo setcap cap_net_raw+ep src/fping6
+## setcap debugging:
+#pwd
+#df -k .
+#which setcap
+#uname -a
+#mount
+#
+#sudo apt-get install strace
+#sudo strace setcap cap_net_raw+ep src/fping
+
+# use setuid, since setcap is not available
+sudo chown root src/fping
+sudo chown root src/fping6
+sudo chmod u+s  src/fping
+sudo chmod u+s  src/fping6

ci/coveralls.sh

@@ -0,0 +1,13 @@
+#!/bin/sh
+
+set -x
+
+sudo pip install cpp-coveralls --use-mirrors
+
+cd src
+
+ls -l
+
+gcov *.o
+cd ..
+coveralls --exclude ci --no-gcov

ci/deploy-bintray.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+# upload to bintray.com/schweikert
+
+set -e
+
+# do this only for the gcc run
+if [ "$CC" != "gcc" ]; then
+    echo "skipped upload because $CC != gcc"
+    exit 0
+fi
+
+# do this only for the master branch
+if [ "$TRAVIS_BRANCH" != "master" ]; then
+    echo "skipped upload branch $TRAVIS_BRANCH isn't master"
+    exit 0
+fi
+
+VERSION=$(ls fping-*.tar.gz | sed -e 's/^fping-//' | sed -e 's/\.tar\.gz$//')
+if [[ "$VERSION" =~ ^[0-9]+\.[0-9]+$ ]]; then
+    REPO=release
+else
+    REPO=beta
+fi
+curl -T fping-$VERSION.tar.gz -uschweikert:$BINTRAY_API_KEY https://api.bintray.com/content/schweikert/$REPO/fping/$VERSION/fping-$VERSION.tar.gz
+echo

ci/prepare-linux.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+sudo setcap cap_net_raw+ep src/fping
+sudo setcap cap_net_raw+ep src/fping6
+
+if [[ ! $PATH =~ fping/src ]]; then
+    echo "# WARNING: must set PATH:"
+    echo PATH=/home/dws/checkouts/fping/src:\$PATH
+fi

ci/prepare-macos.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+# only do this on Mac OS X
+if [ `uname -s` != "Darwin" ]; then
+    exit 0;
+fi
+
+if [[ ! `ifconfig lo0` =~ 127\.0\.0\.2 ]]; then
+    sudo ifconfig lo0 127.0.0.2/8 alias
+    sudo ifconfig lo0 127.0.0.3/8 alias
+    sudo ifconfig lo0 127.0.0.4/8 alias
+    sudo ifconfig lo0 127.0.0.5/8 alias
+fi 
+
+if [[ ! $PATH =~ /Users/dws/checkouts/fping/src ]]; then
+    echo "# WARNING: must set PATH:"
+    echo PATH=/Users/dws/checkouts/fping/src:\$PATH
+fi

ci/test-01-basics.pl

@@ -0,0 +1,24 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 9;
+
+# ping 127.0.0.1
+my $cmd1 = Test::Command->new(cmd => "fping 127.0.0.1");
+$cmd1->exit_is_num(0);
+$cmd1->stdout_is_eq("127.0.0.1 is alive\n");
+$cmd1->stderr_is_eq("");
+
+# ping ::1
+my $cmd2 = Test::Command->new(cmd => "fping6 ::1");
+$cmd2->exit_is_num(0);
+$cmd2->stdout_is_eq("::1 is alive\n");
+$cmd2->stderr_is_eq("");
+
+# ping 3 times 127.0.0.1
+my $cmd3 = Test::Command->new(cmd => "fping -p 100 -C3 127.0.0.1");
+$cmd3->exit_is_num(0);
+$cmd3->stdout_like(qr{127\.0\.0\.1 : \[0\], 84 bytes, 0\.\d+ ms \(0\.\d+ avg, 0% loss\)
+127\.0\.0\.1 : \[1\], 84 bytes, 0\.\d+ ms \(0.\d+ avg, 0% loss\)
+127\.0\.0\.1 : \[2\], 84 bytes, 0\.\d+ ms \(0.\d+ avg, 0% loss\)
+});
+$cmd3->stderr_like(qr{127\.0\.0\.1 : 0\.\d+ 0\.\d+ 0\.\d+\n});

ci/test-02-help.pl

@@ -0,0 +1,65 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 9;
+
+my $I_HELP = "   -I if      bind to a particular interface\n";
+$I_HELP = '' if $^O eq 'darwin';
+
+# fping -h
+my $cmd1 = Test::Command->new(cmd => "fping -h");
+$cmd1->exit_is_num(0);
+$cmd1->stdout_is_eq(<<END);
+
+Usage: fping [options] [targets...]
+   -a         show targets that are alive
+   -A         show targets by address
+   -b n       amount of ping data to send, in bytes (default 56)
+   -B f       set exponential backoff factor to f
+   -c n       count of pings to send to each target (default 1)
+   -C n       same as -c, report results in verbose format
+   -D         print timestamp before each output line
+   -e         show elapsed time on return packets
+   -f file    read list of targets from a file ( - means stdin) (only if no -g specified)
+   -g         generate target list (only if no -f specified)
+                (specify the start and end IP in the target list, or supply a IP netmask)
+                (ex. fping -g 192.168.1.0 192.168.1.255 or fping -g 192.168.1.0/24)
+   -H n       Set the IP TTL value (Time To Live hops)
+   -i n       interval between sending ping packets (in millisec) (default 25)
+${I_HELP}   -l         loop sending pings forever
+   -m         ping multiple interfaces on target host
+   -n         show targets by name (-d is equivalent)
+   -O n       set the type of service (tos) flag on the ICMP packets
+   -p n       interval between ping packets to one target (in millisec)
+                (in looping and counting modes, default 1000)
+   -q         quiet (don't show per-target/per-ping results)
+   -Q n       same as -q, but show summary every n seconds
+   -r n       number of retries (default 3)
+   -R         random packet data (to foil link data compression)
+   -s         print final stats
+   -S addr    set source address
+   -t n       individual target initial timeout (in millisec) (default 500)
+   -T n       ignored (for compatibility with fping 2.4)
+   -u         show targets that are unreachable
+   -v         show version
+   targets    list of targets to check (if no -f specified)
+
+END
+$cmd1->stderr_is_eq("");
+
+# fping -v
+my $cmd2 = Test::Command->new(cmd => "fping -v");
+$cmd2->exit_is_num(0);
+$cmd2->stdout_like(qr{fping: Version \S+
+fping: comments to david\@schweikert\.ch\n});
+$cmd2->stderr_is_eq("");
+
+# fping with unknown option
+my $cmd3 = Test::Command->new(cmd => "fping -Z");
+$cmd3->exit_is_num(1);
+$cmd3->stdout_is_eq("");
+if($^O eq 'darwin') {
+    $cmd3->stderr_is_eq("fping: illegal option -- Z\nsee 'fping -h' for usage information\n");
+}
+else {
+    $cmd3->stderr_is_eq("fping: invalid option -- 'Z'\nsee 'fping -h' for usage information\n");
+}

ci/test-03-forbidden.pl

@@ -0,0 +1,82 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 33;
+
+# fping -i 9
+my $cmd1 = Test::Command->new(cmd => "fping -i 9 -T10 -g 127.0.0.1/29");
+$cmd1->exit_is_num(1);
+$cmd1->stdout_is_eq("");
+$cmd1->stderr_is_eq(<<END);
+fping: these options are too risky for mere mortals.
+fping: You need i >= 10, p >= 20, r < 20, and t >= 50
+END
+
+# fping -p 15
+my $cmd2 = Test::Command->new(cmd => "fping -c3 -p 15 127.0.0.1");
+$cmd2->exit_is_num(1);
+$cmd2->stdout_is_eq("");
+$cmd2->stderr_is_eq(<<END);
+fping: these options are too risky for mere mortals.
+fping: You need i >= 10, p >= 20, r < 20, and t >= 50
+END
+
+# fping -r 30
+my $cmd3 = Test::Command->new(cmd => "fping -r 30 127.0.0.1");
+$cmd3->exit_is_num(1);
+$cmd3->stdout_is_eq("");
+$cmd3->stderr_is_eq(<<END);
+fping: these options are too risky for mere mortals.
+fping: You need i >= 10, p >= 20, r < 20, and t >= 50
+END
+
+# fping -t 40
+my $cmd4 = Test::Command->new(cmd => "fping -t 40 127.0.0.1");
+$cmd4->exit_is_num(1);
+$cmd4->stdout_is_eq("");
+$cmd4->stderr_is_eq(<<END);
+fping: these options are too risky for mere mortals.
+fping: You need i >= 10, p >= 20, r < 20, and t >= 50
+END
+
+# fping -H 300
+my $cmd5 = Test::Command->new(cmd => "fping -H 300 127.0.0.1");
+$cmd5->exit_is_num(1);
+$cmd5->stdout_is_eq("");
+$cmd5->stderr_is_eq("ttl 300 out of range\n");
+
+# fping -a -u
+my $cmd6 = Test::Command->new(cmd => "fping -a -u 127.0.0.1");
+$cmd6->exit_is_num(1);
+$cmd6->stdout_is_eq("");
+$cmd6->stderr_is_eq("fping: specify only one of a, u\n");
+
+# fping -c -l
+my $cmd7 = Test::Command->new(cmd => "fping -c3 -l 127.0.0.1");
+$cmd7->exit_is_num(1);
+$cmd7->stdout_is_eq("");
+$cmd7->stderr_is_eq("fping: specify only one of c, l\n");
+
+# fping -b 65509
+my $cmd8 = Test::Command->new(cmd => "fping -b 65509 127.0.0.1");
+$cmd8->exit_is_num(1);
+$cmd8->stdout_is_eq("");
+$cmd8->stderr_is_eq("fping: data size 65509 not valid, must be between 0 and 65508\n");
+
+# fping -B 0.9
+my $cmd9 = Test::Command->new(cmd => "fping -B 0.9 127.0.0.1");
+$cmd9->exit_is_num(1);
+$cmd9->stdout_is_eq("");
+$cmd9->stderr_is_eq("fping: backoff factor 0.9 not valid, must be between 1.0 and 5.0\n");
+
+# fping -B 0.9
+my $cmd10 = Test::Command->new(cmd => "fping -B 5.1 127.0.0.1");
+$cmd10->exit_is_num(1);
+$cmd10->stdout_is_eq("");
+$cmd10->stderr_is_eq("fping: backoff factor 5.1 not valid, must be between 1.0 and 5.0\n");
+
+# fping -C 11000
+my $cmd11 = Test::Command->new(cmd => "fping -C 11000 127.0.0.1");
+$cmd11->exit_is_num(1);
+$cmd11->stdout_is_eq("");
+$cmd11->stderr_is_eq("fping: count 11000 not valid, must be less than 10000\n");
+

ci/test-04-options-a-b.pl

@@ -0,0 +1,47 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 14;
+use Test::More;
+use Time::HiRes qw(gettimeofday tv_interval);
+
+#  -a         show targets that are alive
+#  -A         show targets by address
+#  -b n       amount of ping data to send, in bytes (default 56)
+#  -B f       set exponential backoff factor to f
+
+# fping -a
+{
+my $cmd = Test::Command->new(cmd => "fping -a 127.0.0.1 127.0.0.2");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1\n127.0.0.2\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -A
+{
+my $cmd = Test::Command->new(cmd => "fping -A localhost");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -b
+{
+my $cmd = Test::Command->new(cmd => "fping -b 1000 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -B
+{
+my $t0 = [gettimeofday];
+my $cmd = Test::Command->new(cmd => "fping  -t 100 -r 3 -B 2  8.8.8.7");
+$cmd->exit_is_num(1);
+$cmd->stdout_is_eq("8.8.8.7 is unreachable\n");
+$cmd->stderr_like(qr{^(|(8.8.8.7: error while sending ping: No route to host\n)+)$});
+my $elapsed = tv_interval($t0);
+# 0.1 + 0.2 + 0.4 + 0.8 = 1.5
+cmp_ok($elapsed, '>=', 1.5);
+cmp_ok($elapsed, '<', 1.8);
+}

ci/test-05-options-c-e.pl

@@ -0,0 +1,60 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 12;
+
+#  -c n       count of pings to send to each target (default 1)
+#  -C n       same as -c, report results in verbose format
+#  -D         print timestamp before each output line
+#  -e         show elapsed time on return packets
+
+# fping -c n
+{
+my $cmd = Test::Command->new(cmd => "fping -c 2 -p 100 localhost 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_like(qr{localhost : \[0\], 84 bytes, 0\.\d+ ms \(0\.\d+ avg, 0% loss\)
+127\.0\.0\.1 : \[0\], 84 bytes, 0\.\d+ ms \(0.\d+ avg, 0% loss\)
+localhost : \[1\], 84 bytes, 0\.\d+ ms \(0\.\d+ avg, 0% loss\)
+127\.0\.0\.1 : \[1\], 84 bytes, 0\.\d+ ms \(0\.\d+ avg, 0% loss\)
+});
+
+$cmd->stderr_like(qr{localhost : xmt/rcv/%loss = 2/2/0%, min/avg/max = 0\.\d+/0\.\d+/0\.\d+
+127\.0\.0\.1 : xmt/rcv/%loss = 2/2/0%, min/avg/max = 0\.\d+/0\.\d+/0\.\d+
+});
+}
+
+# fping -C n
+{
+my $cmd = Test::Command->new(cmd => "fping -C 2 -p 100 localhost 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_like(qr{localhost : \[0\], 84 bytes, 0\.\d+ ms \(0\.\d+ avg, 0% loss\)
+127\.0\.0\.1 : \[0\], 84 bytes, 0\.\d+ ms \(0.\d+ avg, 0% loss\)
+localhost : \[1\], 84 bytes, 0\.\d+ ms \(0\.\d+ avg, 0% loss\)
+127\.0\.0\.1 : \[1\], 84 bytes, 0\.\d+ ms \(0\.\d+ avg, 0% loss\)
+});
+
+$cmd->stderr_like(qr{localhost : 0\.\d+ 0\.\d+
+127\.0\.0\.1 : 0\.\d+ 0\.\d+
+});
+}
+
+# fping -D
+{
+my $cmd = Test::Command->new(cmd => "fping -D -c 2 -p 100 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_like(qr{\[\d{10}\.\d+\] 127\.0\.0\.1 : \[0\], 84 bytes, 0\.\d+ ms \(0.\d+ avg, 0% loss\)
+\[\d{10}\.\d+\] 127\.0\.0\.1 : \[1\], 84 bytes, 0\.\d+ ms \(0\.\d+ avg, 0% loss\)
+});
+
+$cmd->stderr_like(qr{127\.0\.0\.1 : xmt/rcv/%loss = 2/2/0%, min/avg/max = 0\.\d+/0\.\d+/0\.\d+
+});
+}
+
+# fping -e
+{
+my $cmd = Test::Command->new(cmd => "fping -e 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_like(qr{127\.0\.0\.1 is alive \(0\.\d+ ms\)
+});
+
+$cmd->stderr_is_eq("");
+}

ci/test-06-options-f-h.pl

@@ -0,0 +1,62 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 18;
+use File::Temp;
+
+#  -f file    read list of targets from a file ( - means stdin) (only if no -g specified)
+#  -g         generate target list (only if no -f specified)
+#               (specify the start and end IP in the target list, or supply a IP netmask)
+#               (ex. ../src/fping -g 192.168.1.0 192.168.1.255 or ../src/fping -g 192.168.1.0/24)
+#  -H n       Set the IP TTL value (Time To Live hops)
+
+my $tmpfile = File::Temp->new();
+print $tmpfile "127.0.0.1\n127.0.0.2\n";
+close($tmpfile);
+
+# fping without option (-> equivalent to 'fping -f -')
+{
+my $cmd = Test::Command->new(cmd => "cat ".$tmpfile->filename." | fping");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n127.0.0.2 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -f -
+{
+my $cmd = Test::Command->new(cmd => "cat ".$tmpfile->filename." | fping -f -");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n127.0.0.2 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -f file
+{
+my $cmd = Test::Command->new(cmd => "fping -f ".$tmpfile->filename);
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n127.0.0.2 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -g (range)
+{
+my $cmd = Test::Command->new(cmd => "fping -g 127.0.0.1 127.0.0.5");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n127.0.0.2 is alive\n127.0.0.3 is alive\n127.0.0.4 is alive\n127.0.0.5 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -g (cidr)
+{
+my $cmd = Test::Command->new(cmd => "fping -g 127.0.0.1/30");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n127.0.0.2 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -H
+{
+my $cmd = Test::Command->new(cmd => "fping -H 1 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n");
+$cmd->stderr_is_eq("");
+}

ci/test-07-options-i-m.pl

@@ -0,0 +1,25 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 4;
+
+#  -i n       interval between sending ping packets (in millisec) (default 25)
+#  -l         loop sending pings forever
+#  -m         ping multiple interfaces on target host
+
+# fping -i n
+{
+my $cmd = Test::Command->new(cmd => "fping -i 100 127.0.0.1 127.0.0.2");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n127.0.0.2 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -l
+{
+my $cmd = Test::Command->new(cmd => '(sleep 2; pkill fping)& fping -p 900 -l 127.0.0.1');
+$cmd->stdout_like(qr{127\.0\.0\.1 : \[0\], 84 bytes, 0\.\d+ ms \(0.\d+ avg, 0% loss\)
+127\.0\.0\.1 : \[1\], 84 bytes, 0\.\d+ ms \(0\.\d+ avg, 0% loss\)
+});
+}
+
+# fping -m -> test-14-internet-hosts

ci/test-08-options-n-q.pl

@@ -0,0 +1,42 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 9;
+
+#  -n         show targets by name (-d is equivalent)
+#  -O n       set the type of service (tos) flag on the ICMP packets
+#  -p n       interval between ping packets to one target (in millisec)
+#               (in looping and counting modes, default 1000)
+#  -q         quiet (don't show per-target/per-ping results)
+#  -Q n       same as -q, but show summary every n seconds
+
+# fping -n -> test-14-internet-hosts
+
+# fping -O
+{
+my $cmd = Test::Command->new(cmd => "fping -O 2 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -q
+{
+my $cmd = Test::Command->new(cmd => "fping -q -p 100 -c 3 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("");
+$cmd->stderr_like(qr{127\.0\.0\.1 : xmt/rcv/%loss = 3/3/0%, min/avg/max = 0\.\d+/0\.\d+/0\.\d+
+});
+}
+
+# fping -Q
+{
+my $cmd = Test::Command->new(cmd => "fping -Q 1 -p 400 -c 4 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("");
+$cmd->stderr_like(qr{\[\d+:\d+:\d+\]
+127\.0\.0\.1 : xmt/rcv/%loss = 3/3/0%, min/avg/max = 0\.\d+/0\.\d+/0\.\d+
+127\.0\.0\.1 : xmt/rcv/%loss = 4/4/0%, min/avg/max = 0\.\d+/0\.\d+/0\.\d+
+});
+}
+
+

ci/test-09-option-r-t.pl

@@ -0,0 +1,92 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 18;
+
+#  -R         random bytes
+#  -r n       number of retries (default 3)
+#  -s         print final stats
+#  -S addr    set source address
+#  -t n       individual target initial timeout (in millisec) (default 500)
+#  -T n       ignored (for compatibility with fping 2.4)
+
+# fping -R
+{
+my $cmd = Test::Command->new(cmd => "fping -q -R -c3 -p100 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("");
+$cmd->stderr_like(qr{127\.0\.0\.1 : xmt/rcv/%loss = 3/3/0%.*});
+}
+
+# fping6 -R
+{
+my $cmd = Test::Command->new(cmd => "fping6 -q -R -c3 -p100 ::1");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("");
+$cmd->stderr_like(qr{::1 : xmt/rcv/%loss = 3/3/0%.*});
+}
+
+# fping -r tested in test-4-options-a-b.pl
+
+# fping -s
+{
+my $cmd = Test::Command->new(cmd => "fping -s 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n");
+$cmd->stderr_like(qr{\s*
+\s*1 targets
+\s*1 alive
+\s*0 unreachable
+\s*0 unknown addresses
+\s*
+\s*0 timeouts \(waiting for response\)
+\s*1 ICMP Echos sent
+\s*1 ICMP Echo Replies received
+\s*0 other ICMP received
+
+\s*0.\d+ ms \(min round trip time\)
+\s*0.\d+ ms \(avg round trip time\)
+\s*0.\d+ ms \(max round trip time\)
+\s*0.\d+ sec \(elapsed real time\)
+});
+}
+
+# fping -s (no host reachable)
+{
+my $cmd = Test::Command->new(cmd => "fping -r0 -t100 -s 8.8.0.0");
+$cmd->exit_is_num(1);
+$cmd->stdout_is_eq("8.8.0.0 is unreachable\n");
+$cmd->stderr_like(qr{\s*
+\s*1 targets
+\s*0 alive
+\s*1 unreachable
+\s*0 unknown addresses
+\s*
+\s*1 timeouts \(waiting for response\)
+\s*1 ICMP Echos sent
+\s*0 ICMP Echo Replies received
+\s*0 other ICMP received
+
+\s*0.\d+ ms \(min round trip time\)
+\s*0.\d+ ms \(avg round trip time\)
+\s*0.\d+ ms \(max round trip time\)
+\s*0.\d+ sec \(elapsed real time\)
+});
+}
+
+# fping -S
+{
+my $cmd = Test::Command->new(cmd => "fping -S 127.0.0.1 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping6 -S
+{
+my $cmd = Test::Command->new(cmd => "fping6 -S ::1 ::1");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("::1 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -t tested in test-4-options-a-b.pl

ci/test-1-basics.pl

@@ -0,0 +1,24 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 9;
+
+# ping 127.0.0.1
+my $cmd1 = Test::Command->new(cmd => "fping 127.0.0.1");
+$cmd1->exit_is_num(0);
+$cmd1->stdout_is_eq("127.0.0.1 is alive\n");
+$cmd1->stderr_is_eq("");
+
+# ping ::1
+my $cmd2 = Test::Command->new(cmd => "fping6 ::1");
+$cmd2->exit_is_num(0);
+$cmd2->stdout_is_eq("::1 is alive\n");
+$cmd2->stderr_is_eq("");
+
+# ping 3 times 127.0.0.1
+my $cmd3 = Test::Command->new(cmd => "fping -p 100 -C3 127.0.0.1");
+$cmd3->exit_is_num(0);
+$cmd3->stdout_like(qr{127\.0\.0\.1 : \[0\], 84 bytes, 0\.\d+ ms \(0\.\d+ avg, 0% loss\)
+127\.0\.0\.1 : \[1\], 84 bytes, 0\.\d+ ms \(0.\d+ avg, 0% loss\)
+127\.0\.0\.1 : \[2\], 84 bytes, 0\.\d+ ms \(0.\d+ avg, 0% loss\)
+});
+$cmd3->stderr_like(qr{127\.0\.0\.1 : 0\.\d+ 0\.\d+ 0\.\d+\n});

ci/test-10-option-u-v.pl

@@ -0,0 +1,24 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 6;
+
+#  -u         show targets that are unreachable
+#  -v         show version
+
+# fping -u
+{
+my $cmd = Test::Command->new(cmd => "fping -r0 -u 8.8.0.0 127.0.0.1");
+$cmd->exit_is_num(1);
+$cmd->stdout_is_eq("8.8.0.0\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -v
+{
+my $cmd = Test::Command->new(cmd => "fping -v");
+$cmd->exit_is_num(0);
+$cmd->stdout_like(qr{ping: Version 3\.\d+(-rc\d+)?
+fping: comments to david\@schweikert\.ch
+});
+$cmd->stderr_is_eq("");
+}

ci/test-11-nopriv.pl

@@ -0,0 +1,32 @@
+#!/usr/bin/perl -w
+
+use Test::Command;
+use Test::More;
+
+if( $^O eq 'darwin' ) {
+    plan skip_all => 'Test irrelevant on MacOS';
+    exit 0;
+}
+plan tests => 6;
+
+# run without privileges
+my $fping_bin = `which fping`; chomp $fping_bin;
+my $fping6_bin = `which fping6`; chomp $fping6_bin;
+system("cp $fping_bin /tmp/fping.copy; chmod +x /tmp/fping.copy");
+system("cp $fping6_bin /tmp/fping6.copy; chmod +x /tmp/fping6.copy");
+
+# fping
+{
+my $cmd = Test::Command->new(cmd => "/tmp/fping.copy 127.0.0.1");
+$cmd->exit_is_num(4);
+$cmd->stdout_is_eq("");
+$cmd->stderr_like(qr{\(null\): can't create socket \(must run as root\?\) : .*\n});
+}
+
+# fping6
+{
+my $cmd = Test::Command->new(cmd => "/tmp/fping6.copy ::1");
+$cmd->exit_is_num(4);
+$cmd->stdout_is_eq("");
+$cmd->stderr_like(qr{\(null\): can't create raw socket \(must run as root\?\) : .*\n});
+}

ci/test-12-option-type.pl

@@ -0,0 +1,10 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 36;
+
+for my $arg (qw(i b B c C H i O p Q r t)) {
+    my $cmd = Test::Command->new(cmd => "fping -$arg xxx");
+    $cmd->exit_is_num(1);
+    $cmd->stdout_is_eq("");
+    $cmd->stderr_like(qr{Usage:});
+}

ci/test-13-unknown-host.pl

@@ -0,0 +1,19 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 6;
+
+# fping
+{
+my $cmd = Test::Command->new(cmd => "fping nosuchname.example.com");
+$cmd->exit_is_num(1);
+$cmd->stdout_is_eq("");
+$cmd->stderr_like(qr{^nosuchname\.example\.com: .*not (known|found)});
+}
+
+# fping6
+{
+my $cmd = Test::Command->new(cmd => "fping6 nosuchname.example.com");
+$cmd->exit_is_num(1);
+$cmd->stdout_is_eq("");
+$cmd->stderr_like(qr{^nosuchname\.example\.com: .*not (known|found)});
+}

ci/test-14-ping-internet-hosts.pl

@@ -0,0 +1,66 @@
+#!/usr/bin/perl -w
+
+use Test::Command;
+use Test::More;
+
+# evaluate if we have internet
+if(!gethostbyname("www.google.com")) {
+    plan skip_all => 'Can\'t resolve www.google.com -> no internet?';
+    exit 0;
+}
+
+plan tests => 18;
+
+my $re_num = qr{\d+(?:\.\d+)?};
+
+# fping
+{
+my $cmd = Test::Command->new(cmd => "fping -q -i 10 -p 20 -c 3 -t200  8.8.8.8 4.2.2.5 www.france-telecom.fr www.google.com");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("");
+$cmd->stderr_like(qr{8\.8\.8\.8\s*: xmt/rcv/%loss = [123]/3/\d+%, min/avg/max = $re_num/$re_num/$re_num
+4\.2\.2\.5\s*: xmt/rcv/%loss = [123]/3/\d+%, min/avg/max = $re_num/$re_num/$re_num
+www\.france-telecom\.fr\s*: xmt/rcv/%loss = [123]/3/\d+%, min/avg/max = $re_num/$re_num/$re_num
+www\.google\.com\s*: xmt/rcv/%loss = [123]/3/\d+%, min/avg/max = $re_num/$re_num/$re_num
+});
+}
+
+# fping -A -n
+{
+my $cmd = Test::Command->new(cmd => "fping -A -n 8.8.8.8");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("google-public-dns-a.google.com (8.8.8.8) is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -A -n
+{
+my $cmd = Test::Command->new(cmd => "fping -A -n google-public-dns-a.google.com");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("google-public-dns-a.google.com (8.8.8.8) is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping6 -A -n
+{
+my $cmd = Test::Command->new(cmd => "fping6 -n -A 2001:4860:4860::8888");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("google-public-dns-a.google.com (2001:4860:4860::8888) is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -m
+{
+my $cmd = Test::Command->new(cmd => "fping -m google-public-dns-a.google.com");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("google-public-dns-a.google.com is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -n
+{
+my $cmd = Test::Command->new(cmd => "fping -n 8.8.8.8");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("google-public-dns-a.google.com is alive\n");
+$cmd->stderr_is_eq("");
+}

ci/test-2-help.pl

@@ -0,0 +1,65 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 9;
+
+my $I_HELP = "   -I if      bind to a particular interface\n";
+$I_HELP = '' if $^O eq 'darwin';
+
+# fping -h
+my $cmd1 = Test::Command->new(cmd => "fping -h");
+$cmd1->exit_is_num(0);
+$cmd1->stdout_is_eq(<<END);
+
+Usage: fping [options] [targets...]
+   -a         show targets that are alive
+   -A         show targets by address
+   -b n       amount of ping data to send, in bytes (default 56)
+   -B f       set exponential backoff factor to f
+   -c n       count of pings to send to each target (default 1)
+   -C n       same as -c, report results in verbose format
+   -D         print timestamp before each output line
+   -e         show elapsed time on return packets
+   -f file    read list of targets from a file ( - means stdin) (only if no -g specified)
+   -g         generate target list (only if no -f specified)
+                (specify the start and end IP in the target list, or supply a IP netmask)
+                (ex. fping -g 192.168.1.0 192.168.1.255 or fping -g 192.168.1.0/24)
+   -H n       Set the IP TTL value (Time To Live hops)
+   -i n       interval between sending ping packets (in millisec) (default 25)
+${I_HELP}   -l         loop sending pings forever
+   -m         ping multiple interfaces on target host
+   -n         show targets by name (-d is equivalent)
+   -O n       set the type of service (tos) flag on the ICMP packets
+   -p n       interval between ping packets to one target (in millisec)
+                (in looping and counting modes, default 1000)
+   -q         quiet (don't show per-target/per-ping results)
+   -Q n       same as -q, but show summary every n seconds
+   -r n       number of retries (default 3)
+   -R         random packet data (to foil link data compression)
+   -s         print final stats
+   -S addr    set source address
+   -t n       individual target initial timeout (in millisec) (default 500)
+   -T n       ignored (for compatibility with fping 2.4)
+   -u         show targets that are unreachable
+   -v         show version
+   targets    list of targets to check (if no -f specified)
+
+END
+$cmd1->stderr_is_eq("");
+
+# fping -v
+my $cmd2 = Test::Command->new(cmd => "fping -v");
+$cmd2->exit_is_num(0);
+$cmd2->stdout_like(qr{fping: Version \S+
+fping: comments to david\@schweikert\.ch\n});
+$cmd2->stderr_is_eq("");
+
+# fping with unknown option
+my $cmd3 = Test::Command->new(cmd => "fping -Z");
+$cmd3->exit_is_num(1);
+$cmd3->stdout_is_eq("");
+if($^O eq 'darwin') {
+    $cmd3->stderr_is_eq("fping: illegal option -- Z\nsee 'fping -h' for usage information\n");
+}
+else {
+    $cmd3->stderr_is_eq("fping: invalid option -- 'Z'\nsee 'fping -h' for usage information\n");
+}

ci/test-3-forbidden.pl

@@ -0,0 +1,82 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 33;
+
+# fping -i 9
+my $cmd1 = Test::Command->new(cmd => "fping -i 9 -T10 -g 127.0.0.1/29");
+$cmd1->exit_is_num(1);
+$cmd1->stdout_is_eq("");
+$cmd1->stderr_is_eq(<<END);
+fping: these options are too risky for mere mortals.
+fping: You need i >= 10, p >= 20, r < 20, and t >= 50
+END
+
+# fping -p 15
+my $cmd2 = Test::Command->new(cmd => "fping -c3 -p 15 127.0.0.1");
+$cmd2->exit_is_num(1);
+$cmd2->stdout_is_eq("");
+$cmd2->stderr_is_eq(<<END);
+fping: these options are too risky for mere mortals.
+fping: You need i >= 10, p >= 20, r < 20, and t >= 50
+END
+
+# fping -r 30
+my $cmd3 = Test::Command->new(cmd => "fping -r 30 127.0.0.1");
+$cmd3->exit_is_num(1);
+$cmd3->stdout_is_eq("");
+$cmd3->stderr_is_eq(<<END);
+fping: these options are too risky for mere mortals.
+fping: You need i >= 10, p >= 20, r < 20, and t >= 50
+END
+
+# fping -t 40
+my $cmd4 = Test::Command->new(cmd => "fping -t 40 127.0.0.1");
+$cmd4->exit_is_num(1);
+$cmd4->stdout_is_eq("");
+$cmd4->stderr_is_eq(<<END);
+fping: these options are too risky for mere mortals.
+fping: You need i >= 10, p >= 20, r < 20, and t >= 50
+END
+
+# fping -H 300
+my $cmd5 = Test::Command->new(cmd => "fping -H 300 127.0.0.1");
+$cmd5->exit_is_num(1);
+$cmd5->stdout_is_eq("");
+$cmd5->stderr_is_eq("ttl 300 out of range\n");
+
+# fping -a -u
+my $cmd6 = Test::Command->new(cmd => "fping -a -u 127.0.0.1");
+$cmd6->exit_is_num(1);
+$cmd6->stdout_is_eq("");
+$cmd6->stderr_is_eq("fping: specify only one of a, u\n");
+
+# fping -c -l
+my $cmd7 = Test::Command->new(cmd => "fping -c3 -l 127.0.0.1");
+$cmd7->exit_is_num(1);
+$cmd7->stdout_is_eq("");
+$cmd7->stderr_is_eq("fping: specify only one of c, l\n");
+
+# fping -b 65509
+my $cmd8 = Test::Command->new(cmd => "fping -b 65509 127.0.0.1");
+$cmd8->exit_is_num(1);
+$cmd8->stdout_is_eq("");
+$cmd8->stderr_is_eq("fping: data size 65509 not valid, must be between 0 and 65508\n");
+
+# fping -B 0.9
+my $cmd9 = Test::Command->new(cmd => "fping -B 0.9 127.0.0.1");
+$cmd9->exit_is_num(1);
+$cmd9->stdout_is_eq("");
+$cmd9->stderr_is_eq("fping: backoff factor 0.9 not valid, must be between 1.0 and 5.0\n");
+
+# fping -B 0.9
+my $cmd10 = Test::Command->new(cmd => "fping -B 5.1 127.0.0.1");
+$cmd10->exit_is_num(1);
+$cmd10->stdout_is_eq("");
+$cmd10->stderr_is_eq("fping: backoff factor 5.1 not valid, must be between 1.0 and 5.0\n");
+
+# fping -C 11000
+my $cmd11 = Test::Command->new(cmd => "fping -C 11000 127.0.0.1");
+$cmd11->exit_is_num(1);
+$cmd11->stdout_is_eq("");
+$cmd11->stderr_is_eq("fping: count 11000 not valid, must be less than 10000\n");
+

ci/test-4-options-a-b.pl

@@ -0,0 +1,63 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 20;
+use Test::More;
+use Time::HiRes qw(gettimeofday tv_interval);
+
+#  -a         show targets that are alive
+#  -A         show targets by address
+#  -b n       amount of ping data to send, in bytes (default 56)
+#  -B f       set exponential backoff factor to f
+
+# fping -a
+{
+my $cmd = Test::Command->new(cmd => "fping -a 127.0.0.1 127.0.0.2");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1\n127.0.0.2\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -A
+{
+my $cmd = Test::Command->new(cmd => "fping -A localhost");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -A -n
+{
+my $cmd = Test::Command->new(cmd => "fping -A -n localhost");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("localhost (127.0.0.1) is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping6 -A -n
+{
+my $cmd = Test::Command->new(cmd => "fping6 -n -A 2001:4860:4860::8888");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("google-public-dns-a.google.com (2001:4860:4860::8888) is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -b
+{
+my $cmd = Test::Command->new(cmd => "fping -b 1000 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -B
+{
+my $t0 = [gettimeofday];
+my $cmd = Test::Command->new(cmd => "fping  -t 100 -r 3 -B 2  8.8.8.7");
+$cmd->exit_is_num(1);
+$cmd->stdout_is_eq("8.8.8.7 is unreachable\n");
+$cmd->stderr_is_eq("");
+my $elapsed = tv_interval($t0);
+# 0.1 + 0.2 + 0.4 + 0.8 = 1.5
+cmp_ok($elapsed, '>=', 1.5);
+cmp_ok($elapsed, '<', 1.8);
+}

ci/test-5-options-c-e.pl

@@ -0,0 +1,60 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 12;
+
+#  -c n       count of pings to send to each target (default 1)
+#  -C n       same as -c, report results in verbose format
+#  -D         print timestamp before each output line
+#  -e         show elapsed time on return packets
+
+# fping -c n
+{
+my $cmd = Test::Command->new(cmd => "fping -c 2 -p 100 localhost 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_like(qr{localhost : \[0\], 84 bytes, 0\.\d+ ms \(0\.\d+ avg, 0% loss\)
+127\.0\.0\.1 : \[0\], 84 bytes, 0\.\d+ ms \(0.\d+ avg, 0% loss\)
+localhost : \[1\], 84 bytes, 0\.\d+ ms \(0\.\d+ avg, 0% loss\)
+127\.0\.0\.1 : \[1\], 84 bytes, 0\.\d+ ms \(0\.\d+ avg, 0% loss\)
+});
+
+$cmd->stderr_like(qr{localhost : xmt/rcv/%loss = 2/2/0%, min/avg/max = 0\.\d+/0\.\d+/0\.\d+
+127\.0\.0\.1 : xmt/rcv/%loss = 2/2/0%, min/avg/max = 0\.\d+/0\.\d+/0\.\d+
+});
+}
+
+# fping -C n
+{
+my $cmd = Test::Command->new(cmd => "fping -C 2 -p 100 localhost 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_like(qr{localhost : \[0\], 84 bytes, 0\.\d+ ms \(0\.\d+ avg, 0% loss\)
+127\.0\.0\.1 : \[0\], 84 bytes, 0\.\d+ ms \(0.\d+ avg, 0% loss\)
+localhost : \[1\], 84 bytes, 0\.\d+ ms \(0\.\d+ avg, 0% loss\)
+127\.0\.0\.1 : \[1\], 84 bytes, 0\.\d+ ms \(0\.\d+ avg, 0% loss\)
+});
+
+$cmd->stderr_like(qr{localhost : 0\.\d+ 0\.\d+
+127\.0\.0\.1 : 0\.\d+ 0\.\d+
+});
+}
+
+# fping -D
+{
+my $cmd = Test::Command->new(cmd => "fping -D -c 2 -p 100 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_like(qr{\[\d{10}\.\d+\] 127\.0\.0\.1 : \[0\], 84 bytes, 0\.\d+ ms \(0.\d+ avg, 0% loss\)
+\[\d{10}\.\d+\] 127\.0\.0\.1 : \[1\], 84 bytes, 0\.\d+ ms \(0\.\d+ avg, 0% loss\)
+});
+
+$cmd->stderr_like(qr{127\.0\.0\.1 : xmt/rcv/%loss = 2/2/0%, min/avg/max = 0\.\d+/0\.\d+/0\.\d+
+});
+}
+
+# fping -e
+{
+my $cmd = Test::Command->new(cmd => "fping -e 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_like(qr{127\.0\.0\.1 is alive \(0\.\d+ ms\)
+});
+
+$cmd->stderr_is_eq("");
+}

ci/test-6-options-f-h.pl

@@ -0,0 +1,62 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 18;
+use File::Temp;
+
+#  -f file    read list of targets from a file ( - means stdin) (only if no -g specified)
+#  -g         generate target list (only if no -f specified)
+#               (specify the start and end IP in the target list, or supply a IP netmask)
+#               (ex. ../src/fping -g 192.168.1.0 192.168.1.255 or ../src/fping -g 192.168.1.0/24)
+#  -H n       Set the IP TTL value (Time To Live hops)
+
+my $tmpfile = File::Temp->new();
+print $tmpfile "127.0.0.1\n127.0.0.2\n";
+close($tmpfile);
+
+# fping without option (-> equivalent to 'fping -f -')
+{
+my $cmd = Test::Command->new(cmd => "cat ".$tmpfile->filename." | fping");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n127.0.0.2 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -f -
+{
+my $cmd = Test::Command->new(cmd => "cat ".$tmpfile->filename." | fping -f -");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n127.0.0.2 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -f file
+{
+my $cmd = Test::Command->new(cmd => "fping -f ".$tmpfile->filename);
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n127.0.0.2 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -g (range)
+{
+my $cmd = Test::Command->new(cmd => "fping -g 127.0.0.1 127.0.0.5");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n127.0.0.2 is alive\n127.0.0.3 is alive\n127.0.0.4 is alive\n127.0.0.5 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -g (cidr)
+{
+my $cmd = Test::Command->new(cmd => "fping -g 127.0.0.1/30");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n127.0.0.2 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -H
+{
+my $cmd = Test::Command->new(cmd => "fping -H 1 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n");
+$cmd->stderr_is_eq("");
+}

ci/test-7-options-i-m.pl

@@ -0,0 +1,31 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 7;
+
+#  -i n       interval between sending ping packets (in millisec) (default 25)
+#  -l         loop sending pings forever
+#  -m         ping multiple interfaces on target host
+
+# fping -i n
+{
+my $cmd = Test::Command->new(cmd => "fping -i 100 127.0.0.1 127.0.0.2");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n127.0.0.2 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -l
+{
+my $cmd = Test::Command->new(cmd => '(sleep 2; pkill fping)& fping -p 900 -l 127.0.0.1');
+$cmd->stdout_like(qr{127\.0\.0\.1 : \[0\], 84 bytes, 0\.\d+ ms \(0.\d+ avg, 0% loss\)
+127\.0\.0\.1 : \[1\], 84 bytes, 0\.\d+ ms \(0\.\d+ avg, 0% loss\)
+});
+}
+
+# fping -m
+{
+my $cmd = Test::Command->new(cmd => "fping -m google-public-dns-a.google.com");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("google-public-dns-a.google.com is alive\n");
+$cmd->stderr_is_eq("");
+}

ci/test-8-options-n-q.pl

@@ -0,0 +1,48 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 12;
+
+#  -n         show targets by name (-d is equivalent)
+#  -O n       set the type of service (tos) flag on the ICMP packets
+#  -p n       interval between ping packets to one target (in millisec)
+#               (in looping and counting modes, default 1000)
+#  -q         quiet (don't show per-target/per-ping results)
+#  -Q n       same as -q, but show summary every n seconds
+
+# fping -n
+{
+my $cmd = Test::Command->new(cmd => "fping -n 8.8.8.8");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("google-public-dns-a.google.com is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -O
+{
+my $cmd = Test::Command->new(cmd => "fping -O 2 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -q
+{
+my $cmd = Test::Command->new(cmd => "fping -q -p 100 -c 3 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("");
+$cmd->stderr_like(qr{127\.0\.0\.1 : xmt/rcv/%loss = 3/3/0%, min/avg/max = 0\.\d+/0\.\d+/0\.\d+
+});
+}
+
+# fping -Q
+{
+my $cmd = Test::Command->new(cmd => "fping -Q 1 -p 400 -c 4 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("");
+$cmd->stderr_like(qr{\[\d+:\d+:\d+\]
+127\.0\.0\.1 : xmt/rcv/%loss = 3/3/0%, min/avg/max = 0\.\d+/0\.\d+/0\.\d+
+127\.0\.0\.1 : xmt/rcv/%loss = 4/4/0%, min/avg/max = 0\.\d+/0\.\d+/0\.\d+
+});
+}
+
+

ci/test-9-option-r-t.pl

@@ -0,0 +1,75 @@
+#!/usr/bin/perl -w
+
+use Test::Command tests => 12;
+
+#  -r n       number of retries (default 3)
+#  -s         print final stats
+#  -S addr    set source address
+#  -t n       individual target initial timeout (in millisec) (default 500)
+#  -T n       ignored (for compatibility with fping 2.4)
+
+# fping -r tested in test-4-options-a-b.pl
+
+# fping -s
+{
+my $cmd = Test::Command->new(cmd => "fping -s 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n");
+$cmd->stderr_like(qr{\s*
+\s*1 targets
+\s*1 alive
+\s*0 unreachable
+\s*0 unknown addresses
+\s*
+\s*0 timeouts \(waiting for response\)
+\s*1 ICMP Echos sent
+\s*1 ICMP Echo Replies received
+\s*0 other ICMP received
+
+\s*0.\d+ ms \(min round trip time\)
+\s*0.\d+ ms \(avg round trip time\)
+\s*0.\d+ ms \(max round trip time\)
+\s*0.\d+ sec \(elapsed real time\)
+});
+}
+
+# fping -s (no host reachable)
+{
+my $cmd = Test::Command->new(cmd => "fping -r0 -t100 -s 8.8.0.0");
+$cmd->exit_is_num(1);
+$cmd->stdout_is_eq("8.8.0.0 is unreachable\n");
+$cmd->stderr_like(qr{\s*
+\s*1 targets
+\s*0 alive
+\s*1 unreachable
+\s*0 unknown addresses
+\s*
+\s*1 timeouts \(waiting for response\)
+\s*1 ICMP Echos sent
+\s*0 ICMP Echo Replies received
+\s*0 other ICMP received
+
+\s*0.\d+ ms \(min round trip time\)
+\s*0.\d+ ms \(avg round trip time\)
+\s*0.\d+ ms \(max round trip time\)
+\s*0.\d+ sec \(elapsed real time\)
+});
+}
+
+# fping -S
+{
+my $cmd = Test::Command->new(cmd => "fping -S 127.0.0.1 127.0.0.1");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("127.0.0.1 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping6 -S
+{
+my $cmd = Test::Command->new(cmd => "fping6 -S ::1 ::1");
+$cmd->exit_is_num(0);
+$cmd->stdout_is_eq("::1 is alive\n");
+$cmd->stderr_is_eq("");
+}
+
+# fping -t tested in test-4-options-a-b.pl

ci/test-issue-56.pl

@@ -0,0 +1,10 @@
+#!/usr/bin/perl -w
+
+# regression testing for github issue #56
+
+use Test::Command tests => 3;
+
+my $cmd1 = Test::Command->new(cmd => "fping -t100 -p100 -C3 255.255.255.255");
+$cmd1->exit_is_num(1);
+$cmd1->stdout_is_eq("");
+$cmd1->stderr_is_eq("\n255.255.255.255 : - - -\n");

ci/test-issue-58.pl

@@ -0,0 +1,10 @@
+#!/usr/bin/perl -w
+
+# regression testing for github issue #58
+
+use Test::Command tests => 3;
+
+my $cmd1 = Test::Command->new(cmd => "fping -a -g 2001:db8:120:4161::4/64");
+$cmd1->exit_is_num(1);
+$cmd1->stdout_is_eq("");
+$cmd1->stderr_is_eq("Error: -g works only with IPv4 addresses\n");

ci/test-tarball.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+# make sure that the .tar.gz file contains everything necessary
+# to build fping
+
+set -e
+set -x
+
+make dist
+VERSION=$(ls fping-*.tar.gz | sed -e 's/^fping-//' | sed -e 's/\.tar\.gz$//')
+if [ -z "$VERSION" ]; then
+    echo "tar.gz file not found." >&2
+    exit 1
+fi
+
+# unarchive
+TMPDIR=$(mktemp -d --tmpdir=ci)
+cd $TMPDIR
+tar xf ../../fping-$VERSION.tar.gz
+DIRNAME=$(ls)
+
+# build
+cd $DIRNAME
+./configure --enable-ipv4 --enable-ipv6 --prefix=/opt/fping
+make
+sudo make install 

configure.ac

@@ -3,10 +3,33 @@ dnl Process this file with autoconf to produce a configure script.
 dnl Minimum Autoconf version required.
 AC_PREREQ(2.59)
 
-AC_INIT([fping],[3.2])
+AC_INIT([fping],[3.13])
+
+dnl make ipv4 and ipv6 options
+AC_ARG_ENABLE([ipv4],
+  [  --enable-ipv4    Build IPv4 capable fping],
+  [case "${enableval}" in
+   yes)	ipv4=true ;;
+   no)	ipv4=false ;;
+   *)	AC_MSG_ERROR([bad value ${enableval} for --enable-ipv4]) ;;
+   esac],[ipv4=true])
+  AM_CONDITIONAL([IPV4], [test x$ipv4 = xtrue])
+
+AC_ARG_ENABLE([ipv6],
+  [  --enable-ipv6    Build IPv6 capable fping6],
+  [case "${enableval}" in
+   yes)	ipv6=true ;;
+   no)	ipv6=false ;;
+   *)	AC_MSG_ERROR([bad value ${enableval} for --enable-ipv6]) ;;
+   esac],[ipv6=false])
+  AM_CONDITIONAL([IPV6], [test x$ipv6 = xtrue])
+
+if test x$ipv4 = xfalse && test x$ipv6 = xfalse; then
+  AC_MSG_ERROR([You must enable at least one of IPv4 and IPv6.])
+fi
 
 AC_CANONICAL_TARGET
-AM_INIT_AUTOMAKE([foreign])
+AM_INIT_AUTOMAKE([-Wall -Werror foreign])
 AM_MAINTAINER_MODE
 
 AC_CONFIG_HEADERS([config.h])

contrib/fping.spec

@@ -0,0 +1,73 @@
+Summary: send ICMP echo probes to multiple hosts
+Name: fping
+Version: 3.4
+Release: 1
+License: MIT
+Group: Applications/System
+Source0: http://fping.org/dist/%{name}-%{version}.tar.gz
+BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot
+
+%description
+fping is a program to send ICMP echo probes to network hosts, similar to ping,
+but much better performing when pinging multiple hosts. fping has a very long
+history: Roland Schemers did publish a first version of it in 1992 and it has
+established itself since then as a standard tool for network diagnostics and
+statistics.
+
+%prep
+%setup -q
+
+%build
+
+if [ ! -f ./configure ] ; then
+    ./autogen.sh
+fi
+
+# fping
+%configure --enable-ipv4
+make
+
+# fping6
+%configure --enable-ipv6
+make
+%{__mv} -f src/fping src/fping6
+
+%install
+rm -rf $RPM_BUILD_ROOT
+make DESTDIR=$RPM_BUILD_ROOT install
+
+# fping6
+%{__install} -Dp -m4755 src/fping6 %{buildroot}%{_sbindir}/fping6
+%{__ln_s} -f fping.8 %{buildroot}%{_mandir}/man8/fping6.8
+
+%clean
+rm -rf $RPM_BUILD_ROOT
+
+%files
+%defattr(-,root,root,-)
+%attr(4755, root, root) /usr/sbin/fping
+%attr(4755, root, root) /usr/sbin/fping6
+%doc README COPYING ChangeLog
+/usr/share/man/man8/fping.8.gz
+/usr/share/man/man8/fping6.8.gz
+
+%post
+if [ -x /usr/sbin/setcap ]; then
+    /bin/chmod 0755 /usr/sbin/fping*
+    /usr/sbin/setcap cap_net_raw+ep /usr/sbin/fping*
+fi
+
+%changelog
+* Mon Dec 24 2012 Marcus Vinicius Ferreira <ferreira.mv@gmail.com>
+- Missing './configure' script when cloning from master.
+- Making 'fping6'.
+- Fix setuid permission to 'rwsr-xr-x'.
+- doc files.
+- Replacing setuid permission if 'setcap' is present on post-install.
+- Using 'http://fping.org/dist/' for release source distributions.
+
+* Mon Jul 16 2012 Stephen Schaefer <sschaefer@acm.org>
+- Initial build
+
+# vim:ft=spec:
+

doc/Makefile.am

@@ -1,2 +1,17 @@
-man_MANS = fping.8
-EXTRA_DIST = $(man_MANS)
+man_MANS =
+
+if IPV4
+man_MANS += fping.8
+endif
+
+if IPV6
+man_MANS += fping6.8
+endif
+
+EXTRA_DIST = fping.8 fping6.8 fping.pod README.1992
+
+fping.8: fping.pod
+	pod2man  -c "" -s 8 -r "fping" $< >$@
+
+fping6.8: fping.pod
+	pod2man  -c "" -s 8 -r "fping" -n fping6 $< >$@

doc/fping.8

@@ -1,227 +0,0 @@
-.TH fping 8
-.SH NAME
-fping \- send ICMP ECHO_REQUEST packets to network hosts
-.SH SYNOPSIS
-.B fping
-[ \fIoptions\fR ]
-[ \fIsystems...\fR ]
-
-.SH DESCRIPTION
-.B fping
-is a program like
-.B ping(8)
-which uses the Internet Control
-Message Protocol (ICMP) echo request to determine if a target host is
-responding.
-.B fping
-differs from ping in that you can specify any
-number of targets on the command line, or specify a file containing
-the lists of targets to ping. Instead of sending to one target until it
-times out or replies,
-.B fping
-will send out a ping packet and move
-on to the next target in a round-robin fashion.
-.PP
-In the default mode, if a target replies,
-it is noted and removed from the list of targets to check; if a target
-does not respond within a certain time limit and/or retry limit it
-is designated as unreachable.
-.B fping
-also supports sending a specified number of pings to a target, or
-looping indefinitely (as in
-.B ping
-).
-.PP
-Unlike
-.B ping,
-.B fping
-is meant to be used in scripts, so its output is designed to be
-easy to parse.
-.SH OPTIONS
-.IP \fB\-a\fR 5
-Show systems that are alive.
-.IP \fB\-A\fR 5
-Display targets by address rather than DNS name.
-.IP \fB\-b\fIn\fR 5
-Number of bytes of ping data to send.  The minimum size (normally 12)
-allows room for the data that
-.B fping
-needs to do its work (sequence number, timestamp).  The reported
-received data size includes the IP header (normally 20 bytes) and ICMP
-header (8 bytes), so the minimum total size is 40 bytes.  Default is
-56, as in
-.B ping.
-Maximum is the theoretical maximum IP datagram size (64K), though most
-systems limit this to a smaller, system-dependent number.
-.IP \fB\-B\fIn\fR 5
-In the default mode,
-.B fping
-sends several requests to a target before giving up, waiting longer for
-a reply on each successive request.  This parameter is the value by
-which the wait time is multiplied on each successive request; it must
-be entered as a floating-point number (x.y).  The default is 1.5.
-.IP \fB\-c\fR 5
-Number of request packets to send to each target.  In this mode, a
-line is displayed for each received response (this can suppressed with
-\-q or \-Q).  Also, statistics about responses for each target are displayed
-when all requests have been sent (or when interrupted).
-.IP \fB-C\fR 5
-Similar to \-c, but the per-target statistics are displayed in a format
-designed for automated response-time statistics gathering.  For
-example:
-
-% fping \-C 5 \-q somehost
-
-somehost : 91.7 37.0 29.2 \- 36.8
-
-shows the response time in milliseconds for each of the five requests,
-with the "\-" indicating that no response was received to the fourth
-request.
-.IP \fB\-d\fR 5
-Use DNS to lookup address of return ping packet. This allows you to give
-fping a list of IP addresses as input and print hostnames in the output.
-.IP \fB\-e\fR 5
-Show elapsed (round-trip) time of packets.
-.IP \fB\-f\fR 5
-Read list of targets from a file.  This option can only be used by the
-root user.  Regular users should pipe in the file via stdin:
-
-% fping < targets_file
-
-.IP \fB\-g\fR 5
-Generate a target list from a supplied IP netmask, or a starting and ending IP.
-Specify the netmask or start/end in the targets portion of the command line. If
-a network with netmask is given, the network and broadcast addresses will be
-excluded.
-
-ex. To ping the network 192.168.1.0/24, the specified command line could look like either:
-
-fping \-g 192.168.1.0/24
-
-or
-
-fping -g 192.168.1.1 192.168.1.254
-.IP \fB\-h\fR 5
-Print usage message.
-.IP \fB\-i\fIn\fR 5
-The minimum amount of time (in milliseconds) between sending a ping packet to any target (default is 25).
-.IP \fB\-l\fR 5
-Loop sending packets to each target indefinitely.  Can be interrupted
-with Ctrl-C; statistics about responses for each target are then displayed.
-.IP \fB\-m\fR 5
-Send pings to each of a target host's multiple interfaces.
-.IP \fB\-n\fR 5
-Same as \-d.
-.IP \fB\-p\fR 5
-In looping or counting modes (\-l, \-c, or \-C), this parameter sets the
-time in milliseconds that
-.B fping
-waits between successive packets to an individual target.  Default is
-1000.
-.IP \fB\-q\fR 5
-Quiet. Don't show per-target results, just set final exit status.
-.IP \fB\-Q\fIn\fR 5
-Like \-q, but show summary results every n seconds.
-.IP \fB\-r\fIn\fR 5
-Retry limit (default 3). This is the number of times an attempt at pinging
-a target will be made, not including the first try.
-.IP \fB\-s\fR 5
-Print cumulative statistics upon exit.
-.IP \fB\-S\fIaddr\fR 5
-Set source address.
-.IP \fB\-I\fIif\fR 5
-Set the interface (requires SO_BINDTODEVICE support)
-.IP \fB\-t\fIn\fR 5
-Initial target timeout in milliseconds (default 500). In the default
-mode, this is the amount of time that
-.B fping
-waits for a response to its first request.  Successive timeouts are
-multiplied by the backoff factor.
-.IP \fB\-T\fIn\fR 5
-Ignored (for compatibility with fping 2.4).
-.IP \fB\-u\fR 5
-Show targets that are unreachable.
-.IP \fB\-T\fIn\fR 5
-Set the typ of service flag (TOS). \fIn\fR can be either decimal or hexadecimal (0xh) format.
-.IP \fB\-v\fR 5
-Print
-.B fping
-version information.
-.IP \fB-H\fIn\fR 5
-Set the IP TTL field (time to live hops).
-
-.SH EXAMPLES
-The following perl script will check a list of hosts and send mail if
-any are unreachable. It uses the open2 function which allows a program
-to be opened for reading and writing. fping does not start pinging the
-list of systems until it reads EOF, which it gets after INPUT is closed.
-Sure the open2 usage is not needed in this example, but it's a good open2
-example none the less.
-.nf
-
-#!/usr/bin/perl
-require 'open2.pl';
-
-$MAILTO = "root";
-
-$pid = &open2("OUTPUT","INPUT","/usr/local/bin/fping -u");
-
-@check=("slapshot","foo","foobar");
-
-foreach(@check) {  print INPUT "$_\\n"; }
-close(INPUT);
-@output=<OUTPUT>;
-
-if ($#output != -1) {
- chop($date=`date`);
- open(MAIL,"|mail -s 'unreachable systems' $MAILTO");
- print MAIL "\\nThe following systems are unreachable as of: $date\\n\\n";
- print MAIL @output;
- close MAIL;
-}
-
-.fi
-Another good example is when you want to perform an action only on hosts
-that are currently reachable.
-.nf
-
-#!/usr/bin/perl
-
-$hosts_to_backup = `cat /etc/hosts.backup | fping -a`;
-
-foreach $host (split(/\\n/,$hosts_to_backup)) {
-  # do it
-}
-
-.fi
-
-.SH AUTHORS
-.nf
-Roland J. Schemers III, Stanford University, concept and versions 1.x
-RL "Bob" Morgan, Stanford University, versions 2.x
-David Papp, versions 2.3x and up,
-David Schweikert, versions 3.0 and up
-fping website:  http://www.fping.org
-.fi
-.SH DIAGNOSTICS
-Exit status is 0 if all the hosts are reachable, 1 if some hosts were
-unreachable, 2 if any IP addresses were not found, 3 for invalid
-command line arguments, and 4 for a system call failure.
-.SH BUGS
-Ha! If we knew of any we would have fixed them!
-.SH RESTRICTIONS
-If certain options are used (i.e, a low value for \-i and \-t, and a
-high value for \-r) it is possible to flood the network. This program
-must be installed as setuid root in order to open up a raw socket,
-or must be run by root. In order to stop mere mortals from hosing the
-network (when fping is installed setuid root) , normal users can't specify
-the following:
-.nf
-
- -i n   where n < 10  msec
- -r n   where n > 20
- -t n   where n < 250 msec
-
-.fi
-.SH SEE ALSO
-netstat(1), ping(8), ifconfig(8c)

doc/fping.pod

@@ -0,0 +1,266 @@
+=head1 NAME
+
+fping - send ICMP ECHO_REQUEST packets to network hosts
+
+=head1 SYNOPSIS
+
+B<fping> [ I<options> ] [ I<systems...> ] 
+B<fping6> [ I<options> ] [ I<systems...> ] 
+
+=head1 DESCRIPTION
+
+B<fping> is a program like B<ping> which uses the Internet Control Message
+Protocol (ICMP) echo request to determine if a target host is responding.
+B<fping> differs from B<ping> in that you can specify any number of targets on the
+command line, or specify a file containing the lists of targets to ping.
+Instead of sending to one target until it times out or replies, B<fping> will
+send out a ping packet and move on to the next target in a round-robin fashion.
+In the default mode, if a target replies, it is noted and removed from the list
+of targets to check; if a target does not respond within a certain time limit
+and/or retry limit it is designated as unreachable. B<fping> also supports
+sending a specified number of pings to a target, or looping indefinitely (as in
+B<ping> ). Unlike B<ping>, B<fping> is meant to be used in scripts, so its
+output is designed to be easy to parse.
+
+The binary named B<fping6> is the same as B<fping>, except that it uses IPv6
+addresses instead of IPv4.
+
+=head1 OPTIONS
+
+=over 5
+
+=item B<-a>
+
+Show systems that are alive. 
+
+=item B<-A>
+
+Display targets by address rather than DNS name. Combined with -d, the output
+will be both the ip and (if available) the hostname.
+
+=item B<-b> I<n>
+
+Number of bytes of ping data to send.  The minimum size (normally 12) allows
+room for the data that B<fping> needs to do its work (sequence number,
+timestamp).  The reported received data size includes the IP header (normally
+20 bytes) and ICMP header (8 bytes), so the minimum total size is 40 bytes.
+Default is 56, as in B<ping>. Maximum is the theoretical maximum IP datagram
+size (64K), though most systems limit this to a smaller, system-dependent
+number. 
+
+=item B<-B> I<n>
+
+Backoff factor. In the default mode, B<fping> sends several requests to a
+target before giving up, waiting longer for a reply on each successive request.
+This parameter is the value by which the wait time (B<-t>) is multiplied on each
+successive request; it must be entered as a floating-point number (x.y). The
+default is 1.5. 
+
+=item B<-c> I<n>
+
+Number of request packets to send to each target.  In this mode, a line is
+displayed for each received response (this can suppressed with B<-q> or B<-Q>).
+Also, statistics about responses for each target are displayed when all
+requests have been sent (or when interrupted). 
+
+=item B<-C> I<n>
+
+Similar to B<-c>, but the per-target statistics are displayed in a format
+designed for automated response-time statistics gathering. For example: 
+
+ % fping -C 5 -q somehost 
+ somehost : 91.7 37.0 29.2 - 36.8 
+
+shows the response time in milliseconds for each of the five requests, with the
+C<-> indicating that no response was received to the fourth request. 
+
+=item B<-d>
+
+Use DNS to lookup address of return ping packet. This allows you to give fping
+a list of IP addresses as input and print hostnames in the output. 
+
+=item B<-D>
+
+Add Unix timestamps in front of output lines generated with in looping or counting
+modes (B<-l>, B<-c>, or B<-C>).
+
+=item B<-e>
+
+Show elapsed (round-trip) time of packets. 
+
+=item B<-f>
+
+Read list of targets from a file.  This option can only be used by the root
+user. Regular users should pipe in the file via stdin: 
+
+ % fping < targets_file 
+
+=item B<-g> I<addr/mask>
+
+Generate a target list from a supplied IP netmask, or a starting and ending IP.
+Specify the netmask or start/end in the targets portion of the command line. If
+a network with netmask is given, the network and broadcast addresses will be
+excluded. ex. To ping the network 192.168.1.0/24, the specified command line
+could look like either:
+
+ fping -g 192.168.1.0/24 
+
+or 
+
+ fping -g 192.168.1.1 192.168.1.254 
+
+=item B<-h>
+
+Print usage message.
+
+=item B<-i> I<n>
+
+The minimum amount of time (in milliseconds) between sending a ping packet
+to any target (default is 25). 
+
+=item B<-l>
+
+Loop sending packets to each target indefinitely. Can be interrupted with
+Ctrl-C; statistics about responses for each target are then displayed. 
+
+=item B<-m>
+
+Send pings to each of a target host's multiple interfaces.
+
+=item B<-n>
+
+Same as -d. 
+
+=item B<-p> <n>
+
+In looping or counting modes (B<-l>, B<-c>, or B<-C>), this parameter sets
+the time in milliseconds that B<fping> waits between successive packets to
+an individual target.  Default is 1000. 
+
+=item B<-q>
+
+Quiet. Don't show per-probe results, but only the final summary. Also don't
+show ICMP error messages.
+
+=item B<-Q> I<n>
+
+Like B<-q>, but show summary results every n seconds.
+
+=item B<-r> I<n>
+
+Retry limit (default 3). This is the number of times an attempt at pinging
+a target will be made, not including the first try. 
+
+=item B<-R>
+
+Instead of using all-zeros as the packet data, generate random bytes.
+Use to defeat, e.g., link data compression.
+
+=item B<-s>
+
+Print cumulative statistics upon exit. 
+
+=item B<-S> I<addr>
+
+Set source address. 
+
+=item B<-I> I<if>
+
+Set the interface (requires SO_BINDTODEVICE support) 
+
+=item B<-t> I<n>
+
+Initial target timeout in milliseconds (default 500). In the default mode, this
+is the amount of time that B<fping> waits for a response to its first request.
+Successive timeouts are multiplied by the backoff factor specified with B<-B>.
+Note that this option has no effect looping or counting modes (B<-l>, B<-c>, or
+B<-C>).
+
+=item B<-T> I<n>
+
+Ignored (for compatibility with fping 2.4). 
+
+=item B<-u>
+
+Show targets that are unreachable. 
+
+=item B<-O> I<n>
+
+Set the typ of service flag (TOS). I<n> can be either decimal or hexadecimal
+(0xh) format. 
+
+=item B<-v>
+
+Print B<fping> version information. 
+
+=item B<-H> I<n>
+
+Set the IP TTL field (time to live hops). 
+
+=back
+
+=head1 EXAMPLES
+
+Generate ~1000 pings per second to a host until canceled, printing statistics
+on the fly at one second intervals, and printing statistics at the end:
+
+# fping -s -l -i 1 -p 1 -T 1 -Q 1 127.0.0.1
+
+Note that ping intervals less than 10ms can only be used as root.
+
+=head1 AUTHORS
+
+=over 4
+
+=item *
+
+Roland J. Schemers III, Stanford University, concept and versions 1.x
+
+=item *
+
+RL "Bob" Morgan, Stanford University, versions 2.x
+
+=item *
+
+David Papp, versions 2.3x and up
+
+=item *
+
+David Schweikert, versions 3.0 and up
+
+=back
+
+B<fping website: L<http://www.fping.org>>
+
+=head1 DIAGNOSTICS
+
+Exit status is 0 if all the hosts are reachable, 1 if some hosts
+were unreachable, 2 if any IP addresses were not found, 3 for invalid command
+line arguments, and 4 for a system call failure.
+
+=head1 RESTRICTIONS
+
+If certain options are used (i.e, a low value for B<-i> and B<-t>, and a high value
+for B<-r>) it is possible to flood the network. This program must be installed as
+setuid root in order to open up a raw socket, or must be run by root. In order
+to stop mere mortals from hosing the network, normal users can't specify the following: 
+
+=over 4
+
+=item *
+
+B<-i> I<n>, where I<n> < 10 msec
+
+=item *
+
+B<-r> I<n>, where I<n> > 20
+
+=item *
+
+B<-t> I<n>, where n < 250 msec
+
+=back
+
+=head1 SEE ALSO
+
+C<ping(8)>

doc/fping.txt

@@ -0,0 +1,173 @@
+
+NAME
+       fping - send ICMP ECHO_REQUEST packets to network hosts
+
+SYNOPSIS
+       fping [ options ] [ systems... ] fping6 [ options ] [ systems... ]
+
+DESCRIPTION
+       fping is a program like ping which uses the Internet Control Message
+       Protocol (ICMP) echo request to determine if a target host is
+       responding.  fping differs from ping in that you can specify any number
+       of targets on the command line, or specify a file containing the lists
+       of targets to ping.  Instead of sending to one target until it times
+       out or replies, fping will send out a ping packet and move on to the
+       next target in a round-robin fashion.  In the default mode, if a target
+       replies, it is noted and removed from the list of targets to check; if
+       a target does not respond within a certain time limit and/or retry
+       limit it is designated as unreachable. fping also supports sending a
+       specified number of pings to a target, or looping indefinitely (as in
+       ping ). Unlike ping, fping is meant to be used in scripts, so its
+       output is designed to be easy to parse.
+
+       The binary named fping6 is the same as fping, except that it uses IPv6
+       addresses instead of IPv4.
+
+OPTIONS
+       -a   Show systems that are alive.
+
+       -A   Display targets by address rather than DNS name.
+
+       -b n Number of bytes of ping data to send.  The minimum size (normally
+            12) allows room for the data that fping needs to do its work
+            (sequence number, timestamp).  The reported received data size
+            includes the IP header (normally 20 bytes) and ICMP header (8
+            bytes), so the minimum total size is 40 bytes.  Default is 56, as
+            in ping. Maximum is the theoretical maximum IP datagram size
+            (64K), though most systems limit this to a smaller, system-
+            dependent number.
+
+       -B n Backoff factor. In the default mode, fping sends several requests
+            to a target before giving up, waiting longer for a reply on each
+            successive request.  This parameter is the value by which the wait
+            time (-t) is multiplied on each successive request; it must be
+            entered as a floating-point number (x.y). The default is 1.5.
+
+       -c n Number of request packets to send to each target.  In this mode, a
+            line is displayed for each received response (this can suppressed
+            with -q or -Q).  Also, statistics about responses for each target
+            are displayed when all requests have been sent (or when
+            interrupted).
+
+       -C n Similar to -c, but the per-target statistics are displayed in a
+            format designed for automated response-time statistics gathering.
+            For example:
+
+             % fping -C 5 -q somehost
+             somehost : 91.7 37.0 29.2 - 36.8
+
+            shows the response time in milliseconds for each of the five
+            requests, with the "-" indicating that no response was received to
+            the fourth request.
+
+       -d   Use DNS to lookup address of return ping packet. This allows you
+            to give fping a list of IP addresses as input and print hostnames
+            in the output.
+
+       -D   Add Unix timestamps in front of output lines generated with in
+            looping or counting modes (-l, -c, or -C).
+
+       -e   Show elapsed (round-trip) time of packets.
+
+       -f   Read list of targets from a file.  This option can only be used by
+            the root user. Regular users should pipe in the file via stdin:
+
+             % fping < targets_file
+
+       -g addr/mask
+            Generate a target list from a supplied IP netmask, or a starting
+            and ending IP.  Specify the netmask or start/end in the targets
+            portion of the command line. If a network with netmask is given,
+            the network and broadcast addresses will be excluded. ex. To ping
+            the network 192.168.1.0/24, the specified command line could look
+            like either:
+
+             fping -g 192.168.1.0/24
+
+            or
+
+             fping -g 192.168.1.1 192.168.1.254
+
+       -h   Print usage message.
+
+       -i n The minimum amount of time (in milliseconds) between sending a
+            ping packet to any target (default is 25).
+
+       -l   Loop sending packets to each target indefinitely. Can be
+            interrupted with Ctrl-C; statistics about responses for each
+            target are then displayed.
+
+       -m   Send pings to each of a target host's multiple interfaces.
+
+       -n   Same as -d.
+
+       -p <n>
+            In looping or counting modes (-l, -c, or -C), this parameter sets
+            the time in milliseconds that fping waits between successive
+            packets to an individual target.  Default is 1000.
+
+       -q   Quiet. Don't show per-probe results, but only the final summary.
+            Also don't show ICMP error messages.
+
+       -Q n Like -q, but show summary results every n seconds.
+
+       -r n Retry limit (default 3). This is the number of times an attempt at
+            pinging a target will be made, not including the first try.
+
+       -s   Print cumulative statistics upon exit.
+
+       -S addr
+            Set source address.
+
+       -I if
+            Set the interface (requires SO_BINDTODEVICE support)
+
+       -t n Initial target timeout in milliseconds (default 500). In the
+            default mode, this is the amount of time that fping waits for a
+            response to its first request.  Successive timeouts are multiplied
+            by the backoff factor specified with -B.  Note that this option
+            has no effect looping or counting modes (-l, -c, or -C).
+
+       -T n Ignored (for compatibility with fping 2.4).
+
+       -u   Show targets that are unreachable.
+
+       -O n Set the typ of service flag (TOS). n can be either decimal or
+            hexadecimal (0xh) format.
+
+       -v   Print fping version information.
+
+       -H n Set the IP TTL field (time to live hops).
+
+AUTHORS
+       ·   Roland J. Schemers III, Stanford University, concept and versions
+           1.x
+
+       ·   RL "Bob" Morgan, Stanford University, versions 2.x
+
+       ·   David Papp, versions 2.3x and up
+
+       ·   David Schweikert, versions 3.0 and up
+
+       fping website: <http://www.fping.org>
+
+DIAGNOSTICS
+       Exit status is 0 if all the hosts are reachable, 1 if some hosts were
+       unreachable, 2 if any IP addresses were not found, 3 for invalid
+       command line arguments, and 4 for a system call failure.
+
+RESTRICTIONS
+       If certain options are used (i.e, a low value for -i and -t, and a high
+       value for -r) it is possible to flood the network. This program must be
+       installed as setuid root in order to open up a raw socket, or must be
+       run by root. In order to stop mere mortals from hosing the network,
+       normal users can't specify the following:
+
+       ·   -i n, where n < 10 msec
+
+       ·   -r n, where n > 20
+
+       ·   -t n, where n < 250 msec
+
+
+                                  2014-05-04

readme

@@ -0,0 +1,26 @@
+fping 3 README
+--------------
+
+fping is a program to send ICMP echo probes to network hosts, similar to ping,
+but much better performing when pinging multiple hosts. fping has a long long
+story: Roland Schemers did publish a first version of it in 1992 and it has
+established itself since then as a standard tool.
+
+Current maintainer:
+   David Schweikert <david@schweikert.ch>
+
+Website:
+   http://fping.org/
+
+Mailing-list:
+   https://groups.google.com/group/fping-users
+
+
+Credits
+-------
+
+AmigaOS maintainer Carsten Larsen (carsten.larsen@mail.com)
+Original author:  Roland Schemers (schemers@stanford.edu)
+Previous maintainer:  RL "Bob" Morgan (morgan@stanford.edu)
+Initial IPv6 Support: Jeroen Massar (jeroen@unfix.org / jeroen@ipng.nl)
+Other contributors: see ChangeLog

src/Makefile.am

@@ -1,3 +0,0 @@
-sbin_PROGRAMS = fping
-fping_SOURCES = fping.c options.h
-fping_DEPENDENCIES = ../config.h

src/Makefile.aros

@@ -0,0 +1,48 @@
+# Portable Makefile generated by configure
+
+all:	fping
+
+CC     = gcc
+CFLAGS = -O2 -DAROS -I. -D_DEBUG -Wall -Werror
+LDLIBS = -lm
+
+build_date.h:
+	echo "#define BUILD_DATE \"$$(date -u)"\" >build_date.h
+
+fping.h:	 mem.h
+	touch fping.h
+
+getaddrinfo.h:	 fping.h
+	touch getaddrinfo.h
+
+fping.o:	fping.c build_date.h fping.h getaddrinfo.h options.h seqmap.h
+
+fping_amiga.o:	fping_amiga.c fping.h getaddrinfo.h
+
+getaddrinfo.o:	getaddrinfo.c fping.h getaddrinfo.h
+
+ntop.o:	ntop.c
+
+pton.o:	pton.c
+
+seqmap.o:	seqmap.c options.h seqmap.h
+
+socket.o:	socket.c fping.h
+
+socket4.o:	socket4.c fping.h
+
+mem.o:	mem.c mem.h
+
+getopt.o:	getopt.c getopt.h
+
+rand.o:	rand.c
+
+
+fping:	 fping.o fping_amiga.o getaddrinfo.o ntop.o pton.o seqmap.o socket.o socket4.o mem.o getopt.o rand.o
+	${CC} ${CFLAGS} -s -o fping  fping.o fping_amiga.o getaddrinfo.o ntop.o pton.o seqmap.o socket.o socket4.o mem.o getopt.o rand.o ${LDLIBS}
+
+clean:
+	rm -f  fping.o fping_amiga.o getaddrinfo.o ntop.o pton.o seqmap.o socket.o socket4.o mem.o getopt.o rand.o build_date.h fping
+
+depend:
+	@echo Dependencies already done

src/Makefile.m68k

@@ -0,0 +1,48 @@
+# Portable Makefile generated by configure
+
+all:	fping
+
+CC     = m68k-amigaos-gcc
+CFLAGS = -O2 -noixemul -DAOS3 -D_DEBUG -I. -I.. -Iinclude -Wall -Werror
+LDLIBS = -lm
+
+build_date.h:
+	echo "#define BUILD_DATE \"$$(date -u)"\" >build_date.h
+
+fping.h:	 mem.h
+	touch fping.h
+
+getaddrinfo.h:	 fping.h
+	touch getaddrinfo.h
+
+fping.o:	fping.c build_date.h fping.h getaddrinfo.h options.h seqmap.h
+
+fping_amiga.o:	fping_amiga.c fping.h getaddrinfo.h
+
+getaddrinfo.o:	getaddrinfo.c fping.h getaddrinfo.h
+
+ntop.o:	ntop.c
+
+pton.o:	pton.c
+
+seqmap.o:	seqmap.c options.h seqmap.h
+
+socket.o:	socket.c fping.h
+
+socket4.o:	socket4.c fping.h
+
+mem.o:	mem.c mem.h
+
+getopt.o:	getopt.c getopt.h
+
+rand.o:	rand.c
+
+
+fping:	 fping.o fping_amiga.o getaddrinfo.o ntop.o pton.o seqmap.o socket.o socket4.o mem.o getopt.o rand.o
+	${CC} ${CFLAGS} -s -o fping  fping.o fping_amiga.o getaddrinfo.o ntop.o pton.o seqmap.o socket.o socket4.o mem.o getopt.o rand.o ${LDLIBS}
+
+clean:
+	rm -f  fping.o fping_amiga.o getaddrinfo.o ntop.o pton.o seqmap.o socket.o socket4.o mem.o getopt.o rand.o build_date.h fping
+
+depend:
+	@echo Dependencies already done

src/configure

@@ -0,0 +1,129 @@
+#!/bin/sh
+# 
+# Copyright (c) 2015, 16 Carsten Larsen
+# Copyright (c) 2014 Poul-Henning Kamp
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+#
+
+set -e
+
+HDRS='
+	fping.h
+	getaddrinfo.h
+	options.h
+	seqmap.h
+	mem.h
+	getopt.h
+'
+
+SRCS='
+	fping.c
+	fping_amiga.c
+	getaddrinfo.c
+	ntop.c
+	pton.c
+	seqmap.c
+	socket.c
+	socket4.c
+	mem.c
+	getopt.c
+	rand.c
+'
+
+if make -v 2>&1 | grep GNU > /dev/null 2>&1 ; then
+	echo "make is GNU make."
+	VALID=true
+#else
+#	echo "Wrong version of make."
+#	VALID=false
+fi
+
+if $VALID ; then
+	(
+	echo '# Portable Makefile generated by configure'
+	echo ''
+	echo 'all:	fping'
+	echo ''
+	if [ -n "$2" ] && [ $2 = "DEBUG" ] ; then
+		DEBUG="-D_DEBUG "
+	fi
+	if [ -n "$1" ] && [ $1 = "AMIGA" ] ; then
+		echo 'CC     = m68k-amigaos-gcc'
+		echo "CFLAGS = -O2 -noixemul -DAOS3 ${DEBUG}-I. -I.. -Iinclude -Wall -Werror"
+		echo "LDLIBS = -lm"
+	elif [ -n "$1" ] && [ $1 = "AROS" ] ; then
+		echo 'CC     = gcc'
+		echo "CFLAGS = -O2 -DAROS -I. ${DEBUG}-Wall -Werror"
+		echo "LDLIBS = -lm"
+	else
+		echo "CFLAGS = -O2 -Wall -Werror"
+		echo "LDLIBS = -lm"
+	fi
+	echo ''
+	echo 'build_date.h:'
+	echo '	echo "#define BUILD_DATE \"$$(date -u)"\" >build_date.h'
+	echo ''
+
+	for f in ${HDRS}
+	do
+		b=`basename $f .h`
+		i=`sed -n -e '/#include.*"/{
+			s/"$//
+			s/.*"//
+			p
+		}' $f | sort -u`
+		if [ "x${i}" != "x" ] ; then
+			echo "${b}.h:	" ${i}
+			echo "	touch ${b}.h"
+			echo
+		fi
+	done
+	
+	l=""
+	for f in ${SRCS}
+	do
+		b=`basename $f .c`
+		i=`sed -n -e '/#include.*"/{
+			s/"$//
+			s/.*"//
+			p
+		}' $f | sort -u`
+		echo "${b}.o:	${b}.c" ${i}
+		echo
+		l="${l} ${b}.o"
+	done
+
+	echo
+	echo "fping:	${l}"
+	echo "	\${CC} \${CFLAGS} -s -o fping ${l} \${LDLIBS}"
+	echo
+	echo "clean:"
+	echo "	rm -f ${l} build_date.h fping"
+	echo
+	echo "depend:"
+	echo "	@echo Dependencies already done"
+	) > Makefile
+	
+	echo "Makefile generated"
+fi

src/fping.h

@@ -0,0 +1,155 @@
+/*
+ * Written by Carsten Larsen.
+ * Public domain.
+ */
+
+#ifndef _FPING_H
+#define _FPING_H
+
+#include <clib/dos_protos.h>
+#include <clib/exec_protos.h>
+#include <clib/alib_protos.h>
+#include <clib/timer_protos.h>
+#include <clib/utility_protos.h>
+#include <utility/date.h>
+#include <devices/timer.h>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/file.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stddef.h>
+#include <unistd.h>
+#include <errno.h>
+#include <signal.h>
+#include <stdarg.h>
+
+#include "mem.h"
+#define calloc(x, y) allocmem(x*y)
+#define malloc(x) allocmem(x)
+#define free(x) freemem(x)
+
+#ifdef AOS3
+# include <clib/amitcp_protos.h>
+# include <amitcp/socketbasetags.h>
+# include <machine/types.h>
+# define uint16_t u_int16_t
+# define IPTR ULONG
+# define ANSI_CONSOLE 1
+# define gettimeofday(x, y) getsystime(x)
+typedef unsigned int socklen_t;
+typedef unsigned int sa_family_t;
+#endif
+
+typedef u_int16_t    in_port_t;
+
+#ifdef AROS
+# include <inttypes.h>
+# include <sys/time.h>
+# define Socket(a,b,c) socket(a,b,c)
+# define Bind(a,b,c) bind(a,b,c)
+# define RecvFrom(a,b,c,d,e,f) recvfrom(a,b,c,d,e,f)
+# define SendTo(a,b,c,d,e,f) sendto(a,b,c,d,e,f)
+#endif
+
+#ifdef AOS3
+struct addrinfo {
+    int ai_flags;
+    int ai_family;
+    int ai_socktype;
+    int ai_protocol;
+    socklen_t ai_addrlen;
+    char *ai_canonname;
+    struct sockaddr *ai_addr;
+    struct addrinfo *ai_next;
+};
+#endif
+
+#define FPING_SOCKADDR struct sockaddr_in
+
+#ifndef IPV6
+# define FPING_INADDR   struct in_addr
+# define FPING_ICMPHDR  struct icmp
+#else
+# define FPING_INADDR   struct in6_addr
+# define FPING_ICMPHDR  struct icmp6_hdr
+#endif
+
+#ifndef INADDR_NONE
+# define INADDR_NONE 0xffffffffU
+#endif
+
+#ifndef PF_INET6
+# define PF_INET6 10
+#endif
+#ifndef AF_INET6
+# define AF_INET6 PF_INET6
+#endif
+
+#ifndef INET_ADDRSTRLEN
+# define INET_ADDRSTRLEN 16
+#endif
+#ifndef INET6_ADDRSTRLEN
+# define INET6_ADDRSTRLEN 46
+#endif
+
+#if defined( DEBUG ) || defined( _DEBUG )
+# define DEBUG_TEXT "b"
+#else
+# define DEBUG_TEXT ""
+#endif
+
+#ifdef AOS3
+# define random() rand()
+# define srandom() srand()
+#endif
+
+#define PACKAGE_NAME "fping"
+#define PACKAGE_VERSION "3.13"
+
+/* No TTL (time to live) in socket options */
+#define NOTTL 1
+
+/* No TOS (type of service) in socket options */
+#define NOTOS 1
+
+#define SIGNAL ULONG
+
+/* fping.c */
+void crash_and_burn( char *message );
+void errno_crash_and_burn( char *message );
+int in_cksum( unsigned short *p, int n );
+int random_data_flag;
+char *prog;
+unsigned int debugging;
+
+/* socket.c */
+int  open_ping_socket();
+void init_ping_buffer(size_t ping_data_size);
+void socket_set_src_addr(int s, FPING_INADDR src_addr);
+int  socket_sendto_ping(int s, struct sockaddr *saddr, socklen_t saddr_len, uint16_t icmp_seq, uint16_t icmp_id);
+void close_ping_socket();
+void cleanup_ping_buffer();
+
+/* inet_ntop.c */
+const char *inet_ntop(int af, const void *src, char *dst, size_t size);
+
+/* inet_pton.c */
+int inet_pton(int af, const char *src, void *dst);
+
+/* fping_amiga.c */
+int open_libs();
+int getsystime(struct timeval *tv);
+
+extern struct Library *SocketBase;
+extern int errno;
+
+#ifndef AROS
+extern int h_errno;
+#endif
+
+#endif

src/fping_amiga.c

@@ -0,0 +1,178 @@
+/*
+ * Written by Carsten Larsen.
+ * Public domain.
+ */
+
+#include "fping.h"
+#include "getaddrinfo.h"
+
+#define OPEN_ERROR       "Cannot open %s.\n"
+#define OPEN_VER_ERROR   "Cannot open %s (%d.0)\n"
+#define DOSLIB_NAME      "dos.library"
+#define DOSLIB_REV       37L
+#define BSDLIB_NAME      "bsdsocket.library"
+#define BSDLIB_REV       03L
+#define UTILLIB_NAME     "utility.library"
+#define UTILLIB_REV      37L
+#define TIMER_NAME       TIMERNAME
+#define LIB_ERROR        4
+
+const char *vers = "\0$VER: " PACKAGE_NAME " " PACKAGE_VERSION " (21.02.2016)";
+
+#include <unistd.h>
+#ifdef AOS3
+uid_t getuid () {
+    return 1;
+}
+
+int setuid (uid_t id) {
+    return 1;
+}
+
+int h_errno;
+#endif
+
+struct Library*      DOSBase     = NULL;
+struct Library*      SocketBase  = NULL;
+struct Library*      UtilityBase = NULL;
+struct Device*       TimerBase   = NULL;
+struct timerequest*  TimeRequest = NULL;
+
+int create_timer();
+void delete_timer();
+
+void amiga_open_error(char *name)
+{
+    printf(OPEN_ERROR, name);
+}
+
+void amiga_open_lib_error(char *name, int version)
+{
+    printf(OPEN_VER_ERROR, name, version);
+}
+
+void close_libs()
+{
+    close_ping_socket();
+    cleanup_ping_buffer();
+
+    if (TimerBase != NULL) {
+        delete_timer();
+    }
+
+    if (UtilityBase != NULL) {
+        CloseLibrary(UtilityBase);
+        UtilityBase = NULL;
+    }
+
+    if (SocketBase != NULL) {
+        CloseLibrary(SocketBase);
+        SocketBase = NULL;
+    }
+
+    freeall();
+
+    if (DOSBase != NULL) {
+        CloseLibrary(DOSBase);
+        DOSBase = NULL;
+    }
+}
+
+int open_libs()
+{
+    struct timeval tv;
+
+    atexit(close_libs);
+    InitSemaphore(&GetaddrinfoSemaphore);
+
+    if(!(DOSBase = OpenLibrary((STRPTR)DOSLIB_NAME, DOSLIB_REV))) {
+        amiga_open_lib_error(DOSLIB_NAME, DOSLIB_REV);
+        return LIB_ERROR;
+    }
+
+    if(!(SocketBase = OpenLibrary((STRPTR)BSDLIB_NAME, BSDLIB_REV))) {
+        amiga_open_lib_error(BSDLIB_NAME, BSDLIB_REV);
+        return LIB_ERROR;
+    } else {
+        SocketBaseTags(
+            SBTM_SETVAL(SBTC_ERRNOPTR(sizeof(errno))), (IPTR) &errno,
+            SBTM_SETVAL(SBTC_HERRNOLONGPTR),           (IPTR) &h_errno,
+            SBTM_SETVAL(SBTC_LOGTAGPTR),               (IPTR) &prog,
+            TAG_DONE );
+    }
+
+    if(!(UtilityBase = OpenLibrary((STRPTR)UTILLIB_NAME, UTILLIB_REV))) {
+        amiga_open_lib_error(UTILLIB_NAME, UTILLIB_REV);
+        return LIB_ERROR;
+    }
+
+    if (create_timer() != 0) {
+        amiga_open_error(TIMER_NAME);
+        return LIB_ERROR;
+    }
+
+    gettimeofday(&tv, NULL);
+    srand(tv.tv_usec);
+
+    return 0;
+}
+
+#ifdef AOS3
+int create_timer()
+{
+    LONG error;
+    struct MsgPort *port = CreatePort(0, 0);
+    if (port == NULL)
+        return 1;
+
+    TimeRequest = (struct timerequest*)CreateExtIO(port, sizeof(struct timerequest));
+    if (TimeRequest == NULL)
+    {
+        DeletePort(port);
+        return 1;
+    }
+
+    error = OpenDevice(
+                (STRPTR)TIMER_NAME, UNIT_MICROHZ,
+                (struct IORequest*)TimeRequest, 0L
+            );
+
+    if (error != 0)
+    {
+        delete_timer(TimeRequest);
+        return 1;
+    }
+
+    TimerBase = (struct Device*)TimeRequest->tr_node.io_Device;
+
+    return 0;
+}
+
+void delete_timer()
+{
+    struct MsgPort *port;
+    if (TimeRequest == NULL)
+        return;
+
+    port = TimeRequest->tr_node.io_Message.mn_ReplyPort;
+
+    if (port != 0)
+        DeletePort(port);
+
+    CloseDevice((struct IORequest*)TimeRequest);
+    DeleteExtIO((struct IORequest*)TimeRequest);
+}
+
+int getsystime(struct timeval *tv)
+{
+    struct timeval tv1;
+
+    GetSysTime(&tv1);
+    *tv = tv1;
+
+    return 0;
+}
+#else
+int create_timer() { return 0; }
+void delete_timer() { }
+#endif

src/getaddrinfo.c

@@ -0,0 +1,507 @@
+/*
+ * Copyright (c) 2015, 16  Carsten Larsen
+ * Copyright (c) 2001, 02  Motoyuki Kasahara
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * This program provides getaddrinfo() and getnameinfo() described in
+ * RFC2133, 2553 and 3493.  These functions are mainly used for IPv6
+ * application to resolve hostname or address.
+ *
+ * This program is designed to be working on traditional IPv4 systems
+ * which don't have those functions.  Therefore, this implementation
+ * supports IPv4 only.
+ *
+ * This program is useful for application which should support both IPv6
+ * and traditional IPv4 systems.  Use genuine getaddrinfo() and getnameinfo()
+ * provided by system if the system supports IPv6.  Otherwise, use this
+ * implementation.
+ *
+ * This program also provides freeaddrinfo() and gai_strerror().
+ *
+ * Restriction:
+ *   getaddrinfo() and getnameinfo() of this program are NOT thread
+ *   safe, unless the cpp macro ENABLE_PTHREAD is defined.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <memory.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#include "fping.h"
+#include "getaddrinfo.h"
+
+#ifdef ENABLE_NLS
+#include <libintl.h>
+#endif
+
+#ifdef ENABLE_NLS
+#define _(string) gettext(string)
+#ifdef gettext_noop
+#define N_(string) gettext_noop(string)
+#else
+#define N_(string) (string)
+#endif
+#else
+#define gettext(string) (string)
+#define _(string) (string)
+#define N_(string) (string)
+#endif
+
+/*
+ * Error messages for gai_strerror().
+ */
+static char *eai_errlist[] = {
+    N_("Success"),
+
+    /* EAI_ADDRFAMILY */
+    N_("Address family for hostname not supported"),
+
+    /* EAI_AGAIN */
+    N_("Temporary failure in name resolution"),
+
+    /* EAI_BADFLAGS */
+    N_("Invalid value for ai_flags"),
+
+    /* EAI_FAIL */
+    N_("Non-recoverable failure in name resolution"),
+
+    /* EAI_FAMILY */
+    N_("ai_family not supported"),
+
+    /* EAI_MEMORY */
+    N_("Memory allocation failure"),
+
+    /* EAI_NONAME */
+    N_("hostname nor servname provided, or not known"),
+
+    /* EAI_OVERFLOW */
+    N_("An argument buffer overflowed"),
+
+    /* EAI_SERVICE */
+    N_("servname not supported for ai_socktype"),
+
+    /* EAI_SOCKTYPE */
+    N_("ai_socktype not supported"),
+
+    /* EAI_SYSTEM */
+    N_("System error returned in errno")
+};
+
+/*
+ * Default hints for getaddrinfo().
+ */
+static struct addrinfo default_hints = {
+    0, PF_UNSPEC, 0, 0, 0, NULL, NULL, NULL
+};
+
+/*
+ * Mutex.
+ */
+struct SignalSemaphore GetaddrinfoSemaphore;
+
+/*
+ * Declaration of static functions.
+ */
+#ifdef __STDC__
+static int is_integer(const char *);
+static int is_address(const char *);
+static int itoa_length(int);
+#else
+static int is_integer();
+static int is_address();
+static int itoa_length();
+#endif
+
+/*
+ * gai_strerror().
+ */
+const char *
+gai_strerror(ecode)
+int ecode;
+{
+    if (ecode < 0 || ecode > EAI_SYSTEM)
+        return _("Unknown error");
+
+    return gettext(eai_errlist[ecode]);
+}
+
+/*
+ * freeaddrinfo().
+ */
+void
+freeaddrinfo(ai)
+struct addrinfo *ai;
+{
+    struct addrinfo *next_ai;
+
+    while (ai != NULL) {
+        if (ai->ai_canonname != NULL)
+            free(ai->ai_canonname);
+        if (ai->ai_addr != NULL)
+            free(ai->ai_addr);
+        next_ai = ai->ai_next;
+        free(ai);
+        ai = next_ai;
+    }
+}
+
+/*
+ * Return 1 if the string `s' represents an integer.
+ */
+static int
+is_integer(s)
+const char *s;
+{
+    if (*s == '-' || *s == '+')
+        s++;
+    if (*s < '0' || '9' < *s)
+        return 0;
+
+    s++;
+    while ('0' <= *s && *s <= '9')
+        s++;
+
+    return (*s == '\0');
+}
+
+/*
+ * Return 1 if the string `s' represents an IPv4 address.
+ * Unlike inet_addr(), it doesn't permit malformed nortation such
+ * as "192.168".
+ */
+static int
+is_address(s)
+const char *s;
+{
+    const static char delimiters[] = {'.', '.', '.', '\0'};
+    int i, j;
+    int octet;
+
+    for (i = 0; i < 4; i++) {
+        if (*s == '0' && *(s + 1) != delimiters[i])
+            return 0;
+        for (j = 0, octet = 0; '0' <= *s && *s <= '9' && j < 3; s++, j++)
+            octet = octet * 10 + (*s - '0');
+        if (j == 0 || octet > 255 || *s != delimiters[i])
+            return 0;
+        s++;
+    }
+
+    return 1;
+}
+
+/*
+ * Calcurate length of the string `s', where `s' is set by
+ * sprintf(s, "%d", n).
+ */
+static int
+itoa_length(n)
+int n;
+{
+    int result = 1;
+
+    if (n < 0) {
+        n = -n;
+        result++;
+    }
+
+    while (n >= 10) {
+        result++;
+        n /= 10;
+    }
+
+    return result;
+}
+
+/*
+ * getaddrinfo().
+ */
+int
+getaddrinfo(nodename, servname, hints, res)
+const char *nodename;
+const char *servname;
+const struct addrinfo *hints;
+struct addrinfo **res;
+{
+    struct addrinfo *head_res = NULL;
+    struct addrinfo *tail_res = NULL;
+    struct addrinfo *new_res;
+    struct sockaddr_in *sa_in;
+    struct in_addr **addr_list;
+    struct in_addr *addr_list_buf[2];
+    struct in_addr addr_buf;
+    struct in_addr **ap;
+    struct servent *servent;
+    struct hostent *hostent;
+    const char *canonname = NULL;
+    in_port_t port;
+    int saved_h_errno;
+    int result = 0;
+
+    ObtainSemaphore(&GetaddrinfoSemaphore);
+    saved_h_errno = h_errno;
+
+    if (nodename == NULL && servname == NULL) {
+        result = EAI_NONAME;
+        goto end;
+    }
+
+    if (hints != NULL) {
+        if (hints->ai_family != PF_INET && hints->ai_family != PF_UNSPEC) {
+            result = EAI_FAMILY;
+            goto end;
+        }
+        if (hints->ai_socktype != SOCK_DGRAM
+                && hints->ai_socktype != SOCK_STREAM
+                && hints->ai_socktype != 0) {
+            result = EAI_SOCKTYPE;
+            goto end;
+        }
+    } else {
+        hints = &default_hints;
+    }
+
+    if (servname != NULL) {
+        if (is_integer(servname))
+            port = htons(atoi(servname));
+        else  {
+            if (hints->ai_flags & AI_NUMERICSERV) {
+                result = EAI_NONAME;
+                goto end;
+            }
+
+            if (hints->ai_socktype == SOCK_DGRAM)
+                servent = getservbyname((char*)servname, (char*)"udp");
+            else if (hints->ai_socktype == SOCK_STREAM)
+                servent = getservbyname((char*)servname, (char*)"tcp");
+            else if (hints->ai_socktype == 0)
+                servent = getservbyname((char*)servname, (char*)"tcp");
+            else {
+                result = EAI_SOCKTYPE;
+                goto end;
+            }
+
+            if (servent == NULL) {
+                result = EAI_SERVICE;
+                goto end;
+            }
+            port = servent->s_port;
+        }
+    } else {
+        port = htons(0);
+    }
+
+    if (nodename != NULL) {
+        if (is_address(nodename)) {
+            addr_buf.s_addr = inet_addr(nodename);
+            addr_list_buf[0] = &addr_buf;
+            addr_list_buf[1] = NULL;
+            addr_list = addr_list_buf;
+
+            if (hints->ai_flags & AI_CANONNAME
+                    && !(hints->ai_flags & AI_NUMERICHOST)) {
+                hostent = gethostbyaddr((char *)&addr_buf,
+                                        sizeof(struct in_addr), AF_INET);
+                if (hostent != NULL)
+                    canonname = hostent->h_name;
+                else
+                    canonname = nodename;
+            }
+        } else {
+            if (hints->ai_flags & AI_NUMERICHOST) {
+                result = EAI_NONAME;
+                goto end;
+            }
+
+            hostent = gethostbyname(nodename);
+            if (hostent == NULL) {
+                switch (h_errno) {
+                case HOST_NOT_FOUND:
+                case NO_DATA:
+                    result = EAI_NONAME;
+                    goto end;
+                case TRY_AGAIN:
+                    result = EAI_AGAIN;
+                    goto end;
+                default:
+                    result = EAI_FAIL;
+                    goto end;
+                }
+            }
+            addr_list = (struct in_addr **)hostent->h_addr_list;
+
+            if (hints->ai_flags & AI_CANONNAME)
+                canonname = hostent->h_name;
+        }
+    } else {
+        if (hints->ai_flags & AI_PASSIVE)
+            addr_buf.s_addr = htonl(INADDR_ANY);
+        else
+            addr_buf.s_addr = htonl(0x7F000001);
+        addr_list_buf[0] = &addr_buf;
+        addr_list_buf[1] = NULL;
+        addr_list = addr_list_buf;
+    }
+
+    for (ap = addr_list; *ap != NULL; ap++) {
+        new_res = (struct addrinfo *)malloc(sizeof(struct addrinfo));
+        if (new_res == NULL) {
+            if (head_res != NULL)
+                freeaddrinfo(head_res);
+            result = EAI_MEMORY;
+            goto end;
+        }
+
+        new_res->ai_family = PF_INET;
+        new_res->ai_socktype = hints->ai_socktype;
+        new_res->ai_protocol = hints->ai_protocol;
+        new_res->ai_addr = NULL;
+        new_res->ai_addrlen = sizeof(struct sockaddr_in);
+        new_res->ai_canonname = NULL;
+        new_res->ai_next = NULL;
+
+        new_res->ai_addr = (struct sockaddr *)
+                           malloc(sizeof(struct sockaddr_in));
+        if (new_res->ai_addr == NULL) {
+            free(new_res);
+            if (head_res != NULL)
+                freeaddrinfo(head_res);
+            result = EAI_MEMORY;
+            goto end;
+        }
+
+        sa_in = (struct sockaddr_in *)new_res->ai_addr;
+        memset(sa_in, 0, sizeof(struct sockaddr_in));
+        sa_in->sin_family = PF_INET;
+        sa_in->sin_port = port;
+        memcpy(&sa_in->sin_addr, *ap, sizeof(struct in_addr));
+
+        if (head_res == NULL)
+            head_res = new_res;
+        else
+            tail_res->ai_next = new_res;
+        tail_res = new_res;
+    }
+
+    if (canonname != NULL && head_res != NULL) {
+        head_res->ai_canonname = (char *)malloc(strlen(canonname) + 1);
+        if (head_res->ai_canonname != NULL)
+            strcpy(head_res->ai_canonname, canonname);
+    }
+
+    *res = head_res;
+
+end:
+    h_errno = saved_h_errno;
+    ReleaseSemaphore(&GetaddrinfoSemaphore);
+    return result;
+}
+
+int getnameinfo(const struct sockaddr *sa, socklen_t salen, char *node, socklen_t nodelen, char *serv, socklen_t servlen, int flags) {
+
+    const struct sockaddr_in *sa_in = (const struct sockaddr_in *)sa;
+    struct hostent *hostent;
+    struct servent *servent;
+    char *ntoa_address;
+    int saved_h_errno;
+    int result = 0;
+
+    ObtainSemaphore(&GetaddrinfoSemaphore);
+    saved_h_errno = h_errno;
+
+    if (sa_in->sin_family != PF_INET) {
+        result = EAI_FAMILY;
+        goto end;
+    } else if (node == NULL && serv == NULL) {
+        result = EAI_NONAME;
+        goto end;
+    }
+
+    if (serv != NULL && servlen > 0) {
+        if (flags & NI_NUMERICSERV)
+            servent = NULL;
+        else if (flags & NI_DGRAM)
+            servent = getservbyport(sa_in->sin_port, "udp");
+        else
+            servent = getservbyport(sa_in->sin_port, "tcp");
+
+        if (servent != NULL) {
+            if (servlen <= strlen(servent->s_name)) {
+                result = EAI_OVERFLOW;
+                goto end;
+            }
+            strcpy(serv, servent->s_name);
+        } else {
+            if (servlen <= itoa_length(ntohs(sa_in->sin_port))) {
+                result = EAI_OVERFLOW;
+                goto end;
+            }
+            sprintf(serv, "%d", ntohs(sa_in->sin_port));
+        }
+    }
+
+    if (node != NULL && nodelen > 0) {
+        if (flags & NI_NUMERICHOST)
+            hostent = NULL;
+        else {
+            hostent = gethostbyaddr((char *)&sa_in->sin_addr,
+                                    sizeof(struct in_addr), AF_INET);
+        }
+        if (hostent != NULL) {
+            if (nodelen <= strlen(hostent->h_name)) {
+                result = EAI_OVERFLOW;
+                goto end;
+            }
+            strcpy(node, hostent->h_name);
+        } else {
+            if (flags & NI_NAMEREQD) {
+                result = EAI_NONAME;
+                goto end;
+            }
+            ntoa_address = inet_ntoa(sa_in->sin_addr);
+            if (nodelen <= strlen(ntoa_address)) {
+                result = EAI_OVERFLOW;
+                goto end;
+            }
+            strcpy(node, ntoa_address);
+        }
+
+    }
+
+end:
+    h_errno = saved_h_errno;
+    ReleaseSemaphore(&GetaddrinfoSemaphore);
+    return result;
+}

src/getaddrinfo.h

@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) 2015, 16  Carsten Larsen
+ * Copyright (c) 2001, 02  Motoyuki Kasahara
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef INET_GETADDRINFO_H
+#define INET_GETADDRINFO_H
+
+#include <sys/types.h>
+#include <netdb.h>
+
+#include "fping.h"
+
+/********************************************************************/
+/*
+ * Undefine all the macros.
+ * <netdb.h> might defines some of them.
+ */
+#ifdef EAI_ADDRFAMILY
+#undef EAI_ADDRFAMILY
+#endif
+#ifdef EAI_AGAIN
+#undef EAI_AGAIN
+#endif
+#ifdef EAI_BADFLAGS
+#undef EAI_BADFLAGS
+#endif
+#ifdef EAI_FAIL
+#undef EAI_FAIL
+#endif
+#ifdef EAI_FAMILY
+#undef EAI_FAMILY
+#endif
+#ifdef EAI_MEMORY
+#undef EAI_MEMORY
+#endif
+#ifdef EAI_NONAME
+#undef EAI_NONAME
+#endif
+#ifdef EAI_OVERFLOW
+#undef EAI_OVERFLOW
+#endif
+#ifdef EAI_SERVICE
+#undef EAI_SERVICE
+#endif
+#ifdef EAI_SOCKTYPE
+#undef EAI_SOCKTYPE
+#endif
+#ifdef EAI_SYSTEM
+#undef EAI_SYSTEM
+#endif
+
+#ifdef AI_PASSIVE
+#undef AI_PASSIVE
+#endif
+#ifdef AI_CANONNAME
+#undef AI_CANONNAME
+#endif
+#ifdef AI_NUMERICHOST
+#undef AI_NUMERICHOST
+#endif
+#ifdef AI_NUMERICSERV
+#undef AI_NUMERICSERV
+#endif
+#ifdef AI_V4MAPPED
+#undef AI_V4MAPPED
+#endif
+#ifdef AI_ALL
+#undef AI_ALL
+#endif
+#ifdef AI_ADDRCONFIG
+#undef AI_ADDRCONFIG
+#endif
+#ifdef AI_DEFAULT
+#undef AI_DEFAULT
+#endif
+
+#ifdef NI_NOFQDN
+#undef NI_NOFQDN
+#endif
+#ifdef NI_NUMERICHOST
+#undef NI_NUMERICHOST
+#endif
+#ifdef NI_NAMEREQD
+#undef NI_NAMEREQD
+#endif
+#ifdef NI_NUMERICSERV
+#undef NI_NUMERICSERV
+#endif
+#ifdef NI_NUMERICSCOPE
+#undef NI_NUMERICSCOPE
+#endif
+
+#ifdef NI_DGRAM
+#undef NI_DGRAM
+#endif
+#ifdef NI_MAXHOST
+#undef NI_MAXHOST
+#endif
+#ifdef NI_MAXSERV
+#undef NI_MAXSERV
+#endif
+
+/*
+ * Fake struct and function names.
+ * <netdb.h> might declares all or some of them.
+ */
+/*
+#if defined(HAVE_GETADDRINFO) || defined(HAVE_GETNAMEINFO)
+#define addrinfo my_addrinfo
+#define gai_strerror my_gai_strerror
+#define freeaddrinfo my_freeaddrinfo
+#define getaddrinfo my_getaddrinfo
+#define getnameinfo my_getnameinfo
+#endif
+*/
+
+/********************************************************************/
+/*
+ * Error codes.
+ */
+#define EAI_ADDRFAMILY	1
+#define EAI_AGAIN	2
+#define EAI_BADFLAGS	3
+#define EAI_FAIL	4
+#define EAI_FAMILY	5
+#define EAI_MEMORY	6
+#define EAI_NONAME	7
+#define EAI_OVERFLOW	8
+#define EAI_SERVICE	9
+#define EAI_SOCKTYPE	10
+#define EAI_SYSTEM	11
+
+/*
+ * Flags for getaddrinfo().
+ */
+#define AI_ADDRCONFIG	0x0001
+#define AI_ALL		0x0002
+#define AI_CANONNAME	0x0004
+#define AI_NUMERICHOST	0x0008
+#define AI_NUMERICSERV	0x0010
+#define AI_PASSIVE	0x0020
+#define AI_V4MAPPED	0x0040
+#define AI_DEFAULT	(AI_V4MAPPED | AI_ADDRCONFIG)
+
+/*
+ * Flags for getnameinfo().
+ */
+#define NI_DGRAM	0x0001
+#define NI_NAMEREQD	0x0002
+#define NI_NOFQDN	0x0004
+#define NI_NUMERICHOST	0x0008
+#define NI_NUMERICSCOPE	0x0010
+#define NI_NUMERICSERV	0x0020
+
+/*
+ * Maximum length of FQDN and servie name for getnameinfo().
+ */
+#define NI_MAXHOST	1025
+#define NI_MAXSERV	32
+
+/*
+ * Address families and Protocol families.
+ */
+#if 0
+#ifndef AF_UNSPEC
+#define AF_UNSPEC AF_INET
+#endif
+#ifndef PF_UNSPEC
+#define PF_UNSPEC PF_INET
+#endif
+#endif
+
+#include <exec/types.h>
+extern struct SignalSemaphore GetaddrinfoSemaphore;
+
+const char* gai_strerror(int);
+void freeaddrinfo(struct addrinfo *);
+int getaddrinfo(const char *, const char *, const struct addrinfo *, struct addrinfo **);
+int getnameinfo(const struct sockaddr *, socklen_t, char *, socklen_t, char *, socklen_t, int);
+
+#endif

src/getopt.c

@@ -0,0 +1,117 @@
+/*
+ * getopt.c --
+ *
+ *      Standard UNIX getopt function.  Code is from BSD.
+ *
+ * Copyright (c) 1987-2002 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * A. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * B. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * C. Neither the names of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+ * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* #if !defined(lint)
+ * static char sccsid[] = "@(#)getopt.c 8.2 (Berkeley) 4/2/94";
+ * #endif
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "getopt.h"
+
+int     opterr = 1,             /* if error message should be printed */
+        optind = 1,             /* index into parent argv vector */
+        optopt,                 /* character checked for validity */
+        optreset;               /* reset getopt */
+char    *optarg;                /* argument associated with option */
+
+#define BADCH   (int)'?'
+#define BADARG  (int)':'
+#define EMSG    ""
+
+/*
+ * getopt --
+ *      Parse argc/argv argument vector.
+ */
+int
+getopt( int nargc,
+            char * const *nargv,
+        const char *ostr)
+{
+        static char *place = EMSG;              /* option letter processing */
+        char *oli;                              /* option letter list index */
+
+        if (optreset || !*place) {              /* update scanning pointer */
+                optreset = 0;
+                if (optind >= nargc || *(place = nargv[optind]) != '-') {
+                        place = EMSG;
+                        return (EOF);
+                }
+                if (place[1] && *++place == '-') {      /* found "--" */
+                        ++optind;
+                        place = EMSG;
+                        return (EOF);
+                }
+        }                                       /* option letter okay? */
+        if ((optopt = (int)*place++) == (int)':' ||
+            !(oli = (char*) strchr(ostr, optopt))) {
+                /*
+                 * if the user didn't specify '-' as an option,
+                 * assume it means EOF.
+                 */
+                 if (optopt == (int)'-')
+                        return (EOF);
+                if (!*place)
+                        ++optind;
+                 if (opterr && *ostr != ':')
+                         (void)fprintf(stderr,
+                             "illegal option -- %c\n", optopt);
+                 return (BADCH);
+         }
+         if (*++oli != ':') {                    /* don't need argument */
+                 optarg = NULL;
+                if (!*place)
+                        ++optind;
+        }
+        else {                                  /* need an argument */
+                if (*place)                     /* no white space */
+                        optarg = place;
+                else if (nargc <= ++optind) {   /* no arg */
+                        place = EMSG;
+                        if (*ostr == ':')
+                                return (BADARG);
+                        if (opterr)
+                                (void)fprintf(stderr,
+                                    "option requires an argument -- %c\n",
+                                     optopt);
+                        return (BADCH);
+                }
+                else                            /* white space */
+                        optarg = nargv[optind];
+                place = EMSG;
+                ++optind;
+        }
+        return (optopt);                        /* dump back option letter */
+}

src/getopt.h

@@ -0,0 +1,51 @@
+#ifndef _HAD_GETOPT_H
+#define _HAD_GETOPT_H
+
+/*
+  getopt.h -- header for getopt() replacement function
+  Copyright (C) 1999-2011 Dieter Baron and Thomas Klausner
+
+  This file is part of libzip, a library to manipulate ZIP archives.
+  The authors can be contacted at <libzip@nih.at>
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in
+     the documentation and/or other materials provided with the
+     distribution.
+  3. The names of the authors may not be used to endorse or promote
+     products derived from this software without specific prior
+     written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
+  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+  IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+  IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern char *optarg;
+extern int optind;
+extern int opterr;
+
+extern int getopt(int, char * const *, const char *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _HAD_GETOPT_H */

src/include/clib/amitcp_protos.h

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2015 Carsten Larsen
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef _SOCKET_AMITCP_H
+#define _SOCKET_AMITCP_H
+//--------------------------------------------------------------------------//
+#define AMITCP_BASE_NAME SocketBase
+#include "inline/amitcp.h"
+//--------------------------------------------------------------------------//
+#define socket                 Socket
+#define bind                   Bind
+#define listen                 Listen
+#define accept                 Accept
+#define connect                Connect
+#define send                   Send
+#define sendto                 SendTo
+#define sendmsg                SendMsg
+#define recv                   Recv
+#define recvfrom               RecvFrom
+#define recvmsg                RecvMsg
+#define select                 Select
+#define shutdown               ShutDown
+#define setsockopt             SetSockOpt
+#define getsockopt             GetSockOpt
+#define getsockname            GetSockName
+#define getpeername            GetPeerName
+#define inet_addr              Inet_Addr
+#define inet_network           Inet_Network
+#define inet_ntoa              Inet_NtoA
+#define gethostbyname          GetHostByName
+#define gethostbyaddr          GetHostByAddr
+#define getnetbyname           GetNetByName
+#define getnetbyaddr           GetNetByAddr
+#define getservbyname          GetServByName
+#define getservbyport          GetServByPort
+#define getprotobyname         GetProtoByName
+#define getprotobynumber       GetProtoByNumber
+#define getdtablesize          GetDTableSize
+#define gethostname            GetHostName
+#define gethostid              GetHostId
+#define vsyslog                SyslogA
+#define syslog                 Syslog
+//--------------------------------------------------------------------------//
+#define Accept                 TCP_Accept
+#define Bind                   TCP_Bind
+#define CloseSocket            TCP_CloseSocket
+#define Connect                TCP_Connect
+#define Dup2Socket             TCP_Dup2Socket
+#define Errno                  TCP_Errno
+#define GetDTableSize          TCP_GetDTableSize
+#define GetHostByAddr          TCP_GetHostByAddr
+#define GetHostByName          TCP_GetHostByName
+#define GetHostId              TCP_GetHostId
+#define GetHostName            TCP_GetHostName
+#define GetNetByAddr           TCP_GetNetByAddr
+#define GetNetByName           TCP_GetNetByName
+#define GetPeerName            TCP_GetPeerName
+#define GetProtoByName         TCP_GetProtoByName
+#define GetProtoByNumber       TCP_GetProtoByNumber
+#define GetServByName          TCP_GetServByName
+#define GetServByPort          TCP_GetServByPort
+#define GetSockName            TCP_GetSockName
+#define GetSockOpt             TCP_GetSockOpt
+#define GetSocketEvents        TCP_GetSocketEvents
+#define Inet_Addr              TCP_Inet_Addr
+#define Inet_LnaOf             TCP_Inet_LnaOf
+#define Inet_MakeAddr          TCP_Inet_MakeAddr
+#define Inet_NetOf             TCP_Inet_NetOf
+#define Inet_Network           TCP_Inet_Network
+#define Inet_NtoA(x)           TCP_Inet_NtoA((x).s_addr)
+#define IoctlSocket            TCP_IoctlSocket
+#define Listen                 TCP_Listen
+#define ObtainSocket           TCP_ObtainSocket
+#define Recv                   TCP_Recv
+#define RecvFrom               TCP_RecvFrom
+#define RecvMsg                TCP_RecvMsg
+#define ReleaseCopyOfSocket    TCP_ReleaseCopyOfSocket
+#define ReleaseSocket          TCP_ReleaseSocket
+#define Send                   TCP_Send
+#define SendMsg                TCP_SendMsg
+#define SendTo                 TCP_SendTo
+#define SetErrnoPtr            TCP_SetErrnoPtr
+#define SetSockOpt             TCP_SetSockOpt
+#define SetSocketSignals       TCP_SetSocketSignals
+#define ShutDown               TCP_ShutDown
+#define Socket                 TCP_Socket
+#define SocketBaseTagList      TCP_SocketBaseTagList
+#define SocketBaseTags         TCP_SocketBaseTags
+#define SyslogA                TCP_SyslogA
+#define WaitSelect             TCP_WaitSelect
+#define Select(n,r,w,e,t)      TCP_WaitSelect(n,r,w,e,t,0)
+//--------------------------------------------------------------------------//
+#endif

src/include/inline/amitcp.h

@@ -0,0 +1,203 @@
+/* Automatically generated header! Do not edit! */
+
+#ifndef _INLINE_AMITCP_H
+#define _INLINE_AMITCP_H
+
+#ifndef __INLINE_MACROS_H
+#include <inline/macros.h>
+#endif /* !__INLINE_MACROS_H */
+
+#ifndef AMITCP_BASE_NAME
+#define AMITCP_BASE_NAME lss->lx_BsdSocketBase
+#endif /* !AMITCP_BASE_NAME */
+
+#define TCP_Accept(s, addr, addrlen) \
+	LP3(0x30, LONG, TCP_Accept, LONG, s, d0, struct sockaddr *, addr, a0, int *, addrlen, a1, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_Bind(s, name, namelen) \
+	LP3(0x24, LONG, TCP_Bind, LONG, s, d0, const struct sockaddr *, name, a0, LONG, namelen, d1, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_CloseSocket(d) \
+	LP1(0x78, LONG, TCP_CloseSocket, LONG, d, d0, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_Connect(s, name, namelen) \
+	LP3(0x36, LONG, TCP_Connect, LONG, s, d0, const struct sockaddr *, name, a0, LONG, namelen, d1, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_Dup2Socket(fd1, fd2) \
+	LP2(0x108, LONG, TCP_Dup2Socket, LONG, fd1, d0, LONG, fd2, d1, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_Errno() \
+	LP0(0xa2, LONG, TCP_Errno, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_GetDTableSize() \
+	LP0(0x8a, LONG, TCP_GetDTableSize, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_GetHostByAddr(addr, len, type) \
+	LP3(0xd8, struct hostent  *, TCP_GetHostByAddr, const UBYTE *, addr, a0, LONG, len, d0, LONG, type, d1, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_GetHostByName(name) \
+	LP1(0xd2, struct hostent  *, TCP_GetHostByName, const UBYTE *, name, a0, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_GetHostId() \
+	LP0(0x120, ULONG, TCP_GetHostId, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_GetHostName(hostname, size) \
+	LP2(0x11a, LONG, TCP_GetHostName, STRPTR, hostname, a0, LONG, size, d0, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_GetNetByAddr(net, type) \
+	LP2(0xe4, struct netent   *, TCP_GetNetByAddr, LONG, net, d0, LONG, type, d1, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_GetNetByName(name) \
+	LP1(0xde, struct netent   *, TCP_GetNetByName, const UBYTE *, name, a0, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_GetPeerName(s, hostname, namelen) \
+	LP3(0x6c, LONG, TCP_GetPeerName, LONG, s, d0, struct sockaddr *, hostname, a0, int *, namelen, a1, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_GetProtoByName(name) \
+	LP1(0xf6, struct protoent *, TCP_GetProtoByName, const UBYTE *, name, a0, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_GetProtoByNumber(proto) \
+	LP1(0xfc, struct protoent *, TCP_GetProtoByNumber, LONG, proto, d0, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_GetServByName(name, proto) \
+	LP2(0xea, struct servent  *, TCP_GetServByName, const UBYTE *, name, a0, const UBYTE *, proto, a1, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_GetServByPort(port, proto) \
+	LP2(0xf0, struct servent  *, TCP_GetServByPort, LONG, port, d0, const UBYTE *, proto, a0, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_GetSockName(s, hostname, namelen) \
+	LP3(0x66, LONG, TCP_GetSockName, LONG, s, d0, struct sockaddr *, hostname, a0, int *, namelen, a1, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_GetSockOpt(s, level, optname, optval, optlen) \
+	LP5(0x60, LONG, TCP_GetSockOpt, LONG, s, d0, LONG, level, d1, LONG, optname, d2, void *, optval, a0, int *, optlen, a1, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_GetSocketEvents(eventmaskp) \
+	LP1(0x12c, LONG, TCP_GetSocketEvents, ULONG *, eventmaskp, a0, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_Inet_Addr(cp) \
+	LP1(0xb4, ULONG, TCP_Inet_Addr, const UBYTE *, cp, a0, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_Inet_LnaOf(in) \
+	LP1(0xba, ULONG, TCP_Inet_LnaOf, LONG, in, d0, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_Inet_MakeAddr(net, host) \
+	LP2(0xc6, ULONG, TCP_Inet_MakeAddr, ULONG, net, d0, ULONG, host, d1, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_Inet_NetOf(in) \
+	LP1(0xc0, ULONG, TCP_Inet_NetOf, LONG, in, d0, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_Inet_Network(cp) \
+	LP1(0xcc, ULONG, TCP_Inet_Network, const UBYTE *, cp, a0, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_Inet_NtoA(in) \
+	LP1(0xae, char *, TCP_Inet_NtoA, ULONG, in, d0, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_IoctlSocket(d, request, argp) \
+	LP3(0x72, LONG, TCP_IoctlSocket, LONG, d, d0, ULONG, request, d1, char *, argp, a0, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_Listen(s, backlog) \
+	LP2(0x2a, LONG, TCP_Listen, LONG, s, d0, LONG, backlog, d1, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_ObtainSocket(id, domain, type, protocol) \
+	LP4(0x90, LONG, TCP_ObtainSocket, LONG, id, d0, LONG, domain, d1, LONG, type, d2, LONG, protocol, d3, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_Recv(s, buf, len, flags) \
+	LP4(0x4e, LONG, TCP_Recv, LONG, s, d0, UBYTE *, buf, a0, LONG, len, d1, LONG, flags, d2, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_RecvFrom(s, buf, len, flags, from, fromlen) \
+	LP6(0x48, LONG, TCP_RecvFrom, LONG, s, d0, UBYTE *, buf, a0, LONG, len, d1, LONG, flags, d2, struct sockaddr *, from, a1, int *, fromlen, a2, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_RecvMsg(s, msg, flags) \
+	LP3(0x114, LONG, TCP_RecvMsg, LONG, s, d0, struct msghdr *, msg, a0, LONG, flags, d1, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_ReleaseCopyOfSocket(fd, id) \
+	LP2(0x9c, LONG, TCP_ReleaseCopyOfSocket, LONG, fd, d0, LONG, id, d1, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_ReleaseSocket(fd, id) \
+	LP2(0x96, LONG, TCP_ReleaseSocket, LONG, fd, d0, LONG, id, d1, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_Send(s, msg, len, flags) \
+	LP4(0x42, LONG, TCP_Send, LONG, s, d0, const UBYTE *, msg, a0, LONG, len, d1, LONG, flags, d2, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_SendMsg(s, msg, flags) \
+	LP3(0x10e, LONG, TCP_SendMsg, LONG, s, d0, const struct msghdr *, msg, a0, LONG, flags, d1, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_SendTo(s, msg, len, flags, to, tolen) \
+	LP6(0x3c, LONG, TCP_SendTo, LONG, s, d0, const UBYTE *, msg, a0, LONG, len, d1, LONG, flags, d2, const struct sockaddr *, to, a1, LONG, tolen, d3, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_SetErrnoPtr(errno_p, size) \
+	LP2(0xa8, LONG, TCP_SetErrnoPtr, void *, errno_p, a0, LONG, size, d0, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_SetSockOpt(s, level, optname, optval, optlen) \
+	LP5(0x5a, LONG, TCP_SetSockOpt, LONG, s, d0, LONG, level, d1, LONG, optname, d2, const void *, optval, a0, LONG, optlen, d3, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_SetSocketSignals(SIGINTR, SIGIO, SIGURG) \
+	LP3NR(0x84, TCP_SetSocketSignals, ULONG, SIGINTR, d0, ULONG, SIGIO, d1, ULONG, SIGURG, d2, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_ShutDown(s, how) \
+	LP2(0x54, LONG, TCP_ShutDown, LONG, s, d0, LONG, how, d1, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_Socket(domain, type, protocol) \
+	LP3(0x1e, LONG, TCP_Socket, LONG, domain, d0, LONG, type, d1, LONG, protocol, d2, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_SocketBaseTagList(taglist) \
+	LP1(0x126, LONG, TCP_SocketBaseTagList, struct TagItem *, taglist, a0, \
+	, AMITCP_BASE_NAME)
+
+#ifndef NO_INLINE_STDARG
+#define TCP_SocketBaseTags(tags...) \
+	({ULONG _tags[] = { tags }; TCP_SocketBaseTagList((struct TagItem *)_tags);})
+#endif
+
+#define TCP_SyslogA(level, format, ap) \
+	LP3NR(0x102, TCP_SyslogA, ULONG, level, d0, const char *, format, a0, va_list, ap, a1, \
+	, AMITCP_BASE_NAME)
+
+#define TCP_WaitSelect(nfds, readfds, writefds, execptfds, timeout, maskp) \
+	LP6(0x7e, LONG, TCP_WaitSelect, LONG, nfds, d0, fd_set *, readfds, a0, fd_set *, writefds, a1, fd_set *, execptfds, a2, struct timeval *, timeout, a3, ULONG *, maskp, d1, \
+	, AMITCP_BASE_NAME)
+
+#endif /* !_INLINE_AMITCP_H */

src/mem.c

@@ -0,0 +1,253 @@
+//--------------------------------------------------------------------------//
+// This file is in the public domain.                                       //
+//--------------------------------------------------------------------------//
+#include <stddef.h>
+#include <string.h>
+#include <exec/io.h>
+#include <exec/types.h>
+#include <exec/memory.h>
+#include <exec/semaphores.h>
+#include <clib/exec_protos.h>
+//--------------------------------------------------------------------------//
+#include "mem.h"
+//--------------------------------------------------------------------------//
+#if defined( DEBUG ) || defined( _DEBUG )
+# include <stdio.h>
+# define DBG_MEMORY 128
+# define DBG_MEMORY_ADDR 256
+#endif
+//--------------------------------------------------------------------------//
+struct MemoryBlock
+{
+    struct MemoryBlock *next;
+    size_t size;
+    void *address;
+};
+//--------------------------------------------------------------------------//
+struct MemoryList
+{
+    struct MemoryBlock *first;
+    struct MemoryBlock *last;
+    long size;
+    long count;
+    long opcount;
+};
+//--------------------------------------------------------------------------//
+static struct MemoryList *list = NULL;
+//--------------------------------------------------------------------------//
+void allocerror(char*, size_t);
+void deallocerror(char*, void*);
+//--------------------------------------------------------------------------//
+void* allocmem(size_t size)
+{
+    struct MemoryBlock *newblock;
+    size_t allocsize;
+
+    if (list == NULL) {
+        list =
+            (struct MemoryList*)
+            AllocVec(sizeof(struct MemoryList), MEMF_ANY | MEMF_CLEAR);
+
+        if (!list) {
+            allocerror("list", sizeof(struct MemoryList));
+            return 0;
+        }
+
+        list->first = NULL;
+        list->last = NULL;
+        list->size = 0;
+        list->count = 0;
+    }
+
+    // Align to bytes of 4
+    allocsize = (size + 3) & ~0x03;
+
+    newblock =
+        (struct MemoryBlock*)
+        AllocVec(sizeof(struct MemoryBlock), MEMF_ANY | MEMF_CLEAR);
+
+    if (!newblock) {
+        allocerror("block", sizeof(struct MemoryBlock));
+        return 0;
+    }
+
+    newblock->address =
+        (struct MemoryBlock*)
+        AllocVec(allocsize, MEMF_ANY | MEMF_CLEAR);
+
+    if (!newblock->address) {
+        FreeVec(newblock);
+        allocerror("memory", allocsize);
+        return 0;
+    }
+
+    newblock->size = allocsize;
+    newblock->next = NULL;
+
+    if(list->first == NULL) {
+        list->first = newblock;
+        list->last = newblock;
+    } else {
+        list->last->next = newblock;
+        list->last = newblock;
+    }
+
+    list->size += allocsize;
+    list->count++;
+
+    list->opcount++;
+#if defined( DEBUG ) || defined( _DEBUG )
+    if ( debugging & DBG_MEMORY_ADDR && list->opcount % 25 == 0) {
+        fprintf(stderr,
+                "Memory usage: %ld bytes allocated in %ld blocks.\n",
+                list->size,
+                list->count
+               );
+    }
+#endif
+
+#if defined( DEBUG ) || defined( _DEBUG )
+    if( debugging & DBG_MEMORY_ADDR )
+    {
+        fprintf(stderr,
+                "Memory allocated at address (%X)\n",
+                (unsigned int)newblock->address);
+    }
+#endif
+
+    return newblock->address;
+}
+
+//--------------------------------------------------------------------------//
+
+void freemem(void* block)
+{
+    struct MemoryBlock *current, *last;
+
+    if (list == NULL || block == NULL) {
+        deallocerror("list", 0);
+        return;
+    }
+
+    if (block == NULL) {
+        deallocerror("memory", 0);
+        return;
+    }
+
+    last = NULL;
+    current = list->first;
+    while (current != NULL && current->address != block) {
+        last = current;
+        current = current->next;
+    }
+
+    if (current == NULL) {
+        deallocerror("address not found", block);
+        return;
+    }
+
+    list->size -= current->size;
+    list->count--;
+
+    if (list->first == current) {
+        list->first = NULL;
+        list->last = NULL;
+    } else if (list->last == current) {
+        last->next = current->next;
+        list->last = last;
+    } else {
+        last->next = current->next;
+    }
+
+    FreeVec(current->address);
+    FreeVec(current);
+
+    list->opcount++;
+
+#if defined( DEBUG ) || defined( _DEBUG )
+    if( debugging & DBG_MEMORY_ADDR )
+    {
+        fprintf(stderr,
+                "Memory deallocated at address (%X)\n",
+                (unsigned int)block);
+    }
+#endif
+}
+
+void freeall()
+{
+    struct MemoryBlock *current, *next;
+
+    if (list == NULL) {
+        return;
+    }
+
+#if defined( DEBUG ) || defined( _DEBUG )
+    if( debugging & DBG_MEMORY )
+    {
+        fprintf(stderr,
+                "Cleaning up (%ld) bytes in (%ld) blocks.\n",
+                list->size,
+                list->count
+               );
+    }
+#endif
+
+    current = list->first;
+    while (current != NULL) {
+        next = current->next;
+        FreeVec(current->address);
+        FreeVec(current);
+        current = next;
+    }
+
+    FreeVec(list);
+    list = NULL;
+}
+
+//--------------------------------------------------------------------------//
+
+void allocerror(char *descr, size_t size)
+{
+#if defined( DEBUG ) || defined( _DEBUG )
+    if( debugging & DBG_MEMORY_ADDR )
+    {
+        fprintf(stderr,
+                "Memory allocation error (%s) with size (%ld)\n",
+                descr,
+                size);
+    }
+#endif
+}
+
+void deallocerror(char *descr, void *p)
+{
+#if defined( DEBUG ) || defined( _DEBUG )
+    if( debugging & DBG_MEMORY_ADDR )
+    {
+        fprintf(stderr,
+                "Memory deallocation error (%s) address (%X)\n",
+                descr,
+                (unsigned int)p);
+    }
+#endif
+}
+
+//--------------------------------------------------------------------------//
+
+char *strdup(const char *s1)
+{
+    char *s2;
+    size_t len = strlen(s1);
+    s2 = allocmem(++len);
+
+    if(s2 == NULL)
+    {
+        return NULL;
+    }
+
+    memcpy(s2, s1, --len);
+    return s2;
+}
+
+//--------------------------------------------------------------------------//

src/mem.h

@@ -0,0 +1,18 @@
+//--------------------------------------------------------------------------//
+// This file is in the public domain.                                       //
+//--------------------------------------------------------------------------//
+#ifndef AMIGA_MEM_H
+#define AMIGA_MEM_H
+//--------------------------------------------------------------------------//
+#include <stddef.h>
+//--------------------------------------------------------------------------//
+void* allocmem(size_t);
+void freemem(void*);
+void freeall();
+//--------------------------------------------------------------------------//
+#define strdup(s) managed_strdup(s)
+char *strdup(const char *s1);
+//--------------------------------------------------------------------------//
+extern unsigned int debugging;
+//--------------------------------------------------------------------------//
+#endif

src/ntop.c

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2016 - Carsten Larsen
+ * Copyright (c) 1999 - 2001 Kungliga Tekniska Högskolan
+ * (Royal Institute of Technology, Stockholm, Sweden).
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $Heimdal: inet_ntop.c 21005 2007-06-08 01:54:35Z lha $
+ * $NetBSD: inet_ntop.c,v 1.2 2008/03/22 08:37:21 mlelstv Exp $
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+#ifndef INET_ADDRSTRLEN
+# define INET_ADDRSTRLEN 16
+#endif
+
+static const char *
+inet_ntop_v4 (const void *src, char *dst, size_t size)
+{
+    const char digits[] = "0123456789";
+    int i;
+    struct in_addr *addr = (struct in_addr *)src;
+    u_long a = ntohl(addr->s_addr);
+    const char *orig_dst = dst;
+
+    if (size < INET_ADDRSTRLEN) {
+        errno = ENOSPC;
+        return NULL;
+    }
+    for (i = 0; i < 4; ++i) {
+        int n = (a >> (24 - i * 8)) & 0xFF;
+        int non_zerop = 0;
+
+        if (non_zerop || n / 100 > 0) {
+            *dst++ = digits[n / 100];
+            n %= 100;
+            non_zerop = 1;
+        }
+        if (non_zerop || n / 10 > 0) {
+            *dst++ = digits[n / 10];
+            n %= 10;
+            non_zerop = 1;
+        }
+        *dst++ = digits[n];
+        if (i != 3)
+            *dst++ = '.';
+    }
+    *dst++ = '\0';
+    return orig_dst;
+}
+
+#ifdef IPV6
+static const char *
+inet_ntop_v6 (const void *src, char *dst, size_t size)
+{
+    const char xdigits[] = "0123456789abcdef";
+    int i;
+    const struct in6_addr *addr = (struct in6_addr *)src;
+    const u_char *ptr = addr->s6_addr;
+    const char *orig_dst = dst;
+
+    if (size < INET6_ADDRSTRLEN) {
+        errno = ENOSPC;
+        return NULL;
+    }
+    for (i = 0; i < 8; ++i) {
+        int non_zerop = 0;
+
+        if (non_zerop || (ptr[0] >> 4)) {
+            *dst++ = xdigits[ptr[0] >> 4];
+            non_zerop = 1;
+        }
+        if (non_zerop || (ptr[0] & 0x0F)) {
+            *dst++ = xdigits[ptr[0] & 0x0F];
+            non_zerop = 1;
+        }
+        if (non_zerop || (ptr[1] >> 4)) {
+            *dst++ = xdigits[ptr[1] >> 4];
+            non_zerop = 1;
+        }
+        *dst++ = xdigits[ptr[1] & 0x0F];
+        if (i != 7)
+            *dst++ = ':';
+        ptr += 2;
+    }
+    *dst++ = '\0';
+    return orig_dst;
+}
+#endif /* IPV6 */
+
+const char *
+inet_ntop(int af, const void *src, char *dst, size_t size)
+{
+    switch (af) {
+    case AF_INET :
+        return inet_ntop_v4 (src, dst, size);
+#ifdef IPV6
+    case AF_INET6 :
+        return inet_ntop_v6 (src, dst, size);
+#endif
+    default :
+        errno = EAFNOSUPPORT;
+        return NULL;
+    }
+}

src/options.h

@@ -1,20 +1,20 @@
 
-/* 
- *  Interval is the minimum amount of time between sending a ping packet to 
+/*
+ *  Interval is the minimum amount of time between sending a ping packet to
  *  any host.
- * 
- *  Perhost_interval is the minimum amount of time between sending a ping 
+ *
+ *  Perhost_interval is the minimum amount of time between sending a ping
  *  packet to a particular responding host (when count is > 1)
- * 
+ *
  *  Timeout  is the initial amount of time between sending a ping packet to
  *  a particular non-responding host.
- * 
+ *
  *  Retry is the number of ping packets to send to a non-responding host
  *  before giving up (in is-it-alive mode).
- * 
+ *
  *  Backoff factor is how much longer to wait on successive retries.
- * 
- * 
+ *
+ *
  */
 
 /* constants */
@@ -32,7 +32,7 @@
 #endif
 
 
-#ifndef DEFAULT_RETRY 
+#ifndef DEFAULT_RETRY
 #define DEFAULT_RETRY 3            /* number of times to retry a host */
 #endif
 
@@ -49,6 +49,3 @@
 #ifndef DNS_TIMEOUT
 #define DNS_TIMEOUT 1000         /* time in micro_sec for dns retry */
 #endif
-
-/*  NIS_GROUPS allows input name to be an NIS netgroup name */
-/* #define NIS_GROUPS=1 */

src/pton.c

@@ -0,0 +1,304 @@
+/*
+ * Copyright (c) 2016 by Carsten Larsen
+ * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
+ * Copyright (c) 1996,1999 by Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+ * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * $NetBSD: inet_pton.c,v 1.9 2007/07/23 11:45:52 lukem Exp $
+ * from NetBSD: inet_pton.c,v 1.3 2006/09/26 05:59:18 lukem Exp
+ *
+ */
+
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+#ifndef uint32_t
+# define uint32_t u_int32_t
+#endif
+
+#if !defined(NS_INADDRSZ)
+# define NS_INADDRSZ	4
+#endif
+#if !defined(NS_IN6ADDRSZ)
+# define NS_IN6ADDRSZ	16
+#endif
+#if !defined(NS_INT16SZ)
+# define NS_INT16SZ	2
+#endif
+
+/*
+ * WARNING: Don't even consider trying to compile this on a system where
+ * sizeof(int) < 4.  sizeof(int) > 4 is fine; all the world's not a VAX.
+ */
+
+static int	inet_pton4(const char *src, unsigned char *dst, int pton);
+#ifdef IPV6
+static int	inet_pton6(const char *src, unsigned char *dst);
+#endif /* IPV6 */
+
+/* int
+ * inet_pton(af, src, dst)
+ *	convert from presentation format (which usually means ASCII printable)
+ *	to network format (which is usually some kind of binary format).
+ * return:
+ *	1 if the address was valid for the specified address family
+ *	0 if the address wasn't valid (`dst' is untouched in this case)
+ *	-1 if some other error occurred (`dst' is untouched in this case, too)
+ * author:
+ *	Paul Vixie, 1996.
+ */
+int
+inet_pton(int af, const char *src, void *dst)
+{
+
+    switch (af) {
+    case AF_INET:
+        return (inet_pton4(src, dst, 1));
+#ifdef IPV6
+    case AF_INET6:
+        return (inet_pton6(src, dst));
+#endif /* IPV6 */
+    default:
+        errno = EAFNOSUPPORT;
+        return (-1);
+    }
+    /* NOTREACHED */
+}
+
+/* int
+ * inet_pton4(src, dst, pton)
+ *	when last arg is 0: inet_aton(). with hexadecimal, octal and shorthand.
+ *	when last arg is 1: inet_pton(). decimal dotted-quad only.
+ * return:
+ *	1 if `src' is a valid input, else 0.
+ * notice:
+ *	does not touch `dst' unless it's returning 1.
+ * author:
+ *	Paul Vixie, 1996.
+ */
+static int
+inet_pton4(const char *src, unsigned char *dst, int pton)
+{
+    uint32_t val;
+    unsigned int digit, base;
+    int n;
+    unsigned char c;
+    unsigned int parts[4];
+    register unsigned int *pp = parts;
+
+    c = *src;
+    for (;;) {
+        /*
+         * Collect number up to ``.''.
+         * Values are specified as for C:
+         * 0x=hex, 0=octal, isdigit=decimal.
+         */
+        if (!isdigit(c))
+            return (0);
+        val = 0;
+        base = 10;
+        if (c == '0') {
+            c = *++src;
+            if (c == 'x' || c == 'X')
+                base = 16, c = *++src;
+            else if (isdigit(c) && c != '9')
+                base = 8;
+        }
+        /* inet_pton() takes decimal only */
+        if (pton && base != 10)
+            return (0);
+        for (;;) {
+            if (isdigit(c)) {
+                digit = c - '0';
+                if (digit >= base)
+                    break;
+                val = (val * base) + digit;
+                c = *++src;
+            } else if (base == 16 && isxdigit(c)) {
+                digit = c + 10 - (islower(c) ? 'a' : 'A');
+                if (digit >= 16)
+                    break;
+                val = (val << 4) | digit;
+                c = *++src;
+            } else
+                break;
+        }
+        if (c == '.') {
+            /*
+             * Internet format:
+             *	a.b.c.d
+             *	a.b.c	(with c treated as 16 bits)
+             *	a.b	(with b treated as 24 bits)
+             *	a	(with a treated as 32 bits)
+             */
+            if (pp >= parts + 3)
+                return (0);
+            *pp++ = val;
+            c = *++src;
+        } else
+            break;
+    }
+    /*
+     * Check for trailing characters.
+     */
+    if (c != '\0' && !isspace(c))
+        return (0);
+    /*
+     * Concoct the address according to
+     * the number of parts specified.
+     */
+    n = pp - parts + 1;
+    /* inet_pton() takes dotted-quad only.  it does not take shorthand. */
+    if (pton && n != 4)
+        return (0);
+    switch (n) {
+
+    case 0:
+        return (0);		/* initial nondigit */
+
+    case 1:				/* a -- 32 bits */
+        break;
+
+    case 2:				/* a.b -- 8.24 bits */
+        if (parts[0] > 0xff || val > 0xffffff)
+            return (0);
+        val |= parts[0] << 24;
+        break;
+
+    case 3:				/* a.b.c -- 8.8.16 bits */
+        if ((parts[0] | parts[1]) > 0xff || val > 0xffff)
+            return (0);
+        val |= (parts[0] << 24) | (parts[1] << 16);
+        break;
+
+    case 4:				/* a.b.c.d -- 8.8.8.8 bits */
+        if ((parts[0] | parts[1] | parts[2] | val) > 0xff)
+            return (0);
+        val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
+        break;
+    }
+    if (dst) {
+        val = htonl(val);
+        memcpy(dst, &val, NS_INADDRSZ);
+    }
+    return (1);
+}
+
+#ifdef IPV6
+/* int
+ * inet_pton6(src, dst)
+ *	convert presentation level address to network order binary form.
+ * return:
+ *	1 if `src' is a valid [RFC1884 2.2] address, else 0.
+ * notice:
+ *	(1) does not touch `dst' unless it's returning 1.
+ *	(2) :: in a full address is silently ignored.
+ * credit:
+ *	inspired by Mark Andrews.
+ * author:
+ *	Paul Vixie, 1996.
+ */
+static int
+inet_pton6(const char *src, unsigned char *dst)
+{
+    static const char xdigits_l[] = "0123456789abcdef",
+                                    xdigits_u[] = "0123456789ABCDEF";
+    unsigned char tmp[NS_IN6ADDRSZ], *tp, *endp, *colonp;
+    const char *xdigits, *curtok;
+    int ch, saw_xdigit;
+    unsigned int val;
+
+    memset((tp = tmp), '\0', NS_IN6ADDRSZ);
+    endp = tp + NS_IN6ADDRSZ;
+    colonp = NULL;
+    /* Leading :: requires some special handling. */
+    if (*src == ':')
+        if (*++src != ':')
+            return (0);
+    curtok = src;
+    saw_xdigit = 0;
+    val = 0;
+    while ((ch = *src++) != '\0') {
+        const char *pch;
+
+        if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL)
+            pch = strchr((xdigits = xdigits_u), ch);
+        if (pch != NULL) {
+            val <<= 4;
+            val |= (pch - xdigits);
+            if (val > 0xffff)
+                return (0);
+            saw_xdigit = 1;
+            continue;
+        }
+        if (ch == ':') {
+            curtok = src;
+            if (!saw_xdigit) {
+                if (colonp)
+                    return (0);
+                colonp = tp;
+                continue;
+            } else if (*src == '\0')
+                return (0);
+            if (tp + NS_INT16SZ > endp)
+                return (0);
+            *tp++ = (unsigned char) (val >> 8) & 0xff;
+            *tp++ = (unsigned char) val & 0xff;
+            saw_xdigit = 0;
+            val = 0;
+            continue;
+        }
+        if (ch == '.' && ((tp + NS_INADDRSZ) <= endp) &&
+                inet_pton4(curtok, tp, 1) > 0) {
+            tp += NS_INADDRSZ;
+            saw_xdigit = 0;
+            break;	/* '\0' was seen by inet_pton4(). */
+        }
+        return (0);
+    }
+    if (saw_xdigit) {
+        if (tp + NS_INT16SZ > endp)
+            return (0);
+        *tp++ = (unsigned char) (val >> 8) & 0xff;
+        *tp++ = (unsigned char) val & 0xff;
+    }
+    if (colonp != NULL) {
+        /*
+         * Since some memmove()'s erroneously fail to handle
+         * overlapping regions, we'll do the shift by hand.
+         */
+        const int n = tp - colonp;
+        int i;
+
+        if (tp == endp)
+            return (0);
+        for (i = 1; i <= n; i++) {
+            endp[- i] = colonp[n - i];
+            colonp[n - i] = 0;
+        }
+        tp = endp;
+    }
+    if (tp != endp)
+        return (0);
+    memcpy(dst, tmp, NS_IN6ADDRSZ);
+    return (1);
+}
+#endif /* IPV6 */

src/rand.c

@@ -0,0 +1,61 @@
+/*	$NetBSD: rand.c,v 1.12 2012/06/25 22:32:45 abs Exp $	*/
+
+/*-
+ * Copyright (c) 1990, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+#if defined(LIBC_SCCS) && !defined(lint)
+#if 1
+static char sccsid[] = "@(#)rand.c	8.1 (Berkeley) 6/14/93";
+#else
+__RCSID("$NetBSD: rand.c,v 1.12 2012/06/25 22:32:45 abs Exp $");
+#endif
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/types.h>
+#include <stdlib.h>
+
+#ifndef RAND_MAX
+#define	RAND_MAX 2147483647
+#endif
+
+static u_long next = 1;
+
+int
+rand(void)
+{
+    /* LINTED integer overflow */
+    return (int)((next = next * 1103515245 + 12345) % ((u_long)RAND_MAX + 1));
+}
+
+void
+srand(u_int seed)
+{
+    next = seed;
+}

src/seqmap.c

@@ -0,0 +1,116 @@
+/*
+ * fping: fast-ping, file-ping, favorite-ping, funky-ping
+ *
+ *   Ping a list of target hosts in a round robin fashion.
+ *   A better ping overall.
+ *
+ * fping website:  http://www.fping.org
+ *
+ * Current maintainer of fping: David Schweikert
+ * Please send suggestions and patches to: david@schweikert.ch
+ *
+ *
+ * Original author:  Roland Schemers  <schemers@stanford.edu>
+ * IPv6 Support:     Jeroen Massar    <jeroen@unfix.org / jeroen@ipng.nl>
+ * Improved main loop: David Schweikert <david@schweikert.ch>
+ * Debian Merge, TOS settings: Tobi Oetiker <tobi@oetiker.ch>
+ * Bugfixes, byte order & senseful seq.-numbers: Stephan Fuhrmann (stephan.fuhrmann AT 1und1.de)
+ *
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by Stanford University.  The name of the University may not be used
+ * to endorse or promote products derived from this software without
+ * specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * seqmap.c: implementation of a mapping between sequence number and (host, ping_nr)
+ *           we can't just use ping_nr*host_count + host_nr, because it can
+ *           overflow the 16 bit of the icmp header field. See also:
+ *           https://github.com/schweikert/fping/issues/48
+ */
+
+#include "seqmap.h"
+#include "options.h"
+#include <limits.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+/* description of the data structure used:
+ *
+ * - we assume that no more than SEQMAP_MAXSEQ (65535) pings are sent in
+ *   the timeout interval (SEQMAP_TIMEOUT_IN_S)
+ * - we store the values in an array with SEQMAP_MAXSEQ elements
+ * - current sequence number % SEQMAP_MAXSEQ gives the current index
+ * - when entering a value, we check that the current entry is expired
+ */
+
+static SEQMAP_VALUE *seqmap_map = NULL;
+static unsigned int seqmap_next_id = 0;
+
+#define SEQMAP_TIMEOUT_IN_S       10
+#define SEQMAP_UNASSIGNED_HOST_NR UINT_MAX
+
+void seqmap_init()
+{
+    seqmap_map = calloc(SEQMAP_MAXSEQ, sizeof(SEQMAP_VALUE));
+    if(seqmap_map == NULL) {
+        perror("malloc error (can't allocate seqmap_map)");
+    }
+}
+
+unsigned int seqmap_add(unsigned int host_nr, unsigned int ping_count, struct timeval *now)
+{
+    unsigned int current_id;
+    SEQMAP_VALUE *next_value;
+
+    if(!seqmap_map) {
+        fprintf(stderr, "fping internal error: seqmap not initialized.\n");
+        exit(4);
+    }
+
+    /* check if expired (note that unused seqmap values will have fields set to
+     * 0, so will be seen as expired */
+    next_value = &seqmap_map[seqmap_next_id];
+    if(next_value->ping_ts.tv_sec != 0 && (now->tv_sec - next_value->ping_ts.tv_sec) < SEQMAP_TIMEOUT_IN_S) {
+        fprintf(stderr, "fping error: not enough sequence numbers available! (expire_timeout=%d, host_nr=%d, ping_count=%d, seqmap_next_id=%d)\n",
+                SEQMAP_TIMEOUT_IN_S, host_nr, ping_count, seqmap_next_id);
+        exit(4);
+    }
+
+    /* store the value */
+    next_value->host_nr = host_nr;
+    next_value->ping_count = ping_count;
+    next_value->ping_ts.tv_sec = now->tv_sec;
+    next_value->ping_ts.tv_usec = now->tv_usec;
+
+    /* increase next id */
+    current_id = seqmap_next_id;
+    seqmap_next_id = (seqmap_next_id + 1) % SEQMAP_MAXSEQ;
+
+    return current_id;
+}
+
+SEQMAP_VALUE *seqmap_fetch(unsigned int id, struct timeval *now)
+{
+    SEQMAP_VALUE *value;
+
+    if(id > SEQMAP_MAXSEQ) {
+        return NULL;
+    }
+
+    value = &seqmap_map[id];
+
+    /* verify that value is not expired */
+    if(now->tv_sec - value->ping_ts.tv_sec >= SEQMAP_TIMEOUT_IN_S) {
+        return NULL;
+    }
+
+    return value;
+}

src/seqmap.h

@@ -0,0 +1,20 @@
+#ifndef SEQMAP_H
+#define SEQMAP_H
+
+#include <sys/time.h>
+
+typedef struct seqmap_value
+{
+    unsigned int    host_nr;
+    unsigned int    ping_count;
+    struct timeval  ping_ts;
+
+} SEQMAP_VALUE;
+
+#define SEQMAP_MAXSEQ 65535
+
+void seqmap_init();
+unsigned int seqmap_add(unsigned int host_nr, unsigned int ping_count, struct timeval *now);
+SEQMAP_VALUE *seqmap_fetch(unsigned int id, struct timeval *now);
+
+#endif

src/socket.c

@@ -0,0 +1,94 @@
+/*
+ * fping: fast-ping, file-ping, favorite-ping, funky-ping
+ *
+ *   Ping a list of target hosts in a round robin fashion.
+ *   A better ping overall.
+ *
+ * fping website:  http://www.fping.org
+ *
+ * Current maintainer of fping: David Schweikert
+ * Please send suggestions and patches to: david@schweikert.ch
+ *
+ *
+ * Original author:  Roland Schemers  <schemers@stanford.edu>
+ * IPv6 Support:     Jeroen Massar    <jeroen@unfix.org / jeroen@ipng.nl>
+ * Improved main loop: David Schweikert <david@schweikert.ch>
+ * Debian Merge, TOS settings: Tobi Oetiker <tobi@oetiker.ch>
+ * Bugfixes, byte order & senseful seq.-numbers: Stephan Fuhrmann (stephan.fuhrmann AT 1und1.de)
+ *
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by Stanford University.  The name of the University may not be used
+ * to endorse or promote products derived from this software without
+ * specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include "fping.h"
+
+int open_ping_socket_ipv4();
+int open_ping_socket_ipv6();
+void init_ping_buffer_ipv4(size_t ping_data_size);
+void init_ping_buffer_ipv6(size_t ping_data_size);
+void socket_set_src_addr_ipv4(int s, FPING_INADDR src_addr);
+void socket_set_src_addr_ipv6(int s, FPING_INADDR src_addr);
+int socket_sendto_ping_ipv4(int s, struct sockaddr *saddr, socklen_t saddr_len, uint16_t icmp_seq_nr, uint16_t icmp_id_nr);
+int socket_sendto_ping_ipv6(int s, struct sockaddr *saddr, socklen_t saddr_len, uint16_t icmp_seq_nr, uint16_t icmp_id_nr);
+void close_ping_socket_ipv4();
+void cleanup_ping_buffer_ipv4();
+
+int open_ping_socket()
+{
+#ifndef IPV6
+    return open_ping_socket_ipv4();
+#else
+    return open_ping_socket_ipv6();
+#endif
+}
+
+void init_ping_buffer(size_t ping_data_size)
+{
+#ifndef IPV6
+    return init_ping_buffer_ipv4(ping_data_size);
+#else
+    return init_ping_buffer_ipv6(ping_data_size);
+#endif
+}
+
+void socket_set_src_addr(int s, FPING_INADDR src_addr)
+{
+#ifndef IPV6
+    socket_set_src_addr_ipv4(s, src_addr);
+#else
+    socket_set_src_addr_ipv6(s, src_addr);
+#endif
+}
+
+int socket_sendto_ping(int s, struct sockaddr *saddr, socklen_t saddr_len, uint16_t icmp_seq_nr, uint16_t icmp_id_nr)
+{
+#ifndef IPV6
+    return socket_sendto_ping_ipv4(s, saddr, saddr_len, icmp_seq_nr, icmp_id_nr);
+#else
+    return socket_sendto_ping_ipv6(s, saddr, saddr_len, icmp_seq_nr, icmp_id_nr);
+#endif
+}
+
+void close_ping_socket()
+{
+#ifndef IPV6
+    close_ping_socket_ipv4();
+#endif
+}
+
+void cleanup_ping_buffer()
+{
+#ifndef IPV6
+    cleanup_ping_buffer_ipv4();
+#endif
+}

src/socket4.c

@@ -0,0 +1,144 @@
+/*
+ * fping: fast-ping, file-ping, favorite-ping, funky-ping
+ *
+ *   Ping a list of target hosts in a round robin fashion.
+ *   A better ping overall.
+ *
+ * fping website:  http://www.fping.org
+ *
+ * Current maintainer of fping: David Schweikert
+ * Please send suggestions and patches to: david@schweikert.ch
+ *
+ *
+ * Original author:  Roland Schemers  <schemers@stanford.edu>
+ * IPv6 Support:     Jeroen Massar    <jeroen@unfix.org / jeroen@ipng.nl>
+ * Improved main loop: David Schweikert <david@schweikert.ch>
+ * Debian Merge, TOS settings: Tobi Oetiker <tobi@oetiker.ch>
+ * Bugfixes, byte order & senseful seq.-numbers: Stephan Fuhrmann (stephan.fuhrmann AT 1und1.de)
+ *
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by Stanford University.  The name of the University may not be used
+ * to endorse or promote products derived from this software without
+ * specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include "fping.h"
+
+#include <sys/socket.h>
+#include <netinet/in_systm.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/ip_icmp.h>
+#include <netdb.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+char *ping_buffer = 0;
+size_t ping_pkt_size;
+int s = -1;
+
+int open_ping_socket_ipv4()
+{
+    struct protoent *proto;
+
+    /* confirm that ICMP is available on this machine */
+    if( ( proto = getprotobyname( "icmp" ) ) == NULL )
+        crash_and_burn( "icmp: unknown protocol" );
+
+    /* create raw socket for ICMP calls (ping) */
+    s = Socket( AF_INET, SOCK_RAW, proto->p_proto );
+    if( s < 0 ) {
+        /* try non-privileged icmp (works on Mac OSX without privileges, for example) */
+        s = Socket( AF_INET, SOCK_DGRAM, proto->p_proto );
+        if( s < 0 ) {
+            errno_crash_and_burn( "can't create socket (must run as root?)" );
+        }
+    }
+
+    return s;
+}
+
+void init_ping_buffer_ipv4(size_t ping_data_size)
+{
+    /* allocate ping buffer */
+    ping_pkt_size = ping_data_size + ICMP_MINLEN;
+    ping_buffer = (char *) calloc(1, ping_pkt_size);
+    if(!ping_buffer)
+        crash_and_burn( "can't malloc ping packet" );
+}
+
+void socket_set_src_addr_ipv4(int s, FPING_INADDR src_addr)
+{
+    struct sockaddr_in sa;
+    memset( &sa, 0, sizeof( sa ) );
+    sa.sin_family = AF_INET;
+    sa.sin_addr = src_addr;
+
+    if ( Bind( s, (struct sockaddr *)&sa, sizeof( sa ) ) < 0 )
+        errno_crash_and_burn( "cannot bind source address" );
+}
+
+unsigned short calcsum(unsigned short *buffer, int length)
+{
+    unsigned long sum;
+
+    // initialize sum to zero and loop until length (in words) is 0
+    for (sum=0; length>1; length-=2) // sizeof() returns number of bytes, we're interested in number of words
+        sum += *buffer++;	// add 1 word of buffer to sum and proceed to the next
+
+    // we may have an extra byte
+    if (length==1)
+        sum += (char)*buffer;
+
+    sum = (sum >> 16) + (sum & 0xFFFF); // add high 16 to low 16
+    sum += (sum >> 16);			// add carry
+    return ~sum;
+}
+
+int socket_sendto_ping_ipv4(int s, struct sockaddr *saddr, socklen_t saddr_len, uint16_t icmp_seq_nr, uint16_t icmp_id_nr)
+{
+    struct icmp *icp;
+    int n;
+
+    icp = (struct icmp *) ping_buffer;
+
+    icp->icmp_type = ICMP_ECHO;
+    icp->icmp_code = 0;
+    icp->icmp_cksum = 0;
+    icp->icmp_seq = htons(icmp_seq_nr);
+    icp->icmp_id = htons(icmp_id_nr);
+
+    if (random_data_flag) {
+        for (n = ((void*)&icp->icmp_data - (void *)icp); n < ping_pkt_size; ++n) {
+            ping_buffer[n] = random() & 0xFF;
+        }
+    }
+
+    icp->icmp_cksum = calcsum((unsigned short *) icp, ping_pkt_size);
+
+    n = SendTo(s, (void*)icp, ping_pkt_size, 0, saddr, saddr_len);
+
+    return n;
+}
+
+void close_ping_socket_ipv4()
+{
+    if(s > 0)
+        CloseSocket(s);
+}
+
+void cleanup_ping_buffer_ipv4()
+{
+    if (ping_buffer != 0) {
+        free(ping_buffer);
+    }
+}

src/socket6.c

@@ -0,0 +1,111 @@
+/*
+ * fping: fast-ping, file-ping, favorite-ping, funky-ping
+ *
+ *   Ping a list of target hosts in a round robin fashion.
+ *   A better ping overall.
+ *
+ * fping website:  http://www.fping.org
+ *
+ * Current maintainer of fping: David Schweikert
+ * Please send suggestions and patches to: david@schweikert.ch
+ *
+ *
+ * Original author:  Roland Schemers  <schemers@stanford.edu>
+ * IPv6 Support:     Jeroen Massar    <jeroen@unfix.org / jeroen@ipng.nl>
+ * Improved main loop: David Schweikert <david@schweikert.ch>
+ * Debian Merge, TOS settings: Tobi Oetiker <tobi@oetiker.ch>
+ * Bugfixes, byte order & senseful seq.-numbers: Stephan Fuhrmann (stephan.fuhrmann AT 1und1.de)
+ *
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by Stanford University.  The name of the University may not be used
+ * to endorse or promote products derived from this software without
+ * specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include "fping.h"
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <netinet/icmp6.h>  
+
+char *ping_buffer = 0;
+size_t ping_pkt_size;
+
+int open_ping_socket_ipv6()
+{
+    struct protoent *proto;
+    int s;
+
+    /* confirm that ICMP is available on this machine */
+    if( ( proto = getprotobyname( "ipv6-icmp" ) ) == NULL )
+        crash_and_burn( "icmp: unknown protocol" );
+
+    /* create raw socket for ICMP calls (ping) */
+    s = socket( AF_INET6, SOCK_RAW, proto->p_proto );
+    if( s < 0 ) {
+        /* try non-privileged icmp (works on Mac OSX without privileges, for example) */
+        s = socket( AF_INET6, SOCK_DGRAM, proto->p_proto );
+        if( s < 0 ) {
+            errno_crash_and_burn( "can't create raw socket (must run as root?)" );
+        }
+    }
+
+    return s;
+}
+
+void init_ping_buffer_ipv6(size_t ping_data_size)
+{
+    /* allocate ping buffer */
+    ping_pkt_size = ping_data_size + sizeof(struct icmp6_hdr);
+    ping_buffer = (char *) calloc(1, ping_pkt_size);
+    if(!ping_buffer)
+        crash_and_burn( "can't malloc ping packet" );
+}
+
+void socket_set_src_addr_ipv6(int s, FPING_INADDR src_addr)
+{
+    struct sockaddr_in6 sa;
+    memset( &sa, 0, sizeof( sa ) );
+    sa.sin6_family = AF_INET6;
+    sa.sin6_addr = src_addr;
+
+    if ( bind( s, (struct sockaddr *)&sa, sizeof( sa ) ) < 0 )
+        errno_crash_and_burn( "cannot bind source address" );
+}
+
+int socket_sendto_ping_ipv6(int s, struct sockaddr *saddr, socklen_t saddr_len, uint16_t icmp_seq_nr, uint16_t icmp_id_nr)
+{
+    struct icmp6_hdr *icp;
+    int n;
+
+    icp = (struct icmp6_hdr *) ping_buffer;
+    icp->icmp6_type  = ICMP6_ECHO_REQUEST;
+    icp->icmp6_code  = 0;
+    icp->icmp6_seq   = htons(icmp_seq_nr);
+    icp->icmp6_id    = htons(icmp_id_nr);
+
+    if (random_data_flag) {
+        for (n = sizeof(struct icmp6_hdr); n < ping_pkt_size; ++n) {
+            ping_buffer[n] = random() & 0xFF;
+        }
+    }
+
+    icp->icmp6_cksum = 0;   // The IPv6 stack calculates the checksum for us...
+
+    n = sendto(s, icp, ping_pkt_size, 0, saddr, saddr_len);
+
+    return n;
+}