*** ./src/iperf_api.c.ORIG	Mon May 23 18:45:38 2016
--- ./src/iperf_api.c	Mon May 23 18:47:42 2016
@@ -35,7 +35,11 @@
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
+#ifdef _AIX
+#include "getopt_long.h"
+#else
 #include <getopt.h>
+#endif
 #include <errno.h>
 #include <signal.h>
 #include <unistd.h>

*** ./src/net.c.ORIG	Mon May 23 18:51:38 2016
--- ./src/net.c	Mon May 23 18:51:57 2016
@@ -36,7 +36,11 @@
 #include <assert.h>
 #include <netdb.h>
 #include <string.h>
+#ifdef _AIX
 #include <fcntl.h>
+#else
+#include <sys/fcntl.h>
+#endif
 #include <limits.h>

 #ifdef HAVE_SENDFILE

*** ./src/iperf_server_api.c.ORIG	Mon May 23 18:47:51 2016
--- ./src/iperf_server_api.c	Mon May 23 18:48:09 2016
***************
*** 30,36 ****
--- 30,40 ----
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
+ #ifdef _AIX
+ #include "getopt_long.h"
+ #else
  #include <getopt.h>
+ #endif
  #include <errno.h>
  #include <unistd.h>
  #include <assert.h>
*** ./src/main.c.ORIG	Mon May 23 18:52:24 2016
--- ./src/main.c	Mon May 23 18:55:28 2016
***************
*** 29,35 ****
--- 29,40 ----
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
+ #ifdef _AIX
+ #include "getopt_long.h"
+ #include "getopt_long.c"
+ #else
  #include <getopt.h>
+ #endif
  #include <errno.h>
  #include <signal.h>
  #include <unistd.h>
*** ./src/getopt_long.c.ORIG	Mon May 23 18:53:37 2016
--- ./src/getopt_long.c	Mon May 23 18:46:10 2016
***************
*** 0 ****
--- 1,1237 ----
+ /*
+  * THIS IS NOT A CLEAN COPY OF GETOPT.C AND GETOPT1.C 
+  * -- that is, do not use it in other projects.
+  *
+  * Implementation of getopt_long, cobbled together from getopt.c and
+  * getopt1.c from the GNU binutils distribution.  This is more-or-less
+  * getopt.c inserted into getopt1.c, with the definition of getopt()
+  * commented out.
+  *
+  * Need to ifdef out optarg, optind, opterr, optopt, to handle the
+  * case where these are already defined for the benefit of system
+  * getopt()
+  *
+  * No, it's not pretty.
+  */
+ 
+ /* getopt_long and getopt_long_only entry points for GNU getopt.
+    Copyright (C) 1987,88,89,90,91,92,93,94,96,97,98
+      Free Software Foundation, Inc.
+ 
+    NOTE: This source is derived from an old version taken from the GNU C
+    Library (glibc).
+ 
+    This program is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2, or (at your option) any
+    later version.
+ 
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+ 
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+    USA.  */
+ 
+ //#include <config.h>
+ 
+ #ifndef HAVE_GETOPT_LONG
+ /* We shouldn't be compiling this module in this case, but we clearly
+    are (damned configuration tools!), so avoid messing up. */
+ 
+ #include "getopt_long.h"
+ /* See getopt_long.h for discussion of THIS_IS__STDC__ */
+ 
+ 
+ #if !defined THIS_IS__STDC__ || !THIS_IS__STDC__
+ /* This is a separate conditional since some stdc systems
+    reject `defined (const)'.  */
+ #ifndef const
+ #define const
+ #endif
+ #endif
+ 
+ #include <stdio.h>
+ 
+ 
+ 
+ /* ******************** getopt.c ******************** */
+ /* Getopt for GNU.
+    NOTE: getopt is now part of the C library, so if you don't know what
+    "Keep this file name-space clean" means, talk to drepper@gnu.org
+    before changing it!
+ 
+    Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98
+    	Free Software Foundation, Inc.
+ 
+    NOTE: This source is derived from an old version taken from the GNU C
+    Library (glibc).
+ 
+    This program is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2, or (at your option) any
+    later version.
+ 
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+ 
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+    USA.  */
+ 
+ /* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
+    Ditto for AIX 3.2 and <stdlib.h>.  */
+ #ifndef _NO_PROTO
+ # define _NO_PROTO
+ #endif
+ 
+ 
+ #if !defined THIS_IS__STDC__ || !THIS_IS__STDC__
+ /* This is a separate conditional since some stdc systems
+    reject `defined (const)'.  */
+ # ifndef const
+ #  define const
+ # endif
+ #endif
+ 
+ #include <stdio.h>
+ 
+ /* Comment out all this code if we are using the GNU C Library, and are not
+    actually compiling the library itself.  This code is part of the GNU C
+    Library, but also included in many other GNU distributions.  Compiling
+    and linking in this code is a waste when using the GNU C library
+    (especially if it is a shared library).  Rather than having every GNU
+    program understand `configure --with-gnu-libc' and omit the object files,
+    it is simpler to just do this in the source for each such file.  */
+ 
+ #define GETOPT_INTERFACE_VERSION 2
+ #if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
+ # include <gnu-versions.h>
+ # if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
+ #  define ELIDE_CODE
+ # endif
+ #endif
+ 
+ #ifndef ELIDE_CODE
+ 
+ 
+ /* This needs to come after some library #include
+    to get __GNU_LIBRARY__ defined.  */
+ #ifdef	__GNU_LIBRARY__
+ /* Don't include stdlib.h for non-GNU C libraries because some of them
+    contain conflicting prototypes for getopt.  */
+ # include <stdlib.h>
+ # include <unistd.h>
+ #endif	/* GNU C library.  */
+ 
+ #ifdef VMS
+ # include <unixlib.h>
+ # if HAVE_STRING_H - 0
+ #  include <string.h>
+ # endif
+ #endif
+ 
+ #ifndef _
+ /* This is for other GNU distributions with internationalized messages.
+    When compiling libc, the _ macro is predefined.  */
+ # ifdef HAVE_LIBINTL_H
+ #  include <libintl.h>
+ #  define _(msgid)	gettext (msgid)
+ # else
+ #  define _(msgid)	(msgid)
+ # endif
+ #endif
+ 
+ /* This version of `getopt' appears to the caller like standard Unix `getopt'
+    but it behaves differently for the user, since it allows the user
+    to intersperse the options with the other arguments.
+ 
+    As `getopt' works, it permutes the elements of ARGV so that,
+    when it is done, all the options precede everything else.  Thus
+    all application programs are extended to handle flexible argument order.
+ 
+    Setting the environment variable POSIXLY_CORRECT disables permutation.
+    Then the behavior is completely standard.
+ 
+    GNU application programs can use a third alternative mode in which
+    they can distinguish the relative order of options and other arguments.  */
+ 
+ 
+ 
+ /* Define HAVE_GETOPT if the getopt function (and thus, which is more
+  * important to us, the getopt globals, optarg, optind, opterr and
+  * optopt) is defined by the system.  Leave undefined if they should be
+  * defined here instead.
+  */
+ #ifndef HAVE_GETOPT
+ 
+ /* For communication from `getopt' to the caller.
+    When `getopt' finds an option that takes an argument,
+    the argument value is returned here.
+    Also, when `ordering' is RETURN_IN_ORDER,
+    each non-option ARGV-element is returned here.  */
+ 
+ char *optarg = NULL;
+ 
+ /* Index in ARGV of the next element to be scanned.
+    This is used for communication to and from the caller
+    and for communication between successive calls to `getopt'.
+ 
+    On entry to `getopt', zero means this is the first call; initialize.
+ 
+    When `getopt' returns -1, this is the index of the first of the
+    non-option elements that the caller should itself scan.
+ 
+    Otherwise, `optind' communicates from one call to the next
+    how much of ARGV has been scanned so far.  */
+ 
+ /* 1003.2 says this must be 1 before any call.  */
+ int optind = 1;
+ 
+ /* Callers store zero here to inhibit the error message
+    for unrecognized options.  */
+ 
+ int opterr = 1;
+ 
+ /* Set to an option character which was unrecognized.
+    This must be initialized on some systems to avoid linking in the
+    system's own getopt implementation.  */
+ 
+ int optopt = '?';
+ 
+ #endif /* #ifndef HAVE_GETOPT */
+ 
+ /* Formerly, initialization of getopt depended on optind==0, which
+    causes problems with re-calling getopt as programs generally don't
+    know that. */
+ 
+ int __getopt_initialized = 0;
+ 
+ /* The next char to be scanned in the option-element
+    in which the last option character we returned was found.
+    This allows us to pick up the scan where we left off.
+ 
+    If this is zero, or a null string, it means resume the scan
+    by advancing to the next ARGV-element.  */
+ 
+ static char *nextchar;
+ 
+ /* Describe how to deal with options that follow non-option ARGV-elements.
+ 
+    If the caller did not specify anything,
+    the default is REQUIRE_ORDER if the environment variable
+    POSIXLY_CORRECT is defined, PERMUTE otherwise.
+ 
+    REQUIRE_ORDER means don't recognize them as options;
+    stop option processing when the first non-option is seen.
+    This is what Unix does.
+    This mode of operation is selected by either setting the environment
+    variable POSIXLY_CORRECT, or using `+' as the first character
+    of the list of option characters.
+ 
+    PERMUTE is the default.  We permute the contents of ARGV as we scan,
+    so that eventually all the non-options are at the end.  This allows options
+    to be given in any order, even with programs that were not written to
+    expect this.
+ 
+    RETURN_IN_ORDER is an option available to programs that were written
+    to expect options and other ARGV-elements in any order and that care about
+    the ordering of the two.  We describe each non-option ARGV-element
+    as if it were the argument of an option with character code 1.
+    Using `-' as the first character of the list of option characters
+    selects this mode of operation.
+ 
+    The special argument `--' forces an end of option-scanning regardless
+    of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
+    `--' can cause `getopt' to return -1 with `optind' != ARGC.  */
+ 
+ static enum
+ {
+   REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
+ } ordering;
+ 
+ /* Value of POSIXLY_CORRECT environment variable.  */
+ static char *posixly_correct;
+ 
+ #ifdef	__GNU_LIBRARY__
+ /* We want to avoid inclusion of string.h with non-GNU libraries
+    because there are many ways it can cause trouble.
+    On some systems, it contains special magic macros that don't work
+    in GCC.  */
+ # include <string.h>
+ # define my_index	strchr
+ #else
+ 
+ # if HAVE_STRING_H
+ #  include <string.h>
+ # else
+ #  if HAVE_STRINGS_H
+ #   include <strings.h>
+ #  endif
+ # endif
+ 
+ /* Avoid depending on library functions or files
+    whose names are inconsistent.  */
+ 
+ #ifndef getenv
+ extern char *getenv ();
+ #endif
+ 
+ static char *
+ my_index (str, chr)
+      const char *str;
+      int chr;
+ {
+   while (*str)
+     {
+       if (*str == chr)
+ 	return (char *) str;
+       str++;
+     }
+   return 0;
+ }
+ 
+ /* If using GCC, we can safely declare strlen this way.
+    If not using GCC, it is ok not to declare it.  */
+ #ifdef __GNUC__
+ /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
+    That was relevant to code that was here before.  */
+ # if (!defined THIS_IS__STDC__ || !THIS_IS__STDC__) && !defined strlen
+ /* gcc with -traditional declares the built-in strlen to return int,
+    and has done so at least since version 2.4.5. -- rms.  */
+ extern int strlen (const char *);
+ # endif /* not THIS_IS__STDC__ */
+ #endif /* __GNUC__ */
+ 
+ #endif /* not __GNU_LIBRARY__ */
+ 
+ /* Handle permutation of arguments.  */
+ 
+ /* Describe the part of ARGV that contains non-options that have
+    been skipped.  `first_nonopt' is the index in ARGV of the first of them;
+    `last_nonopt' is the index after the last of them.  */
+ 
+ static int first_nonopt;
+ static int last_nonopt;
+ 
+ #ifdef _LIBC
+ /* Bash 2.0 gives us an environment variable containing flags
+    indicating ARGV elements that should not be considered arguments.  */
+ 
+ /* Defined in getopt_init.c  */
+ extern char *__getopt_nonoption_flags;
+ 
+ static int nonoption_flags_max_len;
+ static int nonoption_flags_len;
+ 
+ static int original_argc;
+ static char *const *original_argv;
+ 
+ /* Make sure the environment variable bash 2.0 puts in the environment
+    is valid for the getopt call we must make sure that the ARGV passed
+    to getopt is that one passed to the process.  */
+ static void
+ __attribute__ ((unused))
+ store_args_and_env (int argc, char *const *argv)
+ {
+   /* XXX This is no good solution.  We should rather copy the args so
+      that we can compare them later.  But we must not use malloc(3).  */
+   original_argc = argc;
+   original_argv = argv;
+ }
+ # ifdef text_set_element
+ text_set_element (__libc_subinit, store_args_and_env);
+ # endif /* text_set_element */
+ 
+ # define SWAP_FLAGS(ch1, ch2) \
+   if (nonoption_flags_len > 0)						      \
+     {									      \
+       char __tmp = __getopt_nonoption_flags[ch1];			      \
+       __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];	      \
+       __getopt_nonoption_flags[ch2] = __tmp;				      \
+     }
+ #else	/* !_LIBC */
+ # define SWAP_FLAGS(ch1, ch2)
+ #endif	/* _LIBC */
+ 
+ /* Exchange two adjacent subsequences of ARGV.
+    One subsequence is elements [first_nonopt,last_nonopt)
+    which contains all the non-options that have been skipped so far.
+    The other is elements [last_nonopt,optind), which contains all
+    the options processed since those non-options were skipped.
+ 
+    `first_nonopt' and `last_nonopt' are relocated so that they describe
+    the new indices of the non-options in ARGV after they are moved.  */
+ 
+ #if defined THIS_IS__STDC__ && THIS_IS__STDC__
+ static void exchange (char **);
+ #endif
+ 
+ static void
+ exchange (argv)
+      char **argv;
+ {
+   int bottom = first_nonopt;
+   int middle = last_nonopt;
+   int top = optind;
+   char *tem;
+ 
+   /* Exchange the shorter segment with the far end of the longer segment.
+      That puts the shorter segment into the right place.
+      It leaves the longer segment in the right place overall,
+      but it consists of two parts that need to be swapped next.  */
+ 
+ #ifdef _LIBC
+   /* First make sure the handling of the `__getopt_nonoption_flags'
+      string can work normally.  Our top argument must be in the range
+      of the string.  */
+   if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
+     {
+       /* We must extend the array.  The user plays games with us and
+ 	 presents new arguments.  */
+       char *new_str = malloc (top + 1);
+       if (new_str == NULL)
+ 	nonoption_flags_len = nonoption_flags_max_len = 0;
+       else
+ 	{
+ 	  memset (__mempcpy (new_str, __getopt_nonoption_flags,
+ 			     nonoption_flags_max_len),
+ 		  '\0', top + 1 - nonoption_flags_max_len);
+ 	  nonoption_flags_max_len = top + 1;
+ 	  __getopt_nonoption_flags = new_str;
+ 	}
+     }
+ #endif
+ 
+   while (top > middle && middle > bottom)
+     {
+       if (top - middle > middle - bottom)
+ 	{
+ 	  /* Bottom segment is the short one.  */
+ 	  int len = middle - bottom;
+ 	  register int i;
+ 
+ 	  /* Swap it with the top part of the top segment.  */
+ 	  for (i = 0; i < len; i++)
+ 	    {
+ 	      tem = argv[bottom + i];
+ 	      argv[bottom + i] = argv[top - (middle - bottom) + i];
+ 	      argv[top - (middle - bottom) + i] = tem;
+ 	      SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
+ 	    }
+ 	  /* Exclude the moved bottom segment from further swapping.  */
+ 	  top -= len;
+ 	}
+       else
+ 	{
+ 	  /* Top segment is the short one.  */
+ 	  int len = top - middle;
+ 	  register int i;
+ 
+ 	  /* Swap it with the bottom part of the bottom segment.  */
+ 	  for (i = 0; i < len; i++)
+ 	    {
+ 	      tem = argv[bottom + i];
+ 	      argv[bottom + i] = argv[middle + i];
+ 	      argv[middle + i] = tem;
+ 	      SWAP_FLAGS (bottom + i, middle + i);
+ 	    }
+ 	  /* Exclude the moved top segment from further swapping.  */
+ 	  bottom += len;
+ 	}
+     }
+ 
+   /* Update records for the slots the non-options now occupy.  */
+ 
+   first_nonopt += (optind - last_nonopt);
+   last_nonopt = optind;
+ }
+ 
+ /* Initialize the internal data when the first call is made.  */
+ 
+ #if defined THIS_IS__STDC__ && THIS_IS__STDC__
+ static const char *_getopt_initialize (int, char *const *, const char *);
+ #endif
+ static const char *
+ _getopt_initialize (argc, argv, optstring)
+      int argc;
+      char *const *argv;
+      const char *optstring;
+ {
+   /* Start processing options with ARGV-element 1 (since ARGV-element 0
+      is the program name); the sequence of previously skipped
+      non-option ARGV-elements is empty.  */
+ 
+   first_nonopt = last_nonopt = optind;
+ 
+   nextchar = NULL;
+ 
+   posixly_correct = getenv ("POSIXLY_CORRECT");
+ 
+   /* Determine how to handle the ordering of options and nonoptions.  */
+ 
+   if (optstring[0] == '-')
+     {
+       ordering = RETURN_IN_ORDER;
+       ++optstring;
+     }
+   else if (optstring[0] == '+')
+     {
+       ordering = REQUIRE_ORDER;
+       ++optstring;
+     }
+   else if (posixly_correct != NULL)
+     ordering = REQUIRE_ORDER;
+   else
+     ordering = PERMUTE;
+ 
+ #ifdef _LIBC
+   if (posixly_correct == NULL
+       && argc == original_argc && argv == original_argv)
+     {
+       if (nonoption_flags_max_len == 0)
+ 	{
+ 	  if (__getopt_nonoption_flags == NULL
+ 	      || __getopt_nonoption_flags[0] == '\0')
+ 	    nonoption_flags_max_len = -1;
+ 	  else
+ 	    {
+ 	      const char *orig_str = __getopt_nonoption_flags;
+ 	      int len = nonoption_flags_max_len = strlen (orig_str);
+ 	      if (nonoption_flags_max_len < argc)
+ 		nonoption_flags_max_len = argc;
+ 	      __getopt_nonoption_flags =
+ 		(char *) malloc (nonoption_flags_max_len);
+ 	      if (__getopt_nonoption_flags == NULL)
+ 		nonoption_flags_max_len = -1;
+ 	      else
+ 		memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
+ 			'\0', nonoption_flags_max_len - len);
+ 	    }
+ 	}
+       nonoption_flags_len = nonoption_flags_max_len;
+     }
+   else
+     nonoption_flags_len = 0;
+ #endif
+ 
+   return optstring;
+ }
+ 
+ /* Scan elements of ARGV (whose length is ARGC) for option characters
+    given in OPTSTRING.
+ 
+    If an element of ARGV starts with '-', and is not exactly "-" or "--",
+    then it is an option element.  The characters of this element
+    (aside from the initial '-') are option characters.  If `getopt'
+    is called repeatedly, it returns successively each of the option characters
+    from each of the option elements.
+ 
+    If `getopt' finds another option character, it returns that character,
+    updating `optind' and `nextchar' so that the next call to `getopt' can
+    resume the scan with the following option character or ARGV-element.
+ 
+    If there are no more option characters, `getopt' returns -1.
+    Then `optind' is the index in ARGV of the first ARGV-element
+    that is not an option.  (The ARGV-elements have been permuted
+    so that those that are not options now come last.)
+ 
+    OPTSTRING is a string containing the legitimate option characters.
+    If an option character is seen that is not listed in OPTSTRING,
+    return '?' after printing an error message.  If you set `opterr' to
+    zero, the error message is suppressed but we still return '?'.
+ 
+    If a char in OPTSTRING is followed by a colon, that means it wants an arg,
+    so the following text in the same ARGV-element, or the text of the following
+    ARGV-element, is returned in `optarg'.  Two colons mean an option that
+    wants an optional arg; if there is text in the current ARGV-element,
+    it is returned in `optarg', otherwise `optarg' is set to zero.
+ 
+    If OPTSTRING starts with `-' or `+', it requests different methods of
+    handling the non-option ARGV-elements.
+    See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
+ 
+    Long-named options begin with `--' instead of `-'.
+    Their names may be abbreviated as long as the abbreviation is unique
+    or is an exact match for some defined option.  If they have an
+    argument, it follows the option name in the same ARGV-element, separated
+    from the option name by a `=', or else the in next ARGV-element.
+    When `getopt' finds a long-named option, it returns 0 if that option's
+    `flag' field is nonzero, the value of the option's `val' field
+    if the `flag' field is zero.
+ 
+    The elements of ARGV aren't really const, because we permute them.
+    But we pretend they're const in the prototype to be compatible
+    with other systems.
+ 
+    LONGOPTS is a vector of `struct option' terminated by an
+    element containing a name which is zero.
+ 
+    LONGIND returns the index in LONGOPT of the long-named option found.
+    It is only valid when a long-named option has been found by the most
+    recent call.
+ 
+    If LONG_ONLY is nonzero, '-' as well as '--' can introduce
+    long-named options.  */
+ 
+ #if 0
+ int
+ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
+      int argc;
+      char *const *argv;
+      const char *optstring;
+      const struct option *longopts;
+      int *longind;
+      int long_only;
+ #endif
+ int
+ _getopt_internal (int argc,
+ 	char *const *argv,
+ 	const char *optstring,
+ 	const struct option *longopts,
+ 	int *longind,
+ 	int long_only)
+ {
+   optarg = NULL;
+ 
+   if (optind == 0 || !__getopt_initialized)
+     {
+       if (optind == 0)
+ 	optind = 1;	/* Don't scan ARGV[0], the program name.  */
+       optstring = _getopt_initialize (argc, argv, optstring);
+       __getopt_initialized = 1;
+     }
+ 
+   /* Test whether ARGV[optind] points to a non-option argument.
+      Either it does not have option syntax, or there is an environment flag
+      from the shell indicating it is not an option.  The later information
+      is only used when the used in the GNU libc.  */
+ #ifdef _LIBC
+ # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'	      \
+ 		      || (optind < nonoption_flags_len			      \
+ 			  && __getopt_nonoption_flags[optind] == '1'))
+ #else
+ # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
+ #endif
+ 
+   if (nextchar == NULL || *nextchar == '\0')
+     {
+       /* Advance to the next ARGV-element.  */
+ 
+       /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
+ 	 moved back by the user (who may also have changed the arguments).  */
+       if (last_nonopt > optind)
+ 	last_nonopt = optind;
+       if (first_nonopt > optind)
+ 	first_nonopt = optind;
+ 
+       if (ordering == PERMUTE)
+ 	{
+ 	  /* If we have just processed some options following some non-options,
+ 	     exchange them so that the options come first.  */
+ 
+ 	  if (first_nonopt != last_nonopt && last_nonopt != optind)
+ 	    exchange ((char **) argv);
+ 	  else if (last_nonopt != optind)
+ 	    first_nonopt = optind;
+ 
+ 	  /* Skip any additional non-options
+ 	     and extend the range of non-options previously skipped.  */
+ 
+ 	  while (optind < argc && NONOPTION_P)
+ 	    optind++;
+ 	  last_nonopt = optind;
+ 	}
+ 
+       /* The special ARGV-element `--' means premature end of options.
+ 	 Skip it like a null option,
+ 	 then exchange with previous non-options as if it were an option,
+ 	 then skip everything else like a non-option.  */
+ 
+       if (optind != argc && !strcmp (argv[optind], "--"))
+ 	{
+ 	  optind++;
+ 
+ 	  if (first_nonopt != last_nonopt && last_nonopt != optind)
+ 	    exchange ((char **) argv);
+ 	  else if (first_nonopt == last_nonopt)
+ 	    first_nonopt = optind;
+ 	  last_nonopt = argc;
+ 
+ 	  optind = argc;
+ 	}
+ 
+       /* If we have done all the ARGV-elements, stop the scan
+ 	 and back over any non-options that we skipped and permuted.  */
+ 
+       if (optind == argc)
+ 	{
+ 	  /* Set the next-arg-index to point at the non-options
+ 	     that we previously skipped, so the caller will digest them.  */
+ 	  if (first_nonopt != last_nonopt)
+ 	    optind = first_nonopt;
+ 	  return -1;
+ 	}
+ 
+       /* If we have come to a non-option and did not permute it,
+ 	 either stop the scan or describe it to the caller and pass it by.  */
+ 
+       if (NONOPTION_P)
+ 	{
+ 	  if (ordering == REQUIRE_ORDER)
+ 	    return -1;
+ 	  optarg = argv[optind++];
+ 	  return 1;
+ 	}
+ 
+       /* We have found another option-ARGV-element.
+ 	 Skip the initial punctuation.  */
+ 
+       nextchar = (argv[optind] + 1
+ 		  + (longopts != NULL && argv[optind][1] == '-'));
+     }
+ 
+   /* Decode the current option-ARGV-element.  */
+ 
+   /* Check whether the ARGV-element is a long option.
+ 
+      If long_only and the ARGV-element has the form "-f", where f is
+      a valid short option, don't consider it an abbreviated form of
+      a long option that starts with f.  Otherwise there would be no
+      way to give the -f short option.
+ 
+      On the other hand, if there's a long option "fubar" and
+      the ARGV-element is "-fu", do consider that an abbreviation of
+      the long option, just like "--fu", and not "-f" with arg "u".
+ 
+      This distinction seems to be the most useful approach.  */
+ 
+   if (longopts != NULL
+       && (argv[optind][1] == '-'
+ 	  || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
+     {
+       char *nameend;
+       const struct option *p;
+       const struct option *pfound = NULL;
+       int exact = 0;
+       int ambig = 0;
+       int indfound = -1;
+       int option_index;
+ 
+       for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
+ 	/* Do nothing.  */ ;
+ 
+       /* Test all long options for either exact match
+ 	 or abbreviated matches.  */
+       for (p = longopts, option_index = 0; p->name; p++, option_index++)
+ 	if (!strncmp (p->name, nextchar, nameend - nextchar))
+ 	  {
+ 	    if ((unsigned int) (nameend - nextchar)
+ 		== (unsigned int) strlen (p->name))
+ 	      {
+ 		/* Exact match found.  */
+ 		pfound = p;
+ 		indfound = option_index;
+ 		exact = 1;
+ 		break;
+ 	      }
+ 	    else if (pfound == NULL)
+ 	      {
+ 		/* First nonexact match found.  */
+ 		pfound = p;
+ 		indfound = option_index;
+ 	      }
+ 	    else
+ 	      /* Second or later nonexact match found.  */
+ 	      ambig = 1;
+ 	  }
+ 
+       if (ambig && !exact)
+ 	{
+ 	  if (opterr)
+ 	    fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
+ 		     argv[0], argv[optind]);
+ 	  nextchar += strlen (nextchar);
+ 	  optind++;
+ 	  optopt = 0;
+ 	  return '?';
+ 	}
+ 
+       if (pfound != NULL)
+ 	{
+ 	  option_index = indfound;
+ 	  optind++;
+ 	  if (*nameend)
+ 	    {
+ 	      /* Don't test has_arg with >, because some C compilers don't
+ 		 allow it to be used on enums.  */
+ 	      if (pfound->has_arg)
+ 		optarg = nameend + 1;
+ 	      else
+ 		{
+ 		  if (opterr)
+ 		    {
+ 		      if (argv[optind - 1][1] == '-')
+ 			/* --option */
+ 			fprintf (stderr,
+ 				 _("%s: option `--%s' doesn't allow an argument\n"),
+ 				 argv[0], pfound->name);
+ 		      else
+ 			/* +option or -option */
+ 			fprintf (stderr,
+ 				 _("%s: option `%c%s' doesn't allow an argument\n"),
+ 				 argv[0], argv[optind - 1][0], pfound->name);
+ 
+ 		      nextchar += strlen (nextchar);
+ 
+ 		      optopt = pfound->val;
+ 		      return '?';
+ 		    }
+ 		}
+ 	    }
+ 	  else if (pfound->has_arg == 1)
+ 	    {
+ 	      if (optind < argc)
+ 		optarg = argv[optind++];
+ 	      else
+ 		{
+ 		  if (opterr)
+ 		    fprintf (stderr,
+ 			   _("%s: option `%s' requires an argument\n"),
+ 			   argv[0], argv[optind - 1]);
+ 		  nextchar += strlen (nextchar);
+ 		  optopt = pfound->val;
+ 		  return optstring[0] == ':' ? ':' : '?';
+ 		}
+ 	    }
+ 	  nextchar += strlen (nextchar);
+ 	  if (longind != NULL)
+ 	    *longind = option_index;
+ 	  if (pfound->flag)
+ 	    {
+ 	      *(pfound->flag) = pfound->val;
+ 	      return 0;
+ 	    }
+ 	  return pfound->val;
+ 	}
+ 
+       /* Can't find it as a long option.  If this is not getopt_long_only,
+ 	 or the option starts with '--' or is not a valid short
+ 	 option, then it's an error.
+ 	 Otherwise interpret it as a short option.  */
+       if (!long_only || argv[optind][1] == '-'
+ 	  || my_index (optstring, *nextchar) == NULL)
+ 	{
+ 	  if (opterr)
+ 	    {
+ 	      if (argv[optind][1] == '-')
+ 		/* --option */
+ 		fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
+ 			 argv[0], nextchar);
+ 	      else
+ 		/* +option or -option */
+ 		fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
+ 			 argv[0], argv[optind][0], nextchar);
+ 	    }
+ 	  nextchar = (char *) "";
+ 	  optind++;
+ 	  optopt = 0;
+ 	  return '?';
+ 	}
+     }
+ 
+   /* Look at and handle the next short option-character.  */
+ 
+   {
+     char c = *nextchar++;
+     char *temp = my_index (optstring, c);
+ 
+     /* Increment `optind' when we start to process its last character.  */
+     if (*nextchar == '\0')
+       ++optind;
+ 
+     if (temp == NULL || c == ':')
+       {
+ 	if (opterr)
+ 	  {
+ 	    if (posixly_correct)
+ 	      /* 1003.2 specifies the format of this message.  */
+ 	      fprintf (stderr, _("%s: illegal option -- %c\n"),
+ 		       argv[0], c);
+ 	    else
+ 	      fprintf (stderr, _("%s: invalid option -- %c\n"),
+ 		       argv[0], c);
+ 	  }
+ 	optopt = c;
+ 	return '?';
+       }
+     /* Convenience. Treat POSIX -W foo same as long option --foo */
+     if (temp[0] == 'W' && temp[1] == ';')
+       {
+ 	char *nameend;
+ 	const struct option *p;
+ 	const struct option *pfound = NULL;
+ 	int exact = 0;
+ 	int ambig = 0;
+ 	int indfound = 0;
+ 	int option_index;
+ 
+ 	/* This is an option that requires an argument.  */
+ 	if (*nextchar != '\0')
+ 	  {
+ 	    optarg = nextchar;
+ 	    /* If we end this ARGV-element by taking the rest as an arg,
+ 	       we must advance to the next element now.  */
+ 	    optind++;
+ 	  }
+ 	else if (optind == argc)
+ 	  {
+ 	    if (opterr)
+ 	      {
+ 		/* 1003.2 specifies the format of this message.  */
+ 		fprintf (stderr, _("%s: option requires an argument -- %c\n"),
+ 			 argv[0], c);
+ 	      }
+ 	    optopt = c;
+ 	    if (optstring[0] == ':')
+ 	      c = ':';
+ 	    else
+ 	      c = '?';
+ 	    return c;
+ 	  }
+ 	else
+ 	  /* We already incremented `optind' once;
+ 	     increment it again when taking next ARGV-elt as argument.  */
+ 	  optarg = argv[optind++];
+ 
+ 	/* optarg is now the argument, see if it's in the
+ 	   table of longopts.  */
+ 
+ 	for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
+ 	  /* Do nothing.  */ ;
+ 
+ 	/* Test all long options for either exact match
+ 	   or abbreviated matches.  */
+ 	for (p = longopts, option_index = 0; p->name; p++, option_index++)
+ 	  if (!strncmp (p->name, nextchar, nameend - nextchar))
+ 	    {
+ 	      if ((unsigned int) (nameend - nextchar) == strlen (p->name))
+ 		{
+ 		  /* Exact match found.  */
+ 		  pfound = p;
+ 		  indfound = option_index;
+ 		  exact = 1;
+ 		  break;
+ 		}
+ 	      else if (pfound == NULL)
+ 		{
+ 		  /* First nonexact match found.  */
+ 		  pfound = p;
+ 		  indfound = option_index;
+ 		}
+ 	      else
+ 		/* Second or later nonexact match found.  */
+ 		ambig = 1;
+ 	    }
+ 	if (ambig && !exact)
+ 	  {
+ 	    if (opterr)
+ 	      fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
+ 		       argv[0], argv[optind]);
+ 	    nextchar += strlen (nextchar);
+ 	    optind++;
+ 	    return '?';
+ 	  }
+ 	if (pfound != NULL)
+ 	  {
+ 	    option_index = indfound;
+ 	    if (*nameend)
+ 	      {
+ 		/* Don't test has_arg with >, because some C compilers don't
+ 		   allow it to be used on enums.  */
+ 		if (pfound->has_arg)
+ 		  optarg = nameend + 1;
+ 		else
+ 		  {
+ 		    if (opterr)
+ 		      fprintf (stderr, _("\
+ %s: option `-W %s' doesn't allow an argument\n"),
+ 			       argv[0], pfound->name);
+ 
+ 		    nextchar += strlen (nextchar);
+ 		    return '?';
+ 		  }
+ 	      }
+ 	    else if (pfound->has_arg == 1)
+ 	      {
+ 		if (optind < argc)
+ 		  optarg = argv[optind++];
+ 		else
+ 		  {
+ 		    if (opterr)
+ 		      fprintf (stderr,
+ 			       _("%s: option `%s' requires an argument\n"),
+ 			       argv[0], argv[optind - 1]);
+ 		    nextchar += strlen (nextchar);
+ 		    return optstring[0] == ':' ? ':' : '?';
+ 		  }
+ 	      }
+ 	    nextchar += strlen (nextchar);
+ 	    if (longind != NULL)
+ 	      *longind = option_index;
+ 	    if (pfound->flag)
+ 	      {
+ 		*(pfound->flag) = pfound->val;
+ 		return 0;
+ 	      }
+ 	    return pfound->val;
+ 	  }
+ 	  nextchar = NULL;
+ 	  return 'W';	/* Let the application handle it.   */
+       }
+     if (temp[1] == ':')
+       {
+ 	if (temp[2] == ':')
+ 	  {
+ 	    /* This is an option that accepts an argument optionally.  */
+ 	    if (*nextchar != '\0')
+ 	      {
+ 		optarg = nextchar;
+ 		optind++;
+ 	      }
+ 	    else
+ 	      optarg = NULL;
+ 	    nextchar = NULL;
+ 	  }
+ 	else
+ 	  {
+ 	    /* This is an option that requires an argument.  */
+ 	    if (*nextchar != '\0')
+ 	      {
+ 		optarg = nextchar;
+ 		/* If we end this ARGV-element by taking the rest as an arg,
+ 		   we must advance to the next element now.  */
+ 		optind++;
+ 	      }
+ 	    else if (optind == argc)
+ 	      {
+ 		if (opterr)
+ 		  {
+ 		    /* 1003.2 specifies the format of this message.  */
+ 		    fprintf (stderr,
+ 			   _("%s: option requires an argument -- %c\n"),
+ 			   argv[0], c);
+ 		  }
+ 		optopt = c;
+ 		if (optstring[0] == ':')
+ 		  c = ':';
+ 		else
+ 		  c = '?';
+ 	      }
+ 	    else
+ 	      /* We already incremented `optind' once;
+ 		 increment it again when taking next ARGV-elt as argument.  */
+ 	      optarg = argv[optind++];
+ 	    nextchar = NULL;
+ 	  }
+       }
+     return c;
+   }
+ }
+ 
+ /*
+ int
+ getopt (argc, argv, optstring)
+      int argc;
+      char *const *argv;
+      const char *optstring;
+ {
+   return _getopt_internal (argc, argv, optstring,
+ 			   (const struct option *) 0,
+ 			   (int *) 0,
+ 			   0);
+ }
+ */
+ 
+ #endif	/* Not ELIDE_CODE.  */
+ /* ******************** ...getopt.c ******************** */
+ 
+ 
+ 
+ /* Comment out all this code if we are using the GNU C Library, and are not
+    actually compiling the library itself.  This code is part of the GNU C
+    Library, but also included in many other GNU distributions.  Compiling
+    and linking in this code is a waste when using the GNU C library
+    (especially if it is a shared library).  Rather than having every GNU
+    program understand `configure --with-gnu-libc' and omit the object files,
+    it is simpler to just do this in the source for each such file.  */
+ 
+ #define GETOPT_INTERFACE_VERSION 2
+ #if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
+ #include <gnu-versions.h>
+ #if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
+ #define ELIDE_CODE
+ #endif
+ #endif
+ 
+ #ifndef ELIDE_CODE
+ 
+ 
+ /* This needs to come after some library #include
+    to get __GNU_LIBRARY__ defined.  */
+ #ifdef __GNU_LIBRARY__
+ #include <stdlib.h>
+ #endif
+ 
+ #ifndef	NULL
+ #define NULL 0
+ #endif
+ 
+ /* K&R declarations!?  C'mon... */
+ /* Just say no to all this gymnastics */
+ #if 0
+ int
+ getopt_long (argc, argv, options, long_options, opt_index)
+      int argc;
+      char *const *argv;
+      const char *options;
+      const struct option *long_options;
+      int *opt_index;
+ #endif
+ int getopt_long (int argc,
+ 	char *const *argv,
+ 	const char *options,
+ 	const struct option *long_options,
+ 	int *opt_index)
+ {
+   return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
+ }
+ 
+ /* Like getopt_long, but '-' as well as '--' can indicate a long option.
+    If an option that starts with '-' (not '--') doesn't match a long option,
+    but does match a short option, it is parsed as a short option
+    instead.  */
+ 
+ #if 0
+ int
+ getopt_long_only (argc, argv, options, long_options, opt_index)
+      int argc;
+      char *const *argv;
+      const char *options;
+      const struct option *long_options;
+      int *opt_index;
+ #endif
+ int
+ getopt_long_only (int argc,
+ 	char *const *argv,
+ 	const char *options,
+ 	const struct option *long_options,
+ 	int *opt_index)
+ {
+   return _getopt_internal (argc, argv, options, long_options, opt_index, 1);
+ }
+ 
+ 
+ #endif	/* Not ELIDE_CODE.  */
+ 
+ #ifdef TEST
+ 
+ #include <stdio.h>
+ 
+ int
+ main (argc, argv)
+      int argc;
+      char **argv;
+ {
+   int c;
+   int digit_optind = 0;
+ 
+   while (1)
+     {
+       int this_option_optind = optind ? optind : 1;
+       int option_index = 0;
+       static struct option long_options[] =
+       {
+ 	{"add", 1, 0, 0},
+ 	{"append", 0, 0, 0},
+ 	{"delete", 1, 0, 0},
+ 	{"verbose", 0, 0, 0},
+ 	{"create", 0, 0, 0},
+ 	{"file", 1, 0, 0},
+ 	{0, 0, 0, 0}
+       };
+ 
+       c = getopt_long (argc, argv, "abc:d:0123456789",
+ 		       long_options, &option_index);
+       if (c == -1)
+ 	break;
+ 
+       switch (c)
+ 	{
+ 	case 0:
+ 	  printf ("option %s", long_options[option_index].name);
+ 	  if (optarg)
+ 	    printf (" with arg %s", optarg);
+ 	  printf ("\n");
+ 	  break;
+ 
+ 	case '0':
+ 	case '1':
+ 	case '2':
+ 	case '3':
+ 	case '4':
+ 	case '5':
+ 	case '6':
+ 	case '7':
+ 	case '8':
+ 	case '9':
+ 	  if (digit_optind != 0 && digit_optind != this_option_optind)
+ 	    printf ("digits occur in two different argv-elements.\n");
+ 	  digit_optind = this_option_optind;
+ 	  printf ("option %c\n", c);
+ 	  break;
+ 
+ 	case 'a':
+ 	  printf ("option a\n");
+ 	  break;
+ 
+ 	case 'b':
+ 	  printf ("option b\n");
+ 	  break;
+ 
+ 	case 'c':
+ 	  printf ("option c with value `%s'\n", optarg);
+ 	  break;
+ 
+ 	case 'd':
+ 	  printf ("option d with value `%s'\n", optarg);
+ 	  break;
+ 
+ 	case '?':
+ 	  break;
+ 
+ 	default:
+ 	  printf ("?? getopt returned character code 0%o ??\n", c);
+ 	}
+     }
+ 
+   if (optind < argc)
+     {
+       printf ("non-option ARGV-elements: ");
+       while (optind < argc)
+ 	printf ("%s ", argv[optind++]);
+       printf ("\n");
+     }
+ 
+   exit (0);
+ }
+ 
+ #endif /* TEST */
+ 
+ #endif /* #ifndef HAVE_GETOPT_LONG */
*** ./src/getopt_long.h.ORIG	Mon May 23 18:53:45 2016
--- ./src/getopt_long.h	Mon May 23 18:46:10 2016
***************
*** 0 ****
--- 1,177 ----
+ /* Declarations for getopt.
+    Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998, 2000
+    Free Software Foundation, Inc.
+ 
+    NOTE: The canonical source of this file is maintained with the GNU C Library.
+    Bugs can be reported to bug-glibc@gnu.org.
+ 
+    This program is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2, or (at your option) any
+    later version.
+ 
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+ 
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+    USA.  */
+ 
+ #ifndef _GETOPT_H
+ #define _GETOPT_H 1
+ 
+ //#include <config.h>
+ 
+ #if HAVE_UNISTD_H
+ /* Declares getopt, if present */
+ #include <unistd.h>
+ #endif
+ 
+ #ifdef	__cplusplus
+ extern "C" {
+ #endif
+ 
+ /* We're building this with a C++ compiler, essentially.  Such
+    compilers are not required to define __STDC__, but the path we
+    should follow, below, is indeed that marked by __STDC__.  We don't
+    want to force a definition of __STDC__ (though that works), because
+    (a) that feels bad, and (b) some compilers perfectly reasonable
+    complain bitterly about it.  So define THIS_IS__STDC__, and replace
+    occurrences of __STDC__ throughout with that.
+ 
+    That means that all of the occurrences of THIS_IS__STDC__ in this
+    file and in getopt_long.c are redundant, but I'm leaving them here
+    in case it becomes necessary to do cleverer things with it than
+    simply define it to be 1, and also as a sort of warped documentation. */
+ #define THIS_IS__STDC__ 1
+ 
+ #if !HAVE_DECL_GETOPT
+ /* For communication from `getopt' to the caller.
+    When `getopt' finds an option that takes an argument,
+    the argument value is returned here.
+    Also, when `ordering' is RETURN_IN_ORDER,
+    each non-option ARGV-element is returned here.  */
+ 
+ extern char *optarg;
+ 
+ /* Index in ARGV of the next element to be scanned.
+    This is used for communication to and from the caller
+    and for communication between successive calls to `getopt'.
+ 
+    On entry to `getopt', zero means this is the first call; initialize.
+ 
+    When `getopt' returns -1, this is the index of the first of the
+    non-option elements that the caller should itself scan.
+ 
+    Otherwise, `optind' communicates from one call to the next
+    how much of ARGV has been scanned so far.  */
+ 
+ extern int optind;
+ 
+ /* Callers store zero here to inhibit the error message `getopt' prints
+    for unrecognized options.  */
+ 
+ extern int opterr;
+ 
+ /* Set to an option character which was unrecognized.  */
+ 
+ extern int optopt;
+ 
+ #endif /* ifndef HAVE_DECL_GETOPT */
+ 
+ #if !HAVE_DECL_GETOPT_LONG
+ /* Describe the long-named options requested by the application.
+    The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
+    of `struct option' terminated by an element containing a name which is
+    zero.
+ 
+    The field `has_arg' is:
+    no_argument		(or 0) if the option does not take an argument,
+    required_argument	(or 1) if the option requires an argument,
+    optional_argument 	(or 2) if the option takes an optional argument.
+ 
+    If the field `flag' is not NULL, it points to a variable that is set
+    to the value given in the field `val' when the option is found, but
+    left unchanged if the option is not found.
+ 
+    To have a long-named option do something other than set an `int' to
+    a compiled-in constant, such as set a value from `optarg', set the
+    option's `flag' field to zero and its `val' field to a nonzero
+    value (the equivalent single-letter option character, if there is
+    one).  For long options that have a zero `flag' field, `getopt'
+    returns the contents of the `val' field.  */
+ 
+ struct option
+ {
+ #if defined (THIS_IS__STDC__) && THIS_IS__STDC__
+   const char *name;
+ #else
+   char *name;
+ #endif
+   /* has_arg can't be an enum because some compilers complain about
+      type mismatches in all the code that assumes it is an int.  */
+   int has_arg;
+   int *flag;
+   int val;
+ };
+ 
+ /* Names for the values of the `has_arg' field of `struct option'.  */
+ 
+ #define	no_argument		0
+ #define required_argument	1
+ #define optional_argument	2
+ 
+ #endif /* #if !HAVE_DECL_GETOPT_LONG */
+ 
+ #if defined (THIS_IS__STDC__) && THIS_IS__STDC__
+ /* HAVE_DECL_* is a three-state macro: undefined, 0 or 1.  If it is
+    undefined, we haven't run the autoconf check so provide the
+    declaration without arguments.  If it is 0, we checked and failed
+    to find the declaration so provide a fully prototyped one.  If it
+    is 1, we found it so don't provide any declaration at all.  */
+ #if defined (__GNU_LIBRARY__) || (defined (HAVE_DECL_GETOPT) && !HAVE_DECL_GETOPT)
+ /* Many other libraries have conflicting prototypes for getopt, with
+    differences in the consts, in stdlib.h.  To avoid compilation
+    errors, only prototype getopt for the GNU C library.  */
+ extern int getopt (int argc, char *const *argv, const char *shortopts);
+ #else /* not __GNU_LIBRARY__ */
+ # ifndef _AIX
+ #  if !defined (HAVE_DECL_GETOPT)
+ extern int getopt ();
+ #  endif
+ # endif
+ #endif /* __GNU_LIBRARY__ */
+ #if !HAVE_DECL_GETOPT_LONG
+ extern int getopt_long (int argc, char *const *argv, const char *shortopts,
+ 		        const struct option *longopts, int *longind);
+ extern int getopt_long_only (int argc, char *const *argv,
+ 			     const char *shortopts,
+ 		             const struct option *longopts, int *longind);
+ 
+ /* Internal only.  Users should not call this directly.  */
+ extern int _getopt_internal (int argc, char *const *argv,
+ 			     const char *shortopts,
+ 		             const struct option *longopts, int *longind,
+ 			     int long_only);
+ #endif /* HAVE_DECL_GETOPT_LONG */
+ #else /* not THIS_IS__STDC__ */
+ #if !HAVE_DECL_GETOPT
+ extern int getopt ();
+ #endif /* HAVE_DECL_GETOPT */
+ #if !HAVE_DECL_GETOPT_LONG
+ extern int getopt_long ();
+ extern int getopt_long_only ();
+ 
+ extern int _getopt_internal ();
+ #endif /* HAVE_DECL_GETOPT_LONG */
+ #endif /* THIS_IS__STDC__ */
+ 
+ 
+ #ifdef	__cplusplus
+ }
+ #endif
+ 
+ #endif /* getopt.h */
*** ./src/daemon.c.ORIG	Mon May 23 18:53:57 2016
--- ./src/daemon.c	Mon May 23 18:53:53 2016
***************
*** 0 ****
--- 1,120 ----
+ /*---------------------------------------------------------------------------*\
+   NAME
+ 	daemon.c - replacement daemon(3) function
+   DESCRIPTION
+         This source file contains a version of a BSD-style daemon(3)
+         function, a function to "daemonize" the calling process.  This
+         implementation is based both on the generic daemon logic defined in
+         the Unix Programmer's FAQ and on the daemon_start() function in
+         W. Richard Stevens' _Unix_Network_Programming_ book (Prentice-Hall,
+         1990).  At the time of this writing, the Unix Programmer's FAQ is
+         located at `http://www.whitefang.com/unix/faq_toc.html' (among
+         other places).
+   LICENSE
+ 	This source code is released under a BSD-style. See the LICENSE
+         file for details.
+   Copyright (c) 2003-2015 Brian M. Clapper, bmc@clapper.org
+ \*---------------------------------------------------------------------------*/
+ 
+ /*---------------------------------------------------------------------------*\
+                                  Includes
+ \*---------------------------------------------------------------------------*/
+ 
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <syslog.h>
+ #include <errno.h>
+ #include <string.h>
+ #include <assert.h>
+ #include <fcntl.h>
+ #include <signal.h>
+ #include <sys/types.h>
+ #include <sys/file.h>
+ 
+ /*---------------------------------------------------------------------------*\
+                               Static Routines
+ \*---------------------------------------------------------------------------*/
+ 
+ /* redirect_fds(): redirect stdin, stdout, and stderr to /dev/NULL */
+ 
+ static void redirect_fds()
+ {
+    (void) close(0);
+    (void) close(1);
+    (void) close(2);
+ 
+    if (open("/dev/null", O_RDWR) != 0)
+    {
+        syslog(LOG_ERR, "Unable to open /dev/null: %s", strerror(errno));
+        exit(1);
+    }
+ 
+    (void) dup(0);
+    (void) dup(0);
+ }
+ 
+ static int do_fork(void)
+ {
+     int status = 0;
+ 
+     switch(fork())
+     {
+         case 0:
+             /* This is the child that will become the daemon. */
+             break;
+ 
+         case -1:
+             /* Fork failure. */
+             status = -1;
+             break;
+ 
+         default:
+             /* Parent: Exit. */
+             _exit(0);
+     }
+ 
+     return status;
+ }
+ 
+ /*---------------------------------------------------------------------------*\
+                               Public Routines
+ \*---------------------------------------------------------------------------*/
+ 
+ int daemon(int nochdir, int noclose)
+ {
+     int status = 0;
+ 
+     openlog("daemonize", LOG_PID, LOG_DAEMON);
+ 
+     /* Fork once to go into the background. */
+     if((status = do_fork()) < 0 )
+         ;
+ 
+     /* Create new session */
+     else if(setsid() < 0)               /* shouldn't fail */
+         status = -1;
+ 
+     /* Fork again to ensure that daemon never reacquires a control terminal. */
+     else if((status = do_fork()) < 0 )
+         ;
+ 
+     else
+     {
+         /* clear any inherited umask(2) value */
+ 
+         umask(0);
+ 
+         /* We're there. */
+ 
+         if(! nochdir)
+         {
+             /* Go to a neutral corner. */
+             chdir("/");
+         }
+ 
+         if(! noclose)
+             redirect_fds();
+     }
+ 
+     return status;
+ }
#*** ./src/Makefile.in.ORIG	Fri Nov 18 00:49:39 2016
#--- ./src/Makefile.in	Fri Nov 18 00:50:10 2016
#***************
#*** 140,146 ****
#  am_libiperf_la_OBJECTS = cjson.lo iperf_api.lo iperf_error.lo \
#  	iperf_client_api.lo iperf_locale.lo iperf_server_api.lo \
#  	iperf_tcp.lo iperf_udp.lo iperf_sctp.lo iperf_util.lo net.lo \
#! 	tcp_info.lo tcp_window_size.lo timer.lo units.lo
#  libiperf_la_OBJECTS = $(am_libiperf_la_OBJECTS)
#  AM_V_lt = $(am__v_lt_@AM_V@)
#  am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
#--- 140,146 ----
#  am_libiperf_la_OBJECTS = cjson.lo iperf_api.lo iperf_error.lo \
#  	iperf_client_api.lo iperf_locale.lo iperf_server_api.lo \
#  	iperf_tcp.lo iperf_udp.lo iperf_sctp.lo iperf_util.lo net.lo \
#! 	tcp_info.lo tcp_window_size.lo timer.lo units.lo getopt_long.lo
#  libiperf_la_OBJECTS = $(am_libiperf_la_OBJECTS)
#  AM_V_lt = $(am__v_lt_@AM_V@)
#  am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
#*** ./src/iperf.h.ORIG	Fri Nov 18 00:27:58 2016
#--- ./src/iperf.h	Fri Nov 18 00:28:07 2016
#***************
#*** 36,42 ****
#  #endif
#  #include <sys/select.h>
#  #include <sys/socket.h>
#! #include <netinet/tcp.h>
#  
#  #if defined(HAVE_CPUSET_SETAFFINITY)
#  #include <sys/param.h>
#--- 36,42 ----
#  #endif
#  #include <sys/select.h>
#  #include <sys/socket.h>
#! #include <netinet/in.h>
#  
#  #if defined(HAVE_CPUSET_SETAFFINITY)
#  #include <sys/param.h>
#*** ./src/units.c.ORIG	Fri Nov 18 00:26:28 2016
#--- ./src/units.c	Fri Nov 18 00:26:34 2016
#***************
#*** 60,66 ****
#  #include <sys/socket.h>
#  #include <sys/types.h>
#  #include <sys/time.h>
#! #include <netinet/tcp.h>
#  
#  
#  #include "iperf.h"
#--- 60,66 ----
#  #include <sys/socket.h>
#  #include <sys/types.h>
#  #include <sys/time.h>
#! #include <netinet/in.h>
#  
#  
#  #include "iperf.h"
--- src/units.c.orig	2017-08-29 02:06:06 -0500
+++ src/units.c	2017-08-29 02:07:37 -0500
@@ -60,7 +60,7 @@
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/time.h>
-
+#include <netinet/tcp.h>
 
 #include "iperf.h"
 
--- ./src/Makefile.in.orig	2020-01-31 01:18:10 +0000
+++ ./src/Makefile.in	2020-01-31 01:19:02 +0000
@@ -670,9 +670,9 @@
 @ENABLE_PROFILING_TRUE@iperf3_profile_SOURCES = main.c \
 @ENABLE_PROFILING_TRUE@                          $(libiperf_la_SOURCES)
 
-@ENABLE_PROFILING_TRUE@iperf3_profile_CFLAGS = -pg -g
+@ENABLE_PROFILING_TRUE@iperf3_profile_CFLAGS = 
 @ENABLE_PROFILING_TRUE@iperf3_profile_LDADD = libiperf.la
-@ENABLE_PROFILING_TRUE@iperf3_profile_LDFLAGS = -pg -g
+@ENABLE_PROFILING_TRUE@iperf3_profile_LDFLAGS = 
 
 # Specify the sources and various flags for the test cases
 t_timer_SOURCES = t_timer.c
--- ./src/iperf_api.c.orig	2020-01-31 01:24:55 +0000
+++ ./src/iperf_api.c	2020-01-31 01:27:09 +0000
@@ -3607,6 +3607,10 @@
 }
 
 /**************************************************************************/
+#ifndef MAP_FAILED
+#define MAP_FAILED ((void *)-1)
+#endif
+
 struct iperf_stream *
 iperf_new_stream(struct iperf_test *test, int s, int sender)
 {
--- ./src/main.c.orig	2021-12-20 05:13:08 +0000
+++ ./src/main.c	2021-12-20 05:13:34 +0000
@@ -54,6 +54,11 @@
 #include "net.h"
 #include "units.h"
 
+/* AIX does not have the daemon() system call */
+#ifdef _AIX
+#include "daemon.c"
+#endif
+
 
 static int run(struct iperf_test *test);
 
--- ./src/portable_endian.h.orig	2021-12-20 05:14:55 +0000
+++ ./src/portable_endian.h	2021-12-20 05:15:29 +0000
@@ -65,7 +65,7 @@
 #	define __LITTLE_ENDIAN LITTLE_ENDIAN
 #	define __PDP_ENDIAN    PDP_ENDIAN
 
-#elif defined(__sun) && defined(__SVR4)
+#elif defined(__sun) && defined(__SVR4) || defined(_AIX)
 
 #	include <sys/types.h>
 #	include <netinet/in.h>
--- ./src/iperf_error.c.orig	2021-12-20 05:17:12 +0000
+++ ./src/iperf_error.c	2021-12-20 05:17:39 +0000
@@ -33,6 +33,10 @@
 #include "iperf.h"
 #include "iperf_api.h"
 
+#ifndef hstrerror
+extern const char *    hstrerror(int);
+#endif
+
 int gerror;
 
 char iperf_timestrerr[100];
--- ./src/Makefile.in.orig	2021-12-20 05:19:05 +0000
+++ ./src/Makefile.in	2021-12-20 05:20:21 +0000
@@ -671,9 +671,9 @@
 
 # Specify the sources and various flags for the iperf binary
 iperf3_SOURCES = main.c
-iperf3_CFLAGS = -g
+iperf3_CFLAGS = 
 iperf3_LDADD = libiperf.la
-iperf3_LDFLAGS = -g
+iperf3_LDFLAGS = 
 
 # If the iperf-profiled-binary is enabled
 # Specify the sources and various flags for the profiled iperf binary. This
@@ -687,15 +687,15 @@
 
 # Specify the sources and various flags for the test cases
 t_timer_SOURCES = t_timer.c
-t_timer_CFLAGS = -g
+t_timer_CFLAGS = 
 t_timer_LDFLAGS = 
 t_timer_LDADD = libiperf.la
 t_units_SOURCES = t_units.c
-t_units_CFLAGS = -g
+t_units_CFLAGS = 
 t_units_LDFLAGS = 
 t_units_LDADD = libiperf.la
 t_uuid_SOURCES = t_uuid.c
-t_uuid_CFLAGS = -g
+t_uuid_CFLAGS = 
 t_uuid_LDFLAGS = 
 t_uuid_LDADD = libiperf.la
 t_api_SOURCES = t_api.c
--- src/iperf_client_api.c_orig	2025-01-27 06:39:34.090683213 -0600
+++ src/iperf_client_api.c	2025-01-27 06:42:03.425038655 -0600
@@ -45,6 +45,9 @@
 #include "iperf_time.h"
 #include "net.h"
 #include "timer.h"
+#ifdef _AIX
+#include <netinet/tcp.h>
+#endif
 
 #if defined(HAVE_TCP_CONGESTION)
 #if !defined(TCP_CA_NAME_MAX)
--- src/Makefile.in_orig	2025-01-27 06:44:06.075548330 -0600
+++ src/Makefile.in	2025-01-27 06:48:40.130027351 -0600
@@ -152,7 +152,7 @@
 	iperf_auth.lo iperf_client_api.lo iperf_locale.lo \
 	iperf_server_api.lo iperf_tcp.lo iperf_udp.lo iperf_sctp.lo \
 	iperf_util.lo iperf_time.lo iperf_pthread.lo dscp.lo net.lo \
-	tcp_info.lo timer.lo units.lo
+	tcp_info.lo timer.lo units.lo getopt_long.lo
 libiperf_la_OBJECTS = $(am_libiperf_la_OBJECTS)
 AM_V_lt = $(am__v_lt_@AM_V@)
 am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
