Attachment #215540 for bug #247251

Line 0 Link Here

(-)sysutils/pwol/distinfo (+3 lines)
	1	TIMESTAMP = 1592131153
	2	SHA256 (ptrrkssn-pwol-v1.5_GH0.tar.gz) = b84c33405b070fea6c17489e4d7670a4a63490978cb29d1a38fa0d6d53ffdf62
	3	SIZE (ptrrkssn-pwol-v1.5_GH0.tar.gz) = 72697




# $FreeBSD$

PORTNAME=		pwol
DISTVERSIONPREFIX=	v
DISTVERSION=		1.5
CATEGORIES=		sysutils

MAINTAINER=		pen@lysator.liu.se
COMMENT=		Peter's Wake-on-LAN Tool

LICENSE=		BSD3CLAUSE
LICENSE_FILE=		${WRKSRC}/LICENSE

USE_GITHUB=		yes
GH_ACCOUNT=		ptrrkssn

GNU_CONFIGURE=		yes

PLIST_FILES=		bin/pwol \
			man/man1/pwol.1.gz \
			man/man5/pwol.conf.5.gz \
			etc/pwol.conf.sample

.include <bsd.port.mk>

Line 0 Link Here

(-)sysutils/pwol/pkg-descr (+9 lines)
	1	This is a port of pwol, Peter's Wake-on-Lan tool
	2
	3	This is a simple tool to send WoL packets to wake up
	4	hosts. No more, no less.
	5
	6	WWW: https://github.com/ptrrkssn/pwol
	7
	8	- Peter Eriksson
	9	pen@lysator.liu.se

Line 0 Link Here

(-)sysutils/pwol/work/.license-catalog.mk (+5 lines)
	1	_LICENSE=BSD3CLAUSE
	2	_LICENSE_NAME=BSD 3-clause New or Revised License
	3	_LICENSE_PERMS=dist-mirror dist-sell pkg-mirror pkg-sell auto-accept
	4	_LICENSE_GROUPS=FSF OSI COPYFREE
	5	_LICENSE_DISTFILES=ptrrkssn-pwol-v1.5_GH0.tar.gz

Line 0 Link Here

(-)sysutils/pwol/work/.license-report (+1 lines)
	1	This package has a single license: BSD3CLAUSE (BSD 3-clause New or Revised License).

Line 0 Link Here

(-)sysutils/pwol/work/.PLIST.flattened (+7 lines)
	1	/usr/local/bin/pwol
	2	/usr/local/man/man1/pwol.1.gz
	3	/usr/local/man/man5/pwol.conf.5.gz
	4	/usr/local/etc/pwol.conf.sample
	5	/usr/local/share/licenses/pwol-1.5/catalog.mk
	6	/usr/local/share/licenses/pwol-1.5/LICENSE
	7	/usr/local/share/licenses/pwol-1.5/BSD3CLAUSE

Line 0 Link Here

(-)sysutils/pwol/work/.PLIST.mktmp (+7 lines)
	1	bin/pwol
	2	man/man1/pwol.1.gz
	3	man/man5/pwol.conf.5.gz
	4	etc/pwol.conf.sample
	5	/usr/local/share/licenses/pwol-1.5/catalog.mk
	6	/usr/local/share/licenses/pwol-1.5/LICENSE
	7	/usr/local/share/licenses/pwol-1.5/BSD3CLAUSE

Line 0 Link Here

(-)sysutils/pwol/work/.PLIST.readelf (+85 lines)
		1
		2	File: /usr/local/bin/pwol
		3
		4	Relocation section with addend (.rela.dyn):
		5	r_offset r_info r_type st_value st_name + r_addend
		6	0000006081d8 001b00000012 R_X86_64_TPOFF64 0000000000000000 _ThreadRuneLocale + 0
		7	0000006083f0 004400000005 R_X86_64_COPY 00000000006083f0 __stdoutp + 0
		8	0000006083f8 004200000005 R_X86_64_COPY 00000000006083f8 __stdinp + 0
		9	000000608400 004300000005 R_X86_64_COPY 0000000000608400 __mb_sb_limit + 0
		10	000000608408 003b00000005 R_X86_64_COPY 0000000000608408 _DefaultRuneLocale + 0
		11	000000609488 003c00000005 R_X86_64_COPY 0000000000609488 __isthreaded + 0
		12	000000609490 003e00000005 R_X86_64_COPY 0000000000609490 __stack_chk_guard + 0
		13	0000006094d0 004000000005 R_X86_64_COPY 00000000006094d0 _CurrentRuneLocale + 0
		14	0000006094d8 004500000005 R_X86_64_COPY 00000000006094d8 __stderrp + 0
		15
		16	Relocation section with addend (.rela.plt):
		17	r_offset r_info r_type st_value st_name + r_addend
		18	0000006081f8 000100000007 R_X86_64_JUMP_SLOT 0000000000000000 malloc + 0
		19	000000608200 000200000007 R_X86_64_JUMP_SLOT 0000000000000000 chdir + 0
		20	000000608208 000300000007 R_X86_64_JUMP_SLOT 0000000000000000 bind + 0
		21	000000608210 000400000007 R_X86_64_JUMP_SLOT 0000000000000000 open + 0
		22	000000608218 000500000007 R_X86_64_JUMP_SLOT 0000000000000000 umask + 0
		23	000000608220 000700000007 R_X86_64_JUMP_SLOT 0000000000000000 fork + 0
		24	000000608228 000800000007 R_X86_64_JUMP_SLOT 0000000000000000 strtok_r + 0
		25	000000608230 000900000007 R_X86_64_JUMP_SLOT 0000000000000000 printf + 0
		26	000000608238 000a00000007 R_X86_64_JUMP_SLOT 0000000000000000 fgets + 0
		27	000000608240 000b00000007 R_X86_64_JUMP_SLOT 0000000000000000 isatty + 0
		28	000000608248 000c00000007 R_X86_64_JUMP_SLOT 0000000000000000 fwrite + 0
		29	000000608250 000d00000007 R_X86_64_JUMP_SLOT 0000000000000000 atexit + 0
		30	000000608258 000e00000007 R_X86_64_JUMP_SLOT 0000000000000000 socket + 0
		31	000000608260 000f00000007 R_X86_64_JUMP_SLOT 0000000000000000 strerror + 0
		32	000000608268 001000000007 R_X86_64_JUMP_SLOT 0000000000000000 getaddrinfo + 0
		33	000000608270 001100000007 R_X86_64_JUMP_SLOT 0000000000000000 _init_tls + 0
		34	000000608278 001200000007 R_X86_64_JUMP_SLOT 0000000000000000 fclose + 0
		35	000000608280 001300000007 R_X86_64_JUMP_SLOT 0000000000000000 memcmp + 0
		36	000000608288 001400000007 R_X86_64_JUMP_SLOT 0000000000000000 strdup + 0
		37	000000608290 001500000007 R_X86_64_JUMP_SLOT 0000000000000000 fprintf + 0
		38	000000608298 001600000007 R_X86_64_JUMP_SLOT 0000000000000000 sprintf + 0
		39	0000006082a0 001700000007 R_X86_64_JUMP_SLOT 0000000000000000 close + 0
		40	0000006082a8 001800000007 R_X86_64_JUMP_SLOT 0000000000000000 ether_hostton + 0
		41	0000006082b0 001900000007 R_X86_64_JUMP_SLOT 0000000000000000 nanosleep + 0
		42	0000006082b8 001a00000007 R_X86_64_JUMP_SLOT 0000000000000000 strlen + 0
		43	0000006082c0 001c00000007 R_X86_64_JUMP_SLOT 0000000000000000 strcat + 0
		44	0000006082c8 001d00000007 R_X86_64_JUMP_SLOT 0000000000000000 dup2 + 0
		45	0000006082d0 001e00000007 R_X86_64_JUMP_SLOT 0000000000000000 syslog + 0
		46	0000006082d8 001f00000007 R_X86_64_JUMP_SLOT 0000000000000000 setsockopt + 0
		47	0000006082e0 002000000007 R_X86_64_JUMP_SLOT 0000000000000000 signal + 0
		48	0000006082e8 002100000007 R_X86_64_JUMP_SLOT 0000000000000000 snprintf + 0
		49	0000006082f0 002200000007 R_X86_64_JUMP_SLOT 0000000000000000 sscanf + 0
		50	0000006082f8 002300000007 R_X86_64_JUMP_SLOT 0000000000000000 sendto + 0
		51	000000608300 002400000007 R_X86_64_JUMP_SLOT 0000000000000000 putc + 0
		52	000000608308 002500000007 R_X86_64_JUMP_SLOT 0000000000000000 __stack_chk_fail + 0
		53	000000608310 002600000007 R_X86_64_JUMP_SLOT 0000000000000000 realloc + 0
		54	000000608318 002700000007 R_X86_64_JUMP_SLOT 0000000000000000 __error + 0
		55	000000608320 002800000007 R_X86_64_JUMP_SLOT 0000000000000000 getnameinfo + 0
		56	000000608328 002900000007 R_X86_64_JUMP_SLOT 0000000000000000 fflush + 0
		57	000000608330 002a00000007 R_X86_64_JUMP_SLOT 0000000000000000 freeaddrinfo + 0
		58	000000608338 002b00000007 R_X86_64_JUMP_SLOT 0000000000000000 memcpy + 0
		59	000000608340 002c00000007 R_X86_64_JUMP_SLOT 0000000000000000 putchar + 0
		60	000000608348 002d00000007 R_X86_64_JUMP_SLOT 0000000000000000 strcpy + 0
		61	000000608350 002e00000007 R_X86_64_JUMP_SLOT 0000000000000000 fileno + 0
		62	000000608358 002f00000007 R_X86_64_JUMP_SLOT 0000000000000000 getenv + 0
		63	000000608360 003000000007 R_X86_64_JUMP_SLOT 0000000000000000 ether_ntoa + 0
		64	000000608368 003100000007 R_X86_64_JUMP_SLOT 0000000000000000 exit + 0
65	000000608370 003200000007 R_X86_64_JUMP_SLOT 0000000000000000 fopen + 0
66	000000608378 003300000007 R_X86_64_JUMP_SLOT 0000000000000000 recvfrom + 0
67	000000608380 003400000007 R_X86_64_JUMP_SLOT 0000000000000000 ether_aton + 0
68	000000608388 003500000007 R_X86_64_JUMP_SLOT 0000000000000000 free + 0
69	000000608390 003600000007 R_X86_64_JUMP_SLOT 0000000000000000 poll + 0
70	000000608398 003700000007 R_X86_64_JUMP_SLOT 0000000000000000 strcmp + 0
71	0000006083a0 003800000007 R_X86_64_JUMP_SLOT 0000000000000000 strchr + 0
72	0000006083a8 003900000007 R_X86_64_JUMP_SLOT 0000000000000000 puts + 0
73	0000006083b0 003a00000007 R_X86_64_JUMP_SLOT 0000000000000000 __swbuf + 0
74
75	File: /usr/local/man/man1/pwol.1.gz
76
77	File: /usr/local/man/man5/pwol.conf.5.gz
78
79	File: /usr/local/etc/pwol.conf.sample
80
81	File: /usr/local/share/licenses/pwol-1.5/catalog.mk
82
83	File: /usr/local/share/licenses/pwol-1.5/LICENSE
84
85	File: /usr/local/share/licenses/pwol-1.5/BSD3CLAUSE




name: C/C++ CI

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v2
#    - name: install dependencies
#      run: test -f /usr/include/readline/readline.h || sudo apt install libreadline-dev
#    - name: configure
#      run: ./configure
    - name: make
      run: make
#    - name: make check
#      run: make check
#    - name: make distcheck
#      run: make distcheck




name: C/C++ CI

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v2
    - name: install dependencies
      run: test -f /usr/include/readline/readline.h || sudo apt install libreadline-dev
    - name: configure
      run: ./configure
    - name: make
      run: make
    - name: make check
      run: make check
    - name: make distcheck
      run: make distcheck




#! /bin/sh
# Wrapper for compilers which do not understand '-c -o'.

scriptversion=2018-03-07.03; # UTC

# Copyright (C) 1999-2018 Free Software Foundation, Inc.
# Written by Tom Tromey <tromey@cygnus.com>.
#
# 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, see <https://www.gnu.org/licenses/>.

# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.

# This file is maintained in Automake, please report
# bugs to <bug-automake@gnu.org> or send patches to
# <automake-patches@gnu.org>.

nl='
'

# We need space, tab and new line, in precisely that order.  Quoting is
# there to prevent tools from complaining about whitespace usage.
IFS=" ""	$nl"

file_conv=

# func_file_conv build_file lazy
# Convert a $build file to $host form and store it in $file
# Currently only supports Windows hosts. If the determined conversion
# type is listed in (the comma separated) LAZY, no conversion will
# take place.
func_file_conv ()
{
  file=$1
  case $file in
    / | /[!/]*) # absolute file, and not a UNC file
      if test -z "$file_conv"; then
	# lazily determine how to convert abs files
	case `uname -s` in
	  MINGW*)
	    file_conv=mingw
	    ;;
	  CYGWIN*)
	    file_conv=cygwin
	    ;;
	  *)
	    file_conv=wine
	    ;;
	esac
      fi
      case $file_conv/,$2, in
	*,$file_conv,*)
	  ;;
	mingw/*)
	  file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'`
	  ;;
	cygwin/*)
	  file=`cygpath -m "$file" || echo "$file"`
	  ;;
	wine/*)
	  file=`winepath -w "$file" || echo "$file"`
	  ;;
      esac
      ;;
  esac
}

# func_cl_dashL linkdir
# Make cl look for libraries in LINKDIR
func_cl_dashL ()
{
  func_file_conv "$1"
  if test -z "$lib_path"; then
    lib_path=$file
  else
    lib_path="$lib_path;$file"
  fi
  linker_opts="$linker_opts -LIBPATH:$file"
}

# func_cl_dashl library
# Do a library search-path lookup for cl
func_cl_dashl ()
{
  lib=$1
  found=no
  save_IFS=$IFS
  IFS=';'
  for dir in $lib_path $LIB
  do
    IFS=$save_IFS
    if $shared && test -f "$dir/$lib.dll.lib"; then
      found=yes
      lib=$dir/$lib.dll.lib
      break
    fi
    if test -f "$dir/$lib.lib"; then
      found=yes
      lib=$dir/$lib.lib
      break
    fi
    if test -f "$dir/lib$lib.a"; then
      found=yes
      lib=$dir/lib$lib.a
      break
    fi
  done
  IFS=$save_IFS

  if test "$found" != yes; then
    lib=$lib.lib
  fi
}

# func_cl_wrapper cl arg...
# Adjust compile command to suit cl
func_cl_wrapper ()
{
  # Assume a capable shell
  lib_path=
  shared=:
  linker_opts=
  for arg
  do
    if test -n "$eat"; then
      eat=
    else
      case $1 in
	-o)
	  # configure might choose to run compile as 'compile cc -o foo foo.c'.
	  eat=1
	  case $2 in
	    *.o | *.[oO][bB][jJ])
	      func_file_conv "$2"
	      set x "$@" -Fo"$file"
	      shift
	      ;;
	    *)
	      func_file_conv "$2"
	      set x "$@" -Fe"$file"
	      shift
	      ;;
	  esac
	  ;;
	-I)
	  eat=1
	  func_file_conv "$2" mingw
	  set x "$@" -I"$file"
	  shift
	  ;;
	-I*)
	  func_file_conv "${1#-I}" mingw
	  set x "$@" -I"$file"
	  shift
	  ;;
	-l)
	  eat=1
	  func_cl_dashl "$2"
	  set x "$@" "$lib"
	  shift
	  ;;
	-l*)
	  func_cl_dashl "${1#-l}"
	  set x "$@" "$lib"
	  shift
	  ;;
	-L)
	  eat=1
	  func_cl_dashL "$2"
	  ;;
	-L*)
	  func_cl_dashL "${1#-L}"
	  ;;
	-static)
	  shared=false
	  ;;
	-Wl,*)
	  arg=${1#-Wl,}
	  save_ifs="$IFS"; IFS=','
	  for flag in $arg; do
	    IFS="$save_ifs"
	    linker_opts="$linker_opts $flag"
	  done
	  IFS="$save_ifs"
	  ;;
	-Xlinker)
	  eat=1
	  linker_opts="$linker_opts $2"
	  ;;
	-*)
	  set x "$@" "$1"
	  shift
	  ;;
	*.cc | *.CC | *.cxx | *.CXX | *.[cC]++)
	  func_file_conv "$1"
	  set x "$@" -Tp"$file"
	  shift
	  ;;
	*.c | *.cpp | *.CPP | *.lib | *.LIB | *.Lib | *.OBJ | *.obj | *.[oO])
	  func_file_conv "$1" mingw
	  set x "$@" "$file"
	  shift
	  ;;
	*)
	  set x "$@" "$1"
	  shift
	  ;;
      esac
    fi
    shift
  done
  if test -n "$linker_opts"; then
    linker_opts="-link$linker_opts"
  fi
  exec "$@" $linker_opts
  exit 1
}

eat=

case $1 in
  '')
     echo "$0: No command.  Try '$0 --help' for more information." 1>&2
     exit 1;
     ;;
  -h | --h*)
    cat <<\EOF
Usage: compile [--help] [--version] PROGRAM [ARGS]

Wrapper for compilers which do not understand '-c -o'.
Remove '-o dest.o' from ARGS, run PROGRAM with the remaining
arguments, and rename the output as expected.

If you are trying to build a whole package this is not the
right script to run: please start by reading the file 'INSTALL'.

Report bugs to <bug-automake@gnu.org>.
EOF
    exit $?
    ;;
  -v | --v*)
    echo "compile $scriptversion"
    exit $?
    ;;
  cl | *[/\\]cl | cl.exe | *[/\\]cl.exe | \
  icl | *[/\\]icl | icl.exe | *[/\\]icl.exe )
    func_cl_wrapper "$@"      # Doesn't return...
    ;;
esac

ofile=
cfile=

for arg
do
  if test -n "$eat"; then
    eat=
  else
    case $1 in
      -o)
	# configure might choose to run compile as 'compile cc -o foo foo.c'.
	# So we strip '-o arg' only if arg is an object.
	eat=1
	case $2 in
	  *.o | *.obj)
	    ofile=$2
	    ;;
	  *)
	    set x "$@" -o "$2"
	    shift
	    ;;
	esac
	;;
      *.c)
	cfile=$1
	set x "$@" "$1"
	shift
	;;
      *)
	set x "$@" "$1"
	shift
	;;
    esac
  fi
  shift
done

if test -z "$ofile" || test -z "$cfile"; then
  # If no '-o' option was seen then we might have been invoked from a
  # pattern rule where we don't need one.  That is ok -- this is a
  # normal compilation that the losing compiler can handle.  If no
  # '.c' file was seen then we are probably linking.  That is also
  # ok.
  exec "$@"
fi

# Name of file we expect compiler to create.
cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'`

# Create the lock directory.
# Note: use '[/\\:.-]' here to ensure that we don't use the same name
# that we are using for the .o file.  Also, base the name on the expected
# object file name, since that is what matters with a parallel build.
lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d
while true; do
  if mkdir "$lockdir" >/dev/null 2>&1; then
    break
  fi
  sleep 1
done
# FIXME: race condition here if user kills between mkdir and trap.
trap "rmdir '$lockdir'; exit 1" 1 2 15

# Run the compile.
"$@"
ret=$?

if test -f "$cofile"; then
  test "$cofile" = "$ofile" || mv "$cofile" "$ofile"
elif test -f "${cofile}bj"; then
  test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile"
fi

rmdir "$lockdir"
exit $ret

# Local Variables:
# mode: shell-script
# sh-indentation: 2
# eval: (add-hook 'before-save-hook 'time-stamp)
# time-stamp-start: "scriptversion="
# time-stamp-format: "%:y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC0"
# time-stamp-end: "; # UTC"
# End:




#! /bin/sh
# depcomp - compile a program generating dependencies as side-effects

scriptversion=2018-03-07.03; # UTC

# Copyright (C) 1999-2018 Free Software Foundation, Inc.

# 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, see <https://www.gnu.org/licenses/>.

# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.

# Originally written by Alexandre Oliva <oliva@dcc.unicamp.br>.

case $1 in
  '')
    echo "$0: No command.  Try '$0 --help' for more information." 1>&2
    exit 1;
    ;;
  -h | --h*)
    cat <<\EOF
Usage: depcomp [--help] [--version] PROGRAM [ARGS]

Run PROGRAMS ARGS to compile a file, generating dependencies
as side-effects.

Environment variables:
  depmode     Dependency tracking mode.
  source      Source file read by 'PROGRAMS ARGS'.
  object      Object file output by 'PROGRAMS ARGS'.
  DEPDIR      directory where to store dependencies.
  depfile     Dependency file to output.
  tmpdepfile  Temporary file to use when outputting dependencies.
  libtool     Whether libtool is used (yes/no).

Report bugs to <bug-automake@gnu.org>.
EOF
    exit $?
    ;;
  -v | --v*)
    echo "depcomp $scriptversion"
    exit $?
    ;;
esac

# Get the directory component of the given path, and save it in the
# global variables '$dir'.  Note that this directory component will
# be either empty or ending with a '/' character.  This is deliberate.
set_dir_from ()
{
  case $1 in
    */*) dir=`echo "$1" | sed -e 's|/[^/]*$|/|'`;;
      *) dir=;;
  esac
}

# Get the suffix-stripped basename of the given path, and save it the
# global variable '$base'.
set_base_from ()
{
  base=`echo "$1" | sed -e 's|^.*/||' -e 's/\.[^.]*$//'`
}

# If no dependency file was actually created by the compiler invocation,
# we still have to create a dummy depfile, to avoid errors with the
# Makefile "include basename.Plo" scheme.
make_dummy_depfile ()
{
  echo "#dummy" > "$depfile"
}

# Factor out some common post-processing of the generated depfile.
# Requires the auxiliary global variable '$tmpdepfile' to be set.
aix_post_process_depfile ()
{
  # If the compiler actually managed to produce a dependency file,
  # post-process it.
  if test -f "$tmpdepfile"; then
    # Each line is of the form 'foo.o: dependency.h'.
    # Do two passes, one to just change these to
    #   $object: dependency.h
    # and one to simply output
    #   dependency.h:
    # which is needed to avoid the deleted-header problem.
    { sed -e "s,^.*\.[$lower]*:,$object:," < "$tmpdepfile"
      sed -e "s,^.*\.[$lower]*:[$tab ]*,," -e 's,$,:,' < "$tmpdepfile"
    } > "$depfile"
    rm -f "$tmpdepfile"
  else
    make_dummy_depfile
  fi
}

# A tabulation character.
tab='	'
# A newline character.
nl='
'
# Character ranges might be problematic outside the C locale.
# These definitions help.
upper=ABCDEFGHIJKLMNOPQRSTUVWXYZ
lower=abcdefghijklmnopqrstuvwxyz
digits=0123456789
alpha=${upper}${lower}

if test -z "$depmode" || test -z "$source" || test -z "$object"; then
  echo "depcomp: Variables source, object and depmode must be set" 1>&2
  exit 1
fi

# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
depfile=${depfile-`echo "$object" |
  sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}
tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}

rm -f "$tmpdepfile"

# Avoid interferences from the environment.
gccflag= dashmflag=

# Some modes work just like other modes, but use different flags.  We
# parameterize here, but still list the modes in the big case below,
# to make depend.m4 easier to write.  Note that we *cannot* use a case
# here, because this file can only contain one case statement.
if test "$depmode" = hp; then
  # HP compiler uses -M and no extra arg.
  gccflag=-M
  depmode=gcc
fi

if test "$depmode" = dashXmstdout; then
  # This is just like dashmstdout with a different argument.
  dashmflag=-xM
  depmode=dashmstdout
fi

cygpath_u="cygpath -u -f -"
if test "$depmode" = msvcmsys; then
  # This is just like msvisualcpp but w/o cygpath translation.
  # Just convert the backslash-escaped backslashes to single forward
  # slashes to satisfy depend.m4
  cygpath_u='sed s,\\\\,/,g'
  depmode=msvisualcpp
fi

if test "$depmode" = msvc7msys; then
  # This is just like msvc7 but w/o cygpath translation.
  # Just convert the backslash-escaped backslashes to single forward
  # slashes to satisfy depend.m4
  cygpath_u='sed s,\\\\,/,g'
  depmode=msvc7
fi

if test "$depmode" = xlc; then
  # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information.
  gccflag=-qmakedep=gcc,-MF
  depmode=gcc
fi

case "$depmode" in
gcc3)
## gcc 3 implements dependency tracking that does exactly what
## we want.  Yay!  Note: for some reason libtool 1.4 doesn't like
## it if -MD -MP comes after the -MF stuff.  Hmm.
## Unfortunately, FreeBSD c89 acceptance of flags depends upon
## the command line argument order; so add the flags where they
## appear in depend2.am.  Note that the slowdown incurred here
## affects only configure: in makefiles, %FASTDEP% shortcuts this.
  for arg
  do
    case $arg in
    -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;;
    *)  set fnord "$@" "$arg" ;;
    esac
    shift # fnord
    shift # $arg
  done
  "$@"
  stat=$?
  if test $stat -ne 0; then
    rm -f "$tmpdepfile"
    exit $stat
  fi
  mv "$tmpdepfile" "$depfile"
  ;;

gcc)
## Note that this doesn't just cater to obsosete pre-3.x GCC compilers.
## but also to in-use compilers like IMB xlc/xlC and the HP C compiler.
## (see the conditional assignment to $gccflag above).
## There are various ways to get dependency output from gcc.  Here's
## why we pick this rather obscure method:
## - Don't want to use -MD because we'd like the dependencies to end
##   up in a subdir.  Having to rename by hand is ugly.
##   (We might end up doing this anyway to support other compilers.)
## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
##   -MM, not -M (despite what the docs say).  Also, it might not be
##   supported by the other compilers which use the 'gcc' depmode.
## - Using -M directly means running the compiler twice (even worse
##   than renaming).
  if test -z "$gccflag"; then
    gccflag=-MD,
  fi
  "$@" -Wp,"$gccflag$tmpdepfile"
  stat=$?
  if test $stat -ne 0; then
    rm -f "$tmpdepfile"
    exit $stat
  fi
  rm -f "$depfile"
  echo "$object : \\" > "$depfile"
  # The second -e expression handles DOS-style file names with drive
  # letters.
  sed -e 's/^[^:]*: / /' \
      -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
## This next piece of magic avoids the "deleted header file" problem.
## The problem is that when a header file which appears in a .P file
## is deleted, the dependency causes make to die (because there is
## typically no way to rebuild the header).  We avoid this by adding
## dummy dependencies for each header file.  Too bad gcc doesn't do
## this for us directly.
## Some versions of gcc put a space before the ':'.  On the theory
## that the space means something, we add a space to the output as
## well.  hp depmode also adds that space, but also prefixes the VPATH
## to the object.  Take care to not repeat it in the output.
## Some versions of the HPUX 10.20 sed can't process this invocation
## correctly.  Breaking it into two sed invocations is a workaround.
  tr ' ' "$nl" < "$tmpdepfile" \
    | sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \
    | sed -e 's/$/ :/' >> "$depfile"
  rm -f "$tmpdepfile"
  ;;

hp)
  # This case exists only to let depend.m4 do its work.  It works by
  # looking at the text of this script.  This case will never be run,
  # since it is checked for above.
  exit 1
  ;;

sgi)
  if test "$libtool" = yes; then
    "$@" "-Wp,-MDupdate,$tmpdepfile"
  else
    "$@" -MDupdate "$tmpdepfile"
  fi
  stat=$?
  if test $stat -ne 0; then
    rm -f "$tmpdepfile"
    exit $stat
  fi
  rm -f "$depfile"

  if test -f "$tmpdepfile"; then  # yes, the sourcefile depend on other files
    echo "$object : \\" > "$depfile"
    # Clip off the initial element (the dependent).  Don't try to be
    # clever and replace this with sed code, as IRIX sed won't handle
    # lines with more than a fixed number of characters (4096 in
    # IRIX 6.2 sed, 8192 in IRIX 6.5).  We also remove comment lines;
    # the IRIX cc adds comments like '#:fec' to the end of the
    # dependency line.
    tr ' ' "$nl" < "$tmpdepfile" \
      | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' \
      | tr "$nl" ' ' >> "$depfile"
    echo >> "$depfile"
    # The second pass generates a dummy entry for each header file.
    tr ' ' "$nl" < "$tmpdepfile" \
      | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
      >> "$depfile"
  else
    make_dummy_depfile
  fi
  rm -f "$tmpdepfile"
  ;;

xlc)
  # This case exists only to let depend.m4 do its work.  It works by
  # looking at the text of this script.  This case will never be run,
  # since it is checked for above.
  exit 1
  ;;

aix)
  # The C for AIX Compiler uses -M and outputs the dependencies
  # in a .u file.  In older versions, this file always lives in the
  # current directory.  Also, the AIX compiler puts '$object:' at the
  # start of each line; $object doesn't have directory information.
  # Version 6 uses the directory in both cases.
  set_dir_from "$object"
  set_base_from "$object"
  if test "$libtool" = yes; then
    tmpdepfile1=$dir$base.u
    tmpdepfile2=$base.u
    tmpdepfile3=$dir.libs/$base.u
    "$@" -Wc,-M
  else
    tmpdepfile1=$dir$base.u
    tmpdepfile2=$dir$base.u
    tmpdepfile3=$dir$base.u
    "$@" -M
  fi
  stat=$?
  if test $stat -ne 0; then
    rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
    exit $stat
  fi

  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
  do
    test -f "$tmpdepfile" && break
  done
  aix_post_process_depfile
  ;;

tcc)
  # tcc (Tiny C Compiler) understand '-MD -MF file' since version 0.9.26
  # FIXME: That version still under development at the moment of writing.
  #        Make that this statement remains true also for stable, released
  #        versions.
  # It will wrap lines (doesn't matter whether long or short) with a
  # trailing '\', as in:
  #
  #   foo.o : \
  #    foo.c \
  #    foo.h \
  #
  # It will put a trailing '\' even on the last line, and will use leading
  # spaces rather than leading tabs (at least since its commit 0394caf7
  # "Emit spaces for -MD").
  "$@" -MD -MF "$tmpdepfile"
  stat=$?
  if test $stat -ne 0; then
    rm -f "$tmpdepfile"
    exit $stat
  fi
  rm -f "$depfile"
  # Each non-empty line is of the form 'foo.o : \' or ' dep.h \'.
  # We have to change lines of the first kind to '$object: \'.
  sed -e "s|.*:|$object :|" < "$tmpdepfile" > "$depfile"
  # And for each line of the second kind, we have to emit a 'dep.h:'
  # dummy dependency, to avoid the deleted-header problem.
  sed -n -e 's|^  *\(.*\) *\\$|\1:|p' < "$tmpdepfile" >> "$depfile"
  rm -f "$tmpdepfile"
  ;;

## The order of this option in the case statement is important, since the
## shell code in configure will try each of these formats in the order
## listed in this file.  A plain '-MD' option would be understood by many
## compilers, so we must ensure this comes after the gcc and icc options.
pgcc)
  # Portland's C compiler understands '-MD'.
  # Will always output deps to 'file.d' where file is the root name of the
  # source file under compilation, even if file resides in a subdirectory.
  # The object file name does not affect the name of the '.d' file.
  # pgcc 10.2 will output
  #    foo.o: sub/foo.c sub/foo.h
  # and will wrap long lines using '\' :
  #    foo.o: sub/foo.c ... \
  #     sub/foo.h ... \
  #     ...
  set_dir_from "$object"
  # Use the source, not the object, to determine the base name, since
  # that's sadly what pgcc will do too.
  set_base_from "$source"
  tmpdepfile=$base.d

  # For projects that build the same source file twice into different object
  # files, the pgcc approach of using the *source* file root name can cause
  # problems in parallel builds.  Use a locking strategy to avoid stomping on
  # the same $tmpdepfile.
  lockdir=$base.d-lock
  trap "
    echo '$0: caught signal, cleaning up...' >&2
    rmdir '$lockdir'
    exit 1
  " 1 2 13 15
  numtries=100
  i=$numtries
  while test $i -gt 0; do
    # mkdir is a portable test-and-set.
    if mkdir "$lockdir" 2>/dev/null; then
      # This process acquired the lock.
      "$@" -MD
      stat=$?
      # Release the lock.
      rmdir "$lockdir"
      break
    else
      # If the lock is being held by a different process, wait
      # until the winning process is done or we timeout.
      while test -d "$lockdir" && test $i -gt 0; do
        sleep 1
        i=`expr $i - 1`
      done
    fi
    i=`expr $i - 1`
  done
  trap - 1 2 13 15
  if test $i -le 0; then
    echo "$0: failed to acquire lock after $numtries attempts" >&2
    echo "$0: check lockdir '$lockdir'" >&2
    exit 1
  fi

  if test $stat -ne 0; then
    rm -f "$tmpdepfile"
    exit $stat
  fi
  rm -f "$depfile"
  # Each line is of the form `foo.o: dependent.h',
  # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'.
  # Do two passes, one to just change these to
  # `$object: dependent.h' and one to simply `dependent.h:'.
  sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"
  # Some versions of the HPUX 10.20 sed can't process this invocation
  # correctly.  Breaking it into two sed invocations is a workaround.
  sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" \
    | sed -e 's/$/ :/' >> "$depfile"
  rm -f "$tmpdepfile"
  ;;

hp2)
  # The "hp" stanza above does not work with aCC (C++) and HP's ia64
  # compilers, which have integrated preprocessors.  The correct option
  # to use with these is +Maked; it writes dependencies to a file named
  # 'foo.d', which lands next to the object file, wherever that
  # happens to be.
  # Much of this is similar to the tru64 case; see comments there.
  set_dir_from  "$object"
  set_base_from "$object"
  if test "$libtool" = yes; then
    tmpdepfile1=$dir$base.d
    tmpdepfile2=$dir.libs/$base.d
    "$@" -Wc,+Maked
  else
    tmpdepfile1=$dir$base.d
    tmpdepfile2=$dir$base.d
    "$@" +Maked
  fi
  stat=$?
  if test $stat -ne 0; then
     rm -f "$tmpdepfile1" "$tmpdepfile2"
     exit $stat
  fi

  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2"
  do
    test -f "$tmpdepfile" && break
  done
  if test -f "$tmpdepfile"; then
    sed -e "s,^.*\.[$lower]*:,$object:," "$tmpdepfile" > "$depfile"
    # Add 'dependent.h:' lines.
    sed -ne '2,${
               s/^ *//
               s/ \\*$//
               s/$/:/
               p
             }' "$tmpdepfile" >> "$depfile"
  else
    make_dummy_depfile
  fi
  rm -f "$tmpdepfile" "$tmpdepfile2"
  ;;

tru64)
  # The Tru64 compiler uses -MD to generate dependencies as a side
  # effect.  'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'.
  # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
  # dependencies in 'foo.d' instead, so we check for that too.
  # Subdirectories are respected.
  set_dir_from  "$object"
  set_base_from "$object"

  if test "$libtool" = yes; then
    # Libtool generates 2 separate objects for the 2 libraries.  These
    # two compilations output dependencies in $dir.libs/$base.o.d and
    # in $dir$base.o.d.  We have to check for both files, because
    # one of the two compilations can be disabled.  We should prefer
    # $dir$base.o.d over $dir.libs/$base.o.d because the latter is
    # automatically cleaned when .libs/ is deleted, while ignoring
    # the former would cause a distcleancheck panic.
    tmpdepfile1=$dir$base.o.d          # libtool 1.5
    tmpdepfile2=$dir.libs/$base.o.d    # Likewise.
    tmpdepfile3=$dir.libs/$base.d      # Compaq CCC V6.2-504
    "$@" -Wc,-MD
  else
    tmpdepfile1=$dir$base.d
    tmpdepfile2=$dir$base.d
    tmpdepfile3=$dir$base.d
    "$@" -MD
  fi

  stat=$?
  if test $stat -ne 0; then
    rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
    exit $stat
  fi

  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
  do
    test -f "$tmpdepfile" && break
  done
  # Same post-processing that is required for AIX mode.
  aix_post_process_depfile
  ;;

msvc7)
  if test "$libtool" = yes; then
    showIncludes=-Wc,-showIncludes
  else
    showIncludes=-showIncludes
  fi
  "$@" $showIncludes > "$tmpdepfile"
  stat=$?
  grep -v '^Note: including file: ' "$tmpdepfile"
  if test $stat -ne 0; then
    rm -f "$tmpdepfile"
    exit $stat
  fi
  rm -f "$depfile"
  echo "$object : \\" > "$depfile"
  # The first sed program below extracts the file names and escapes
  # backslashes for cygpath.  The second sed program outputs the file
  # name when reading, but also accumulates all include files in the
  # hold buffer in order to output them again at the end.  This only
  # works with sed implementations that can handle large buffers.
  sed < "$tmpdepfile" -n '
/^Note: including file:  *\(.*\)/ {
  s//\1/
  s/\\/\\\\/g
  p
}' | $cygpath_u | sort -u | sed -n '
s/ /\\ /g
s/\(.*\)/'"$tab"'\1 \\/p
s/.\(.*\) \\/\1:/
H
$ {
  s/.*/'"$tab"'/
  G
  p
}' >> "$depfile"
  echo >> "$depfile" # make sure the fragment doesn't end with a backslash
  rm -f "$tmpdepfile"
  ;;

msvc7msys)
  # This case exists only to let depend.m4 do its work.  It works by
  # looking at the text of this script.  This case will never be run,
  # since it is checked for above.
  exit 1
  ;;

#nosideeffect)
  # This comment above is used by automake to tell side-effect
  # dependency tracking mechanisms from slower ones.

dashmstdout)
  # Important note: in order to support this mode, a compiler *must*
  # always write the preprocessed file to stdout, regardless of -o.
  "$@" || exit $?

  # Remove the call to Libtool.
  if test "$libtool" = yes; then
    while test "X$1" != 'X--mode=compile'; do
      shift
    done
    shift
  fi

  # Remove '-o $object'.
  IFS=" "
  for arg
  do
    case $arg in
    -o)
      shift
      ;;
    $object)
      shift
      ;;
    *)
      set fnord "$@" "$arg"
      shift # fnord
      shift # $arg
      ;;
    esac
  done

  test -z "$dashmflag" && dashmflag=-M
  # Require at least two characters before searching for ':'
  # in the target name.  This is to cope with DOS-style filenames:
  # a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise.
  "$@" $dashmflag |
    sed "s|^[$tab ]*[^:$tab ][^:][^:]*:[$tab ]*|$object: |" > "$tmpdepfile"
  rm -f "$depfile"
  cat < "$tmpdepfile" > "$depfile"
  # Some versions of the HPUX 10.20 sed can't process this sed invocation
  # correctly.  Breaking it into two sed invocations is a workaround.
  tr ' ' "$nl" < "$tmpdepfile" \
    | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
    | sed -e 's/$/ :/' >> "$depfile"
  rm -f "$tmpdepfile"
  ;;

dashXmstdout)
  # This case only exists to satisfy depend.m4.  It is never actually
  # run, as this mode is specially recognized in the preamble.
  exit 1
  ;;

makedepend)
  "$@" || exit $?
  # Remove any Libtool call
  if test "$libtool" = yes; then
    while test "X$1" != 'X--mode=compile'; do
      shift
    done
    shift
  fi
  # X makedepend
  shift
  cleared=no eat=no
  for arg
  do
    case $cleared in
    no)
      set ""; shift
      cleared=yes ;;
    esac
    if test $eat = yes; then
      eat=no
      continue
    fi
    case "$arg" in
    -D*|-I*)
      set fnord "$@" "$arg"; shift ;;
    # Strip any option that makedepend may not understand.  Remove
    # the object too, otherwise makedepend will parse it as a source file.
    -arch)
      eat=yes ;;
    -*|$object)
      ;;
    *)
      set fnord "$@" "$arg"; shift ;;
    esac
  done
  obj_suffix=`echo "$object" | sed 's/^.*\././'`
  touch "$tmpdepfile"
  ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
  rm -f "$depfile"
  # makedepend may prepend the VPATH from the source file name to the object.
  # No need to regex-escape $object, excess matching of '.' is harmless.
  sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile"
  # Some versions of the HPUX 10.20 sed can't process the last invocation
  # correctly.  Breaking it into two sed invocations is a workaround.
  sed '1,2d' "$tmpdepfile" \
    | tr ' ' "$nl" \
    | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
    | sed -e 's/$/ :/' >> "$depfile"
  rm -f "$tmpdepfile" "$tmpdepfile".bak
  ;;

cpp)
  # Important note: in order to support this mode, a compiler *must*
  # always write the preprocessed file to stdout.
  "$@" || exit $?

  # Remove the call to Libtool.
  if test "$libtool" = yes; then
    while test "X$1" != 'X--mode=compile'; do
      shift
    done
    shift
  fi

  # Remove '-o $object'.
  IFS=" "
  for arg
  do
    case $arg in
    -o)
      shift
      ;;
    $object)
      shift
      ;;
    *)
      set fnord "$@" "$arg"
      shift # fnord
      shift # $arg
      ;;
    esac
  done

  "$@" -E \
    | sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
             -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
    | sed '$ s: \\$::' > "$tmpdepfile"
  rm -f "$depfile"
  echo "$object : \\" > "$depfile"
  cat < "$tmpdepfile" >> "$depfile"
  sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
  rm -f "$tmpdepfile"
  ;;

msvisualcpp)
  # Important note: in order to support this mode, a compiler *must*
  # always write the preprocessed file to stdout.
  "$@" || exit $?

  # Remove the call to Libtool.
  if test "$libtool" = yes; then
    while test "X$1" != 'X--mode=compile'; do
      shift
    done
    shift
  fi

  IFS=" "
  for arg
  do
    case "$arg" in
    -o)
      shift
      ;;
    $object)
      shift
      ;;
    "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
        set fnord "$@"
        shift
        shift
        ;;
    *)
        set fnord "$@" "$arg"
        shift
        shift
        ;;
    esac
  done
  "$@" -E 2>/dev/null |
  sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile"
  rm -f "$depfile"
  echo "$object : \\" > "$depfile"
  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile"
  echo "$tab" >> "$depfile"
  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile"
  rm -f "$tmpdepfile"
  ;;

msvcmsys)
  # This case exists only to let depend.m4 do its work.  It works by
  # looking at the text of this script.  This case will never be run,
  # since it is checked for above.
  exit 1
  ;;

none)
  exec "$@"
  ;;

*)
  echo "Unknown depmode $depmode" 1>&2
  exit 1
  ;;
esac

exit 0

# Local Variables:
# mode: shell-script
# sh-indentation: 2
# eval: (add-hook 'before-save-hook 'time-stamp)
# time-stamp-start: "scriptversion="
# time-stamp-format: "%:y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC0"
# time-stamp-end: "; # UTC"
# End:




#!/bin/sh
# install - install a program, script, or datafile

scriptversion=2018-03-11.20; # UTC

# This originates from X11R5 (mit/util/scripts/install.sh), which was
# later released in X11R6 (xc/config/util/install.sh) with the
# following copyright and license.
#
# Copyright (C) 1994 X Consortium
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to
# deal in the Software without restriction, including without limitation the
# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
# sell copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
# Except as contained in this notice, the name of the X Consortium shall not
# be used in advertising or otherwise to promote the sale, use or other deal-
# ings in this Software without prior written authorization from the X Consor-
# tium.
#
#
# FSF changes to this file are in the public domain.
#
# Calling this script install-sh is preferred over install.sh, to prevent
# 'make' implicit rules from creating a file called install from it
# when there is no Makefile.
#
# This script is compatible with the BSD install script, but was written
# from scratch.

tab='	'
nl='
'
IFS=" $tab$nl"

# Set DOITPROG to "echo" to test this script.

doit=${DOITPROG-}
doit_exec=${doit:-exec}

# Put in absolute file names if you don't have them in your path;
# or use environment vars.

chgrpprog=${CHGRPPROG-chgrp}
chmodprog=${CHMODPROG-chmod}
chownprog=${CHOWNPROG-chown}
cmpprog=${CMPPROG-cmp}
cpprog=${CPPROG-cp}
mkdirprog=${MKDIRPROG-mkdir}
mvprog=${MVPROG-mv}
rmprog=${RMPROG-rm}
stripprog=${STRIPPROG-strip}

posix_mkdir=

# Desired mode of installed file.
mode=0755

chgrpcmd=
chmodcmd=$chmodprog
chowncmd=
mvcmd=$mvprog
rmcmd="$rmprog -f"
stripcmd=

src=
dst=
dir_arg=
dst_arg=

copy_on_change=false
is_target_a_directory=possibly

usage="\
Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
   or: $0 [OPTION]... SRCFILES... DIRECTORY
   or: $0 [OPTION]... -t DIRECTORY SRCFILES...
   or: $0 [OPTION]... -d DIRECTORIES...

In the 1st form, copy SRCFILE to DSTFILE.
In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
In the 4th, create DIRECTORIES.

Options:
     --help     display this help and exit.
     --version  display version info and exit.

  -c            (ignored)
  -C            install only if different (preserve the last data modification time)
  -d            create directories instead of installing files.
  -g GROUP      $chgrpprog installed files to GROUP.
  -m MODE       $chmodprog installed files to MODE.
  -o USER       $chownprog installed files to USER.
  -s            $stripprog installed files.
  -t DIRECTORY  install into DIRECTORY.
  -T            report an error if DSTFILE is a directory.

Environment variables override the default commands:
  CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
  RMPROG STRIPPROG
"

while test $# -ne 0; do
  case $1 in
    -c) ;;

    -C) copy_on_change=true;;

    -d) dir_arg=true;;

    -g) chgrpcmd="$chgrpprog $2"
        shift;;

    --help) echo "$usage"; exit $?;;

    -m) mode=$2
        case $mode in
          *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*)
            echo "$0: invalid mode: $mode" >&2
            exit 1;;
        esac
        shift;;

    -o) chowncmd="$chownprog $2"
        shift;;

    -s) stripcmd=$stripprog;;

    -t)
        is_target_a_directory=always
        dst_arg=$2
        # Protect names problematic for 'test' and other utilities.
        case $dst_arg in
          -* | [=\(\)!]) dst_arg=./$dst_arg;;
        esac
        shift;;

    -T) is_target_a_directory=never;;

    --version) echo "$0 $scriptversion"; exit $?;;

    --) shift
        break;;

    -*) echo "$0: invalid option: $1" >&2
        exit 1;;

    *)  break;;
  esac
  shift
done

# We allow the use of options -d and -T together, by making -d
# take the precedence; this is for compatibility with GNU install.

if test -n "$dir_arg"; then
  if test -n "$dst_arg"; then
    echo "$0: target directory not allowed when installing a directory." >&2
    exit 1
  fi
fi

if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
  # When -d is used, all remaining arguments are directories to create.
  # When -t is used, the destination is already specified.
  # Otherwise, the last argument is the destination.  Remove it from $@.
  for arg
  do
    if test -n "$dst_arg"; then
      # $@ is not empty: it contains at least $arg.
      set fnord "$@" "$dst_arg"
      shift # fnord
    fi
    shift # arg
    dst_arg=$arg
    # Protect names problematic for 'test' and other utilities.
    case $dst_arg in
      -* | [=\(\)!]) dst_arg=./$dst_arg;;
    esac
  done
fi

if test $# -eq 0; then
  if test -z "$dir_arg"; then
    echo "$0: no input file specified." >&2
    exit 1
  fi
  # It's OK to call 'install-sh -d' without argument.
  # This can happen when creating conditional directories.
  exit 0
fi

if test -z "$dir_arg"; then
  if test $# -gt 1 || test "$is_target_a_directory" = always; then
    if test ! -d "$dst_arg"; then
      echo "$0: $dst_arg: Is not a directory." >&2
      exit 1
    fi
  fi
fi

if test -z "$dir_arg"; then
  do_exit='(exit $ret); exit $ret'
  trap "ret=129; $do_exit" 1
  trap "ret=130; $do_exit" 2
  trap "ret=141; $do_exit" 13
  trap "ret=143; $do_exit" 15

  # Set umask so as not to create temps with too-generous modes.
  # However, 'strip' requires both read and write access to temps.
  case $mode in
    # Optimize common cases.
    *644) cp_umask=133;;
    *755) cp_umask=22;;

    *[0-7])
      if test -z "$stripcmd"; then
        u_plus_rw=
      else
        u_plus_rw='% 200'
      fi
      cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
    *)
      if test -z "$stripcmd"; then
        u_plus_rw=
      else
        u_plus_rw=,u+rw
      fi
      cp_umask=$mode$u_plus_rw;;
  esac
fi

for src
do
  # Protect names problematic for 'test' and other utilities.
  case $src in
    -* | [=\(\)!]) src=./$src;;
  esac

  if test -n "$dir_arg"; then
    dst=$src
    dstdir=$dst
    test -d "$dstdir"
    dstdir_status=$?
  else

    # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
    # might cause directories to be created, which would be especially bad
    # if $src (and thus $dsttmp) contains '*'.
    if test ! -f "$src" && test ! -d "$src"; then
      echo "$0: $src does not exist." >&2
      exit 1
    fi

    if test -z "$dst_arg"; then
      echo "$0: no destination specified." >&2
      exit 1
    fi
    dst=$dst_arg

    # If destination is a directory, append the input filename.
    if test -d "$dst"; then
      if test "$is_target_a_directory" = never; then
        echo "$0: $dst_arg: Is a directory" >&2
        exit 1
      fi
      dstdir=$dst
      dstbase=`basename "$src"`
      case $dst in
	*/) dst=$dst$dstbase;;
	*)  dst=$dst/$dstbase;;
      esac
      dstdir_status=0
    else
      dstdir=`dirname "$dst"`
      test -d "$dstdir"
      dstdir_status=$?
    fi
  fi

  case $dstdir in
    */) dstdirslash=$dstdir;;
    *)  dstdirslash=$dstdir/;;
  esac

  obsolete_mkdir_used=false

  if test $dstdir_status != 0; then
    case $posix_mkdir in
      '')
        # Create intermediate dirs using mode 755 as modified by the umask.
        # This is like FreeBSD 'install' as of 1997-10-28.
        umask=`umask`
        case $stripcmd.$umask in
          # Optimize common cases.
          *[2367][2367]) mkdir_umask=$umask;;
          .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;

          *[0-7])
            mkdir_umask=`expr $umask + 22 \
              - $umask % 100 % 40 + $umask % 20 \
              - $umask % 10 % 4 + $umask % 2
            `;;
          *) mkdir_umask=$umask,go-w;;
        esac

        # With -d, create the new directory with the user-specified mode.
        # Otherwise, rely on $mkdir_umask.
        if test -n "$dir_arg"; then
          mkdir_mode=-m$mode
        else
          mkdir_mode=
        fi

        posix_mkdir=false
        case $umask in
          *[123567][0-7][0-7])
            # POSIX mkdir -p sets u+wx bits regardless of umask, which
            # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
            ;;
          *)
            # Note that $RANDOM variable is not portable (e.g. dash);  Use it
            # here however when possible just to lower collision chance.
            tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$

            trap 'ret=$?; rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null; exit $ret' 0

            # Because "mkdir -p" follows existing symlinks and we likely work
            # directly in world-writeable /tmp, make sure that the '$tmpdir'
            # directory is successfully created first before we actually test
            # 'mkdir -p' feature.
            if (umask $mkdir_umask &&
                $mkdirprog $mkdir_mode "$tmpdir" &&
                exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1
            then
              if test -z "$dir_arg" || {
                   # Check for POSIX incompatibilities with -m.
                   # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
                   # other-writable bit of parent directory when it shouldn't.
                   # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
                   test_tmpdir="$tmpdir/a"
                   ls_ld_tmpdir=`ls -ld "$test_tmpdir"`
                   case $ls_ld_tmpdir in
                     d????-?r-*) different_mode=700;;
                     d????-?--*) different_mode=755;;
                     *) false;;
                   esac &&
                   $mkdirprog -m$different_mode -p -- "$test_tmpdir" && {
                     ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"`
                     test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
                   }
                 }
              then posix_mkdir=:
              fi
              rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir"
            else
              # Remove any dirs left behind by ancient mkdir implementations.
              rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null
            fi
            trap '' 0;;
        esac;;
    esac

    if
      $posix_mkdir && (
        umask $mkdir_umask &&
        $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
      )
    then :
    else

      # The umask is ridiculous, or mkdir does not conform to POSIX,
      # or it failed possibly due to a race condition.  Create the
      # directory the slow way, step by step, checking for races as we go.

      case $dstdir in
        /*) prefix='/';;
        [-=\(\)!]*) prefix='./';;
        *)  prefix='';;
      esac

      oIFS=$IFS
      IFS=/
      set -f
      set fnord $dstdir
      shift
      set +f
      IFS=$oIFS

      prefixes=

      for d
      do
        test X"$d" = X && continue

        prefix=$prefix$d
        if test -d "$prefix"; then
          prefixes=
        else
          if $posix_mkdir; then
            (umask=$mkdir_umask &&
             $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
            # Don't fail if two instances are running concurrently.
            test -d "$prefix" || exit 1
          else
            case $prefix in
              *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
              *) qprefix=$prefix;;
            esac
            prefixes="$prefixes '$qprefix'"
          fi
        fi
        prefix=$prefix/
      done

      if test -n "$prefixes"; then
        # Don't fail if two instances are running concurrently.
        (umask $mkdir_umask &&
         eval "\$doit_exec \$mkdirprog $prefixes") ||
          test -d "$dstdir" || exit 1
        obsolete_mkdir_used=true
      fi
    fi
  fi

  if test -n "$dir_arg"; then
    { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
    { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
      test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
  else

    # Make a couple of temp file names in the proper directory.
    dsttmp=${dstdirslash}_inst.$$_
    rmtmp=${dstdirslash}_rm.$$_

    # Trap to clean up those temp files at exit.
    trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0

    # Copy the file name to the temp name.
    (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&

    # and set any options; do chmod last to preserve setuid bits.
    #
    # If any of these fail, we abort the whole thing.  If we want to
    # ignore errors from any of these, just make sure not to ignore
    # errors from the above "$doit $cpprog $src $dsttmp" command.
    #
    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
    { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
    { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&

    # If -C, don't bother to copy if it wouldn't change the file.
    if $copy_on_change &&
       old=`LC_ALL=C ls -dlL "$dst"     2>/dev/null` &&
       new=`LC_ALL=C ls -dlL "$dsttmp"  2>/dev/null` &&
       set -f &&
       set X $old && old=:$2:$4:$5:$6 &&
       set X $new && new=:$2:$4:$5:$6 &&
       set +f &&
       test "$old" = "$new" &&
       $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
    then
      rm -f "$dsttmp"
    else
      # Rename the file to the real destination.
      $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||

      # The rename failed, perhaps because mv can't rename something else
      # to itself, or perhaps because mv is so ancient that it does not
      # support -f.
      {
        # Now remove or move aside any old file at destination location.
        # We try this two ways since rm can't unlink itself on some
        # systems and the destination file might be busy for other
        # reasons.  In this case, the final cleanup might fail but the new
        # file should still install successfully.
        {
          test ! -f "$dst" ||
          $doit $rmcmd -f "$dst" 2>/dev/null ||
          { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
            { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
          } ||
          { echo "$0: cannot unlink or rename $dst" >&2
            (exit 1); exit 1
          }
        } &&

        # Now rename the file to the real destination.
        $doit $mvcmd "$dsttmp" "$dst"
      }
    fi || exit 1

    trap '' 0
  fi
done

# Local variables:
# eval: (add-hook 'before-save-hook 'time-stamp)
# time-stamp-start: "scriptversion="
# time-stamp-format: "%:y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC0"
# time-stamp-end: "; # UTC"
# End:




#! /bin/sh
# Common wrapper for a few potentially missing GNU programs.

scriptversion=2018-03-07.03; # UTC

# Copyright (C) 1996-2018 Free Software Foundation, Inc.
# Originally written by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.

# 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, see <https://www.gnu.org/licenses/>.

# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.

if test $# -eq 0; then
  echo 1>&2 "Try '$0 --help' for more information"
  exit 1
fi

case $1 in

  --is-lightweight)
    # Used by our autoconf macros to check whether the available missing
    # script is modern enough.
    exit 0
    ;;

  --run)
    # Back-compat with the calling convention used by older automake.
    shift
    ;;

  -h|--h|--he|--hel|--help)
    echo "\
$0 [OPTION]... PROGRAM [ARGUMENT]...

Run 'PROGRAM [ARGUMENT]...', returning a proper advice when this fails due
to PROGRAM being missing or too old.

Options:
  -h, --help      display this help and exit
  -v, --version   output version information and exit

Supported PROGRAM values:
  aclocal   autoconf  autoheader   autom4te  automake  makeinfo
  bison     yacc      flex         lex       help2man

Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and
'g' are ignored when checking the name.

Send bug reports to <bug-automake@gnu.org>."
    exit $?
    ;;

  -v|--v|--ve|--ver|--vers|--versi|--versio|--version)
    echo "missing $scriptversion (GNU Automake)"
    exit $?
    ;;

  -*)
    echo 1>&2 "$0: unknown '$1' option"
    echo 1>&2 "Try '$0 --help' for more information"
    exit 1
    ;;

esac

# Run the given program, remember its exit status.
"$@"; st=$?

# If it succeeded, we are done.
test $st -eq 0 && exit 0

# Also exit now if we it failed (or wasn't found), and '--version' was
# passed; such an option is passed most likely to detect whether the
# program is present and works.
case $2 in --version|--help) exit $st;; esac

# Exit code 63 means version mismatch.  This often happens when the user
# tries to use an ancient version of a tool on a file that requires a
# minimum version.
if test $st -eq 63; then
  msg="probably too old"
elif test $st -eq 127; then
  # Program was missing.
  msg="missing on your system"
else
  # Program was found and executed, but failed.  Give up.
  exit $st
fi

perl_URL=https://www.perl.org/
flex_URL=https://github.com/westes/flex
gnu_software_URL=https://www.gnu.org/software

program_details ()
{
  case $1 in
    aclocal|automake)
      echo "The '$1' program is part of the GNU Automake package:"
      echo "<$gnu_software_URL/automake>"
      echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:"
      echo "<$gnu_software_URL/autoconf>"
      echo "<$gnu_software_URL/m4/>"
      echo "<$perl_URL>"
      ;;
    autoconf|autom4te|autoheader)
      echo "The '$1' program is part of the GNU Autoconf package:"
      echo "<$gnu_software_URL/autoconf/>"
      echo "It also requires GNU m4 and Perl in order to run:"
      echo "<$gnu_software_URL/m4/>"
      echo "<$perl_URL>"
      ;;
  esac
}

give_advice ()
{
  # Normalize program name to check for.
  normalized_program=`echo "$1" | sed '
    s/^gnu-//; t
    s/^gnu//; t
    s/^g//; t'`

  printf '%s\n' "'$1' is $msg."

  configure_deps="'configure.ac' or m4 files included by 'configure.ac'"
  case $normalized_program in
    autoconf*)
      echo "You should only need it if you modified 'configure.ac',"
      echo "or m4 files included by it."
      program_details 'autoconf'
      ;;
    autoheader*)
      echo "You should only need it if you modified 'acconfig.h' or"
      echo "$configure_deps."
      program_details 'autoheader'
      ;;
    automake*)
      echo "You should only need it if you modified 'Makefile.am' or"
      echo "$configure_deps."
      program_details 'automake'
      ;;
    aclocal*)
      echo "You should only need it if you modified 'acinclude.m4' or"
      echo "$configure_deps."
      program_details 'aclocal'
      ;;
   autom4te*)
      echo "You might have modified some maintainer files that require"
      echo "the 'autom4te' program to be rebuilt."
      program_details 'autom4te'
      ;;
    bison*|yacc*)
      echo "You should only need it if you modified a '.y' file."
      echo "You may want to install the GNU Bison package:"
      echo "<$gnu_software_URL/bison/>"
      ;;
    lex*|flex*)
      echo "You should only need it if you modified a '.l' file."
      echo "You may want to install the Fast Lexical Analyzer package:"
      echo "<$flex_URL>"
      ;;
    help2man*)
      echo "You should only need it if you modified a dependency" \
           "of a man page."
      echo "You may want to install the GNU Help2man package:"
      echo "<$gnu_software_URL/help2man/>"
    ;;
    makeinfo*)
      echo "You should only need it if you modified a '.texi' file, or"
      echo "any other file indirectly affecting the aspect of the manual."
      echo "You might want to install the Texinfo package:"
      echo "<$gnu_software_URL/texinfo/>"
      echo "The spurious makeinfo call might also be the consequence of"
      echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might"
      echo "want to install GNU make:"
      echo "<$gnu_software_URL/make/>"
      ;;
    *)
      echo "You might have modified some files without having the proper"
      echo "tools for further handling them.  Check the 'README' file, it"
      echo "often tells you about the needed prerequisites for installing"
      echo "this package.  You may also peek at any GNU archive site, in"
      echo "case some other package contains this missing '$1' program."
      ;;
  esac
}

give_advice "$1" | sed -e '1s/^/WARNING: /' \
                       -e '2,$s/^/         /' >&2

# Propagate the correct exit status (expected to be 127 for a program
# not found, 63 for a program that failed due to version mismatch).
exit $st

# Local variables:
# eval: (add-hook 'before-save-hook 'time-stamp)
# time-stamp-start: "scriptversion="
# time-stamp-format: "%:y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC0"
# time-stamp-end: "; # UTC"
# End:




/* config.h.  Generated from config.h.in by configure.  */
/* config.h.in.  Generated from configure.ac by autoheader.  */

/* Define to 1 if you have the <arpa/inet.h> header file. */
#define HAVE_ARPA_INET_H 1

/* Define to 1 if you have the `dup2' function. */
#define HAVE_DUP2 1

/* Define to 1 if you have the <fcntl.h> header file. */
#define HAVE_FCNTL_H 1

/* Define to 1 if you have the `fork' function. */
#define HAVE_FORK 1

/* Define to 1 if you have the <inttypes.h> header file. */
#define HAVE_INTTYPES_H 1

/* Define to 1 if you have the `nsl' library (-lnsl). */
/* #undef HAVE_LIBNSL */

/* Define to 1 if you have the `pthread' library (-lpthread). */
#define HAVE_LIBPTHREAD 1

/* Define to 1 if you have the `socket' library (-lsocket). */
/* #undef HAVE_LIBSOCKET */

/* Define to 1 if your system has a GNU libc compatible `malloc' function, and
   to 0 otherwise. */
#define HAVE_MALLOC 1

/* Define to 1 if you have the <memory.h> header file. */
#define HAVE_MEMORY_H 1

/* Define to 1 if you have the `memset' function. */
#define HAVE_MEMSET 1

/* Define to 1 if you have the <netdb.h> header file. */
#define HAVE_NETDB_H 1

/* Define to 1 if you have the <netinet/in.h> header file. */
#define HAVE_NETINET_IN_H 1

/* Define to 1 if your system has a GNU libc compatible `realloc' function,
   and to 0 otherwise. */
#define HAVE_REALLOC 1

/* Define to 1 if you have the `socket' function. */
#define HAVE_SOCKET 1

/* Define to 1 if you have the <stdint.h> header file. */
#define HAVE_STDINT_H 1

/* Define to 1 if you have the <stdlib.h> header file. */
#define HAVE_STDLIB_H 1

/* Define to 1 if you have the `strchr' function. */
#define HAVE_STRCHR 1

/* Define to 1 if you have the `strdup' function. */
#define HAVE_STRDUP 1

/* Define to 1 if you have the `strerror' function. */
#define HAVE_STRERROR 1

/* Define to 1 if you have the <strings.h> header file. */
#define HAVE_STRINGS_H 1

/* Define to 1 if you have the <string.h> header file. */
#define HAVE_STRING_H 1

/* Define to 1 if you have the <syslog.h> header file. */
#define HAVE_SYSLOG_H 1

/* Define to 1 if you have the <sys/socket.h> header file. */
#define HAVE_SYS_SOCKET_H 1

/* Define to 1 if you have the <sys/stat.h> header file. */
#define HAVE_SYS_STAT_H 1

/* Define to 1 if you have the <sys/types.h> header file. */
#define HAVE_SYS_TYPES_H 1

/* Define to 1 if you have the <unistd.h> header file. */
#define HAVE_UNISTD_H 1

/* Define to 1 if you have the `vfork' function. */
#define HAVE_VFORK 1

/* Define to 1 if you have the <vfork.h> header file. */
/* #undef HAVE_VFORK_H */

/* Define to 1 if `fork' works. */
#define HAVE_WORKING_FORK 1

/* Define to 1 if `vfork' works. */
#define HAVE_WORKING_VFORK 1

/* Define to the address where bug reports for this package should be sent. */
#define PACKAGE_BUGREPORT "pen@lysator.liu.se"

/* Define to the full name of this package. */
#define PACKAGE_NAME "pwol"

/* Define to the full name and version of this package. */
#define PACKAGE_STRING "pwol 1.5"

/* Define to the one symbol short name of this package. */
#define PACKAGE_TARNAME "pwol"

/* Define to the home page for this package. */
#define PACKAGE_URL "https://github.com/ptrrkssn/pwol"

/* Define to the version of this package. */
#define PACKAGE_VERSION "1.5"

/* Define to 1 if you have the ANSI C header files. */
#define STDC_HEADERS 1

/* Define to rpl_malloc if the replacement function should be used. */
/* #undef malloc */

/* Define to `int' if <sys/types.h> does not define. */
/* #undef pid_t */

/* Define to rpl_realloc if the replacement function should be used. */
/* #undef realloc */

/* Define to `unsigned int' if <sys/types.h> does not define. */
/* #undef size_t */

/* Define to `int' if <sys/types.h> does not define. */
/* #undef ssize_t */

/* Define as `fork' if `vfork' does not work. */
/* #undef vfork */




/* config.h.in.  Generated from configure.ac by autoheader.  */

/* Define to 1 if you have the <arpa/inet.h> header file. */
#undef HAVE_ARPA_INET_H

/* Define to 1 if you have the `dup2' function. */
#undef HAVE_DUP2

/* Define to 1 if you have the <fcntl.h> header file. */
#undef HAVE_FCNTL_H

/* Define to 1 if you have the `fork' function. */
#undef HAVE_FORK

/* Define to 1 if you have the <inttypes.h> header file. */
#undef HAVE_INTTYPES_H

/* Define to 1 if you have the `nsl' library (-lnsl). */
#undef HAVE_LIBNSL

/* Define to 1 if you have the `pthread' library (-lpthread). */
#undef HAVE_LIBPTHREAD

/* Define to 1 if you have the `socket' library (-lsocket). */
#undef HAVE_LIBSOCKET

/* Define to 1 if your system has a GNU libc compatible `malloc' function, and
   to 0 otherwise. */
#undef HAVE_MALLOC

/* Define to 1 if you have the <memory.h> header file. */
#undef HAVE_MEMORY_H

/* Define to 1 if you have the `memset' function. */
#undef HAVE_MEMSET

/* Define to 1 if you have the <netdb.h> header file. */
#undef HAVE_NETDB_H

/* Define to 1 if you have the <netinet/in.h> header file. */
#undef HAVE_NETINET_IN_H

/* Define to 1 if your system has a GNU libc compatible `realloc' function,
   and to 0 otherwise. */
#undef HAVE_REALLOC

/* Define to 1 if you have the `socket' function. */
#undef HAVE_SOCKET

/* Define to 1 if you have the <stdint.h> header file. */
#undef HAVE_STDINT_H

/* Define to 1 if you have the <stdlib.h> header file. */
#undef HAVE_STDLIB_H

/* Define to 1 if you have the `strchr' function. */
#undef HAVE_STRCHR

/* Define to 1 if you have the `strdup' function. */
#undef HAVE_STRDUP

/* Define to 1 if you have the `strerror' function. */
#undef HAVE_STRERROR

/* Define to 1 if you have the <strings.h> header file. */
#undef HAVE_STRINGS_H

/* Define to 1 if you have the <string.h> header file. */
#undef HAVE_STRING_H

/* Define to 1 if you have the <syslog.h> header file. */
#undef HAVE_SYSLOG_H

/* Define to 1 if you have the <sys/socket.h> header file. */
#undef HAVE_SYS_SOCKET_H

/* Define to 1 if you have the <sys/stat.h> header file. */
#undef HAVE_SYS_STAT_H

/* Define to 1 if you have the <sys/types.h> header file. */
#undef HAVE_SYS_TYPES_H

/* Define to 1 if you have the <unistd.h> header file. */
#undef HAVE_UNISTD_H

/* Define to 1 if you have the `vfork' function. */
#undef HAVE_VFORK

/* Define to 1 if you have the <vfork.h> header file. */
#undef HAVE_VFORK_H

/* Define to 1 if `fork' works. */
#undef HAVE_WORKING_FORK

/* Define to 1 if `vfork' works. */
#undef HAVE_WORKING_VFORK

/* Define to the address where bug reports for this package should be sent. */
#undef PACKAGE_BUGREPORT

/* Define to the full name of this package. */
#undef PACKAGE_NAME

/* Define to the full name and version of this package. */
#undef PACKAGE_STRING

/* Define to the one symbol short name of this package. */
#undef PACKAGE_TARNAME

/* Define to the home page for this package. */
#undef PACKAGE_URL

/* Define to the version of this package. */
#undef PACKAGE_VERSION

/* Define to 1 if you have the ANSI C header files. */
#undef STDC_HEADERS

/* Define to rpl_malloc if the replacement function should be used. */
#undef malloc

/* Define to `int' if <sys/types.h> does not define. */
#undef pid_t

/* Define to rpl_realloc if the replacement function should be used. */
#undef realloc

/* Define to `unsigned int' if <sys/types.h> does not define. */
#undef size_t

/* Define to `int' if <sys/types.h> does not define. */
#undef ssize_t

/* Define as `fork' if `vfork' does not work. */
#undef vfork




This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.

It was created by pwol configure 1.5, which was
generated by GNU Autoconf 2.69.  Invocation command line was

  $ ./configure --prefix=/usr/local --localstatedir=/var --mandir=/usr/local/man --infodir=/usr/local/share/info/ --build=amd64-portbld-freebsd11.3

## --------- ##
## Platform. ##
## --------- ##

hostname = filur00
uname -m = amd64
uname -r = 11.3-RELEASE-p10
uname -s = FreeBSD
uname -v = FreeBSD 11.3-RELEASE-p10 #0: Tue Jun  9 08:49:05 UTC 2020     root@amd64-builder.daemonology.net:/usr/obj/usr/src/sys/GENERIC 

/usr/bin/uname -p = amd64
/bin/uname -X     = unknown

/bin/arch              = unknown
/usr/bin/arch -k       = unknown
/usr/convex/getsysinfo = unknown
/usr/bin/hostinfo      = unknown
/bin/machine           = unknown
/usr/bin/oslevel       = unknown
/bin/universe          = unknown

PATH: /usr/ports/sysutils/pwol/work/.bin
PATH: /sbin
PATH: /bin
PATH: /usr/sbin
PATH: /usr/bin
PATH: /usr/local/sbin
PATH: /usr/local/bin
PATH: /root/bin


## ----------- ##
## Core tests. ##
## ----------- ##

configure:2049: loading site script /usr/ports/Templates/config.site
| # $FreeBSD: head/Templates/config.site 535001 2020-05-12 18:15:06Z antoine $
| # Do not add:
| #	- toolchain related
| #	- arch-dependent values
| #	- anything "=no" unless guaranteed to never be
| #	  implemented in FreeBSD
| #	- also avoid "working" values
| # This file must reflect the oldest supported Release.
| #
| #MAINTAINER=	portmgr@FreeBSD.org
| 
| # Path
| : ${ac_cv_path_BZIP2=/usr/bin/bzip2}
| : ${ac_cv_path_EGREP=/usr/bin/egrep}
| : ${ac_cv_path_FGREP=/usr/bin/fgrep}
| : ${ac_cv_path_GREP=/usr/bin/grep}
| : ${ac_cv_path_GZIP=/usr/bin/gzip}
| : ${ac_cv_path_MKTEMP_COMMAND=/usr/bin/mktemp}
| : ${ac_cv_path_SED=/usr/bin/sed}
| : ${ac_cv_path_install=/usr/bin/install}
| : ${ac_cv_path_mkdir=/bin/mkdir}
| : ${ac_cv_prog_AWK=/usr/bin/awk}
| : ${ac_cv_prog_SED=/usr/bin/sed}
| : ${am_cv_prog_tar_ustar=/usr/bin/tar}
| : ${cl_cv_prog_LN=/bin/ln}
| : ${cl_cv_prog_cp='/bin/cp -p'}
| : ${lt_cv_path_MAGIC_CMD=/usr/bin/file}
| 
| # Headers
| : ${ac_cv_header_alloca_h=no}
| : ${ac_cv_header_arpa_inet_h=yes}
| : ${ac_cv_header_arpa_nameser_h=yes}
| : ${ac_cv_header_ctype_h=yes}
| : ${ac_cv_header_dirent_h=yes}
| : ${ac_cv_header_dlfcn_h=yes}
| : ${ac_cv_header_elf_h=yes}
| : ${ac_cv_header_err_h=yes}
| : ${ac_cv_header_errno_h=yes}
| : ${ac_cv_header_fcntl_h=yes}
| : ${ac_cv_header_float_h=yes}
| : ${ac_cv_header_floatingpoint_h=yes}
| : ${ac_cv_header_getopt_h=yes}
| : ${ac_cv_header_glob_h=yes}
| : ${ac_cv_header_inttypes_h=yes}
| : ${ac_cv_header_langinfo_h=yes}
| : ${ac_cv_header_libgen_h=yes}
| : ${ac_cv_header_libutil_h=yes}
| : ${ac_cv_header_limits_h=yes}
| : ${ac_cv_header_locale_h=yes}
| : ${ac_cv_header_login_cap_h=yes}
| : ${ac_cv_header_math_h=yes}
| : ${ac_cv_header_memory_h=yes}
| : ${ac_cv_header_minix_config_h=no}
| : ${ac_cv_header_net_if_h=yes}
| : ${ac_cv_header_net_if_media_h=yes}
| : ${ac_cv_header_net_if_tap_h=yes}
| : ${ac_cv_header_net_if_tun_h=yes}
| : ${ac_cv_header_netdb_h=yes}
| : ${ac_cv_header_netinet_in_h=yes}
| : ${ac_cv_header_paths_h=yes}
| : ${ac_cv_header_poll_h=yes}
| : ${ac_cv_header_pthread_h=yes}
| : ${ac_cv_header_pwd_h=yes}
| : ${ac_cv_header_readpassphrase_h=yes}
| : ${ac_cv_header_resolv_h=yes}
| : ${ac_cv_header_rpc_types_h=yes}
| : ${ac_cv_header_sched_h=yes}
| : ${ac_cv_header_search_h=yes}
| : ${ac_cv_header_security_pam_appl_h=yes}
| : ${ac_cv_header_signal_h=yes}
| : ${ac_cv_header_spawn_h=yes}
| : ${ac_cv_header_stdarg_h=yes}
| : ${ac_cv_header_stdbool_h=yes}
| : ${ac_cv_header_stdc=yes}
| : ${ac_cv_header_stddef_h=yes}
| : ${ac_cv_header_stdint_h=yes}
| : ${ac_cv_header_stdio_h=yes}
| : ${ac_cv_header_stdlib_h=yes}
| : ${ac_cv_header_string_h=yes}
| : ${ac_cv_header_strings_h=yes}
| : ${ac_cv_header_sys_acl_h=yes}
| : ${ac_cv_header_sys_cdefs_h=yes}
| : ${ac_cv_header_sys_fcntl_h=yes}
| : ${ac_cv_header_sys_file_h=yes}
| : ${ac_cv_header_sys_ioctl_h=yes}
| : ${ac_cv_header_sys_mman_h=yes}
| : ${ac_cv_header_sys_mount_h=yes}
| : ${ac_cv_header_sys_msg_h=yes}
| : ${ac_cv_header_sys_param_h=yes}
| : ${ac_cv_header_sys_poll_h=yes}
| : ${ac_cv_header_sys_ptrace_h=yes}
| : ${ac_cv_header_sys_resource_h=yes}
| : ${ac_cv_header_sys_select_h=yes}
| : ${ac_cv_header_sys_socket_h=yes}
| : ${ac_cv_header_sys_stat_h=yes}
| : ${ac_cv_header_sys_statvfs_h=yes}
| : ${ac_cv_header_sys_sysctl_h=yes}
| : ${ac_cv_header_sys_time_h=yes}
| : ${ac_cv_header_sys_timers_h=yes}
| : ${ac_cv_header_sys_times_h=yes}
| : ${ac_cv_header_sys_types_h=yes}
| : ${ac_cv_header_sys_uio_h=yes}
| : ${ac_cv_header_sys_un_h=yes}
| : ${ac_cv_header_sys_wait_h=yes}
| : ${ac_cv_header_time_h=yes}
| : ${ac_cv_header_ttyent_h=yes}
| : ${ac_cv_header_ucontext_h=yes}
| : ${ac_cv_header_unistd_h=yes}
| : ${ac_cv_header_utime_h=yes}
| : ${ac_cv_header_utmpx_h=yes}
| : ${ac_cv_header_utmp_h=no}
| : ${ac_cv_header_vis_h=yes}
| : ${ac_cv_header_wchar_h=yes}
| : ${ac_cv_header_wctype_h=yes}
| : ${ac_cv_header_zlib_h=yes}
| 
| : ${gl_cv_header_wchar_h_correct_inline=yes}
| 
| : ${ac_cv_header_argz_h=no}
| : ${ac_cv_header_byteswap_h=no}
| : ${ac_cv_header_dl_h=no}
| : ${ac_cv_header_random_h=no}
| : ${ac_cv_header_vfork_h=no}
| 
| : ${gl_cv_have_raw_decl_strchrnul=yes}
| : ${gl_cv_have_raw_decl_memcpy=no}
| : ${gl_cv_have_raw_decl_memmem=yes}
| : ${gl_cv_have_raw_decl_memrchr=yes}
| : ${gl_cv_have_raw_decl_rawmemchr=yes}
| : ${gl_cv_have_raw_decl_stpcpy=yes}
| : ${gl_cv_have_raw_decl_stpncpy=yes}
| : ${gl_cv_have_raw_decl_strcasestr=yes}
| : ${gl_cv_have_raw_decl_strdup=yes}
| : ${gl_cv_have_raw_decl_strncat=yes}
| : ${gl_cv_have_raw_decl_strndup=yes}
| : ${gl_cv_have_raw_decl_strnlen=yes}
| : ${gl_cv_have_raw_decl_strpbrk=yes}
| : ${gl_cv_have_raw_decl_strsep=yes}
| : ${gl_cv_have_raw_decl_strsignal=yes}
| : ${gl_cv_have_raw_decl_strtok_r=yes}
| : ${gl_cv_have_raw_decl_strverscmp=no}
| 
| # Type
| : ${ac_cv_c_int16_t=yes}
| : ${ac_cv_c_int32_t=yes}
| : ${ac_cv_c_int64_t=yes}
| : ${ac_cv_c_int8_t=yes}
| : ${ac_cv_c_uint16_t=yes}
| : ${ac_cv_c_uint32_t=yes}
| : ${ac_cv_c_uint64_t=yes}
| : ${ac_cv_c_uint8_t=yes}
| 
| : ${ac_cv_type__Bool=yes}
| : ${ac_cv_type_char=yes}
| : ${ac_cv_type_char_p=yes}
| : ${ac_cv_type_fsblkcnt_t=yes}
| : ${ac_cv_type_fsfilcnt_t=yes}
| : ${ac_cv_type_in_addr_t=yes}
| : ${ac_cv_type_in_port_t=yes}
| : ${ac_cv_type_int16_t=yes}
| : ${ac_cv_type_int32_t=yes}
| : ${ac_cv_type_int=yes}
| : ${ac_cv_type_intmax_t=yes}
| : ${ac_cv_type_long=yes}
| : ${ac_cv_type_long_double=yes}
| : ${ac_cv_type_long_long=yes}
| : ${ac_cv_type_long_long_int=yes}
| : ${ac_cv_type_mbstate_t=yes}
| : ${ac_cv_type_mode_t=yes}
| : ${ac_cv_type_nlink_t=yes}
| : ${ac_cv_type_off_t=yes}
| : ${ac_cv_type_pid_t=yes}
| : ${ac_cv_type_posix_spawn_file_actions_t=yes}
| : ${ac_cv_type_posix_spawnattr_t=yes}
| : ${ac_cv_type_ptrdiff_t=yes}
| : ${ac_cv_type_short=yes}
| : ${ac_cv_type_sig_atomic_t=yes}
| : ${ac_cv_type_sigset_t=yes}
| : ${ac_cv_type_size_t=yes}
| : ${ac_cv_type_socklen_t=yes}
| : ${ac_cv_type_ssize_t=yes}
| : ${ac_cv_type_stack_t=yes}
| : ${ac_cv_type_struct_timespec=yes}
| : ${ac_cv_type_u_char=yes}
| : ${ac_cv_type_u_int16_t=yes}
| : ${ac_cv_type_u_int32_t=yes}
| : ${ac_cv_type_u_int8_t=yes}
| : ${ac_cv_type_u_int=yes}
| : ${ac_cv_type_u_long=yes}
| : ${ac_cv_type_u_short=yes}
| : ${ac_cv_type_uid_t=yes}
| : ${ac_cv_type_uintptr_t=yes}
| : ${ac_cv_type_unsigned_char=yes}
| : ${ac_cv_type_unsigned_int=yes}
| : ${ac_cv_type_unsigned_long=yes}
| : ${ac_cv_type_unsigned_long_long=yes}
| : ${ac_cv_type_unsigned_long_long_int=yes}
| : ${ac_cv_type_unsigned_short=yes}
| : ${ac_cv_type_volatile_sig_atomic_t=yes}
| : ${ac_cv_type_wchar_t=yes}
| : ${ac_cv_type_wint_t=yes}
| 
| : ${gl_cv_sigaltstack_low_base=yes}
| : ${gl_cv_size_max=yes}
| : ${gl_cv_type_sigset_t=yes}
| : ${gl_cv_type_wchar_t_signed=yes}
| : ${gl_cv_type_wctrans_t=yes}
| : ${gl_cv_type_wctype_t=yes}
| : ${gl_cv_type_wint_t_signed=yes}
| : ${gl_cv_var_stdin_large_offset=yes}
| : ${gt_cv_c_intmax_t=yes}
| : ${gt_cv_c_wchar_t=yes}
| : ${gt_cv_c_wint_t=yes}
| : ${gt_cv_func_printf_posix=yes}
| : ${gt_cv_int_divbyzero_sigfpe=yes}
| : ${gt_cv_siginfo_t=yes}
| : ${gt_cv_ssize_t=yes}
| 
| # lib
| : ${ac_cv_lib_crypt_crypt=yes}
| : ${ac_cv_lib_edit_el_init=yes}
| : ${ac_cv_lib_pam_pam_set_item=yes}
| : ${ac_cv_lib_z_deflate=yes}
| : ${ac_cv_libc_defines___progname=yes}
| : ${ac_cv_libc_defines_sys_errlist=yes}
| : ${ac_cv_libc_defines_sys_nerr=yes}
| 
| # Struct
| : ${ac_cv_member_HEADER_ad=yes}
| : ${ac_cv_member_struct___res_state_retrans=yes}
| : ${ac_cv_member_struct_sigaction_sa_sigaction=yes}
| : ${ac_cv_member_struct_sockaddr_in6_sin6_scope_id=yes}
| : ${ac_cv_member_struct_stat_st_blksize=yes}
| 
| : ${gl_cv_sys_struct_timespec_in_time_h=yes}
| : ${gl_cv_sys_struct_timeval=yes}
| 
| : ${ac_cv_func_strchrnul=yes}
| : ${ac_cv_func_uselocale=yes}
| : ${ac_cv_func_newlocale=yes}
| 
| # Functions
| : ${ac_cv_func___b64_ntop=yes}
| : ${ac_cv_func___b64_pton=yes}
| : ${ac_cv_func__getlong=yes}
| : ${ac_cv_func__getshort=yes}
| : ${ac_cv_func__getshort=yes}
| : ${ac_cv_func__stat=yes}
| : ${ac_cv_func_abs=yes}
| : ${ac_cv_func_accept=yes}
| : ${ac_cv_func_accept4=yes}
| : ${ac_cv_func_acl_create_entry_np=yes}
| : ${ac_cv_func_acl_delete_def_file=yes}
| : ${ac_cv_func_acl_delete_fd_np=yes}
| : ${ac_cv_func_acl_delete_file_np=yes}
| : ${ac_cv_func_acl_free=yes}
| : ${ac_cv_func_acl_from_text=yes}
| : ${ac_cv_func_acl_get_fd=yes}
| : ${ac_cv_func_acl_get_file=yes}
| : ${ac_cv_func_acl_set_fd=yes}
| : ${ac_cv_func_acl_set_file=yes}
| : ${ac_cv_func_alarm=yes}
| : ${ac_cv_func_alloca=yes}
| : ${ac_cv_func_alphasort=yes}
| : ${ac_cv_func_arc4random=yes}
| : ${ac_cv_func_arc4random_buf=yes}
| : ${ac_cv_func_arc4random_uniform=yes}
| : ${ac_cv_func_asprintf=yes}
| : ${ac_cv_func_atexit=yes}
| : ${ac_cv_func_atoll=yes}
| : ${ac_cv_func_basename=yes}
| : ${ac_cv_func_bcmp=yes}
| : ${ac_cv_func_bcopy=yes}
| : ${ac_cv_func_bindresvport_sa=yes}
| : ${ac_cv_func_bsearch=yes}
| : ${ac_cv_func_btowc=yes}
| : ${ac_cv_func_bzero=yes}
| : ${ac_cv_func_calloc=yes}
| : ${ac_cv_func_chown=yes}
| : ${ac_cv_func_clock=yes}
| : ${ac_cv_func_clock_gettime=yes}
| : ${ac_cv_func_closedir=yes}
| : ${ac_cv_func_closefrom=yes}
| : ${ac_cv_func_daemon=yes}
| : ${ac_cv_func_dirfd=yes}
| : ${ac_cv_func_dirname=yes}
| : ${ac_cv_func_dlopen=yes}
| : ${ac_cv_func_dprintf=yes}
| : ${ac_cv_func_dup2=yes}
| : ${ac_cv_func_eaccess=yes}
| : ${ac_cv_func_endgrent=yes}
| : ${ac_cv_func_err=yes}
| : ${ac_cv_func_errx=yes}
| : ${ac_cv_func_fchmod=yes}
| : ${ac_cv_func_fchown=yes}
| : ${ac_cv_func_fcntl=yes}
| : ${ac_cv_func_ffs=yes}
| : ${ac_cv_func_ffsl=yes}
| : ${ac_cv_func_ffsll=yes}
| : ${ac_cv_func_fileno=yes}
| : ${ac_cv_func_fls=yes}
| : ${ac_cv_func_flsl=yes}
| : ${ac_cv_func_flsll=yes}
| : ${ac_cv_func_fork=yes}
| : ${ac_cv_func_fork_working=yes}
| : ${ac_cv_func_fprintf=yes}
| : ${ac_cv_func_fpurge=yes}
| : ${ac_cv_func_freeaddrinfo=yes}
| : ${ac_cv_func_fstat=yes}
| : ${ac_cv_func_fstatat=yes}
| : ${ac_cv_func_fstatfs=yes}
| : ${ac_cv_func_fstatvfs=yes}
| : ${ac_cv_func_fsync=yes}
| : ${ac_cv_func_futimes=yes}
| : ${ac_cv_func_fwprintf=yes}
| : ${ac_cv_func_gai_strerror=yes}
| : ${ac_cv_func_getaddrinfo=yes}
| : ${ac_cv_func_getcwd=yes}
| : ${ac_cv_func_getdelim=yes}
| : ${ac_cv_func_getdtablesize=yes}
| : ${ac_cv_func_getgrent=yes}
| : ${ac_cv_func_getegid=yes}
| : ${ac_cv_func_getenv=yes}
| : ${ac_cv_func_geteuid=yes}
| : ${ac_cv_func_getgid=yes}
| : ${ac_cv_func_getgrouplist=yes}
| : ${ac_cv_func_gethostbyname=yes}
| : ${ac_cv_func_gethostname=yes}
| : ${ac_cv_func_getline=yes}
| : ${ac_cv_func_getnameinfo=yes}
| : ${ac_cv_func_getopt=yes}
| : ${ac_cv_func_getopt_long_only=yes}
| : ${ac_cv_func_getpagesize=yes}
| : ${ac_cv_func_getpeereid=yes}
| : ${ac_cv_func_getpgid=yes}
| : ${ac_cv_func_getpgrp=yes}
| : ${ac_cv_func_getpgrp_void=yes}
| : ${ac_cv_func_getpid=yes}
| : ${ac_cv_func_getrlimit=yes}
| : ${ac_cv_func_getrusage=yes}
| : ${ac_cv_func_gettimeofday=yes}
| : ${ac_cv_func_getttyent=yes}
| : ${ac_cv_func_getuid=yes}
| : ${ac_cv_func_getwd=yes}
| : ${ac_cv_func_glob=yes}
| : ${ac_cv_func_group_from_gid=yes}
| : ${ac_cv_func_index=yes}
| : ${ac_cv_func_inet_aton=yes}
| : ${ac_cv_func_inet_ntoa=yes}
| : ${ac_cv_func_inet_ntop=yes}
| : ${ac_cv_func_innetgr=yes}
| : ${ac_cv_func_insque=yes}
| : ${ac_cv_func_isascii=yes}
| : ${ac_cv_func_isascii=yes}
| : ${ac_cv_func_isblank=yes}
| : ${ac_cv_func_issetugid=yes}
| : ${ac_cv_func_iswblank=yes}
| : ${ac_cv_func_iswcntrl=yes}
| : ${ac_cv_func_iswctype=yes}
| : ${ac_cv_func_kill=yes}
| : ${ac_cv_func_killpg=yes}
| : ${ac_cv_func_link=yes}
| : ${ac_cv_func_labs=yes}
| : ${ac_cv_func_llabs=yes}
| : ${ac_cv_func_localtime=yes}
| : ${ac_cv_func_login_getcapbool=yes}
| : ${ac_cv_func_lstat=yes}
| : ${ac_cv_func_lstat_dereferences_slashed_symlink=yes}
| : ${ac_cv_func_malloc=yes}
| : ${ac_cv_func_malloc_0_nonnull=yes}
| : ${ac_cv_func_mblen=yes}
| : ${ac_cv_func_mbrlen=yes}
| : ${ac_cv_func_mbrtowc=yes}
| : ${ac_cv_func_mbsinit=yes}
| : ${ac_cv_func_mbsnrtowcs=yes}
| : ${ac_cv_func_mbsrtowcs=yes}
| : ${ac_cv_func_mbstowcs=yes}
| : ${ac_cv_func_mbtowc=yes}
| : ${ac_cv_func_memchr=yes}
| : ${ac_cv_func_memcmp=yes}
| : ${ac_cv_func_memcpy=yes}
| : ${ac_cv_func_memmove=yes}
| : ${ac_cv_func_memset=yes}
| : ${ac_cv_func_mincore=yes}
| : ${ac_cv_func_mkdtemp=yes}
| : ${ac_cv_func_mkstemp=yes}
| : ${ac_cv_func_mkstemps=yes}
| : ${ac_cv_func_mktemp=yes}
| : ${ac_cv_func_mktemps=yes}
| : ${ac_cv_func_mlock=yes}
| : ${ac_cv_func_mmap=yes}
| : ${ac_cv_func_mmap_fixed_mapped=yes}
| : ${ac_cv_func_mprotect=yes}
| : ${ac_cv_func_munlock=yes}
| : ${ac_cv_func_munmap=yes}
| : ${ac_cv_func_nl_langinfo=yes}
| : ${ac_cv_func_opendir=yes}
| : ${ac_cv_func_pam_getenvlist=yes}
| : ${ac_cv_func_pam_putenv=yes}
| : ${ac_cv_func_pathconf=yes}
| : ${ac_cv_func_pipe=yes}
| : ${ac_cv_func_poll=yes}
| : ${ac_cv_func_posix_spawn=yes}
| : ${ac_cv_func_pread=yes}
| : ${ac_cv_func_printf=yes}
| : ${ac_cv_func_psignal=yes}
| : ${ac_cv_func_pthread_cond_broadcast=yes}
| : ${ac_cv_func_pthread_cond_destroy=yes}
| : ${ac_cv_func_pthread_cond_init=yes}
| : ${ac_cv_func_pthread_cond_signal=yes}
| : ${ac_cv_func_pthread_cond_timedwait=yes}
| : ${ac_cv_func_pthread_cond_wait=yes}
| : ${ac_cv_func_pthread_equal=yes}
| : ${ac_cv_func_pthread_exit=yes}
| : ${ac_cv_func_pthread_mutex_destroy=yes}
| : ${ac_cv_func_pthread_mutex_init=yes}
| : ${ac_cv_func_pthread_mutex_lock=yes}
| : ${ac_cv_func_pthread_mutex_unlock=yes}
| : ${ac_cv_func_pthread_self=yes}
| : ${ac_cv_func_putc=yes}
| : ${ac_cv_func_putc_unlocked=yes}
| : ${ac_cv_func_putchar=yes}
| : ${ac_cv_func_putchar_unlocked=yes}
| : ${ac_cv_func_putenv=yes}
| : ${ac_cv_func_putw=yes}
| : ${ac_cv_func_pwrite=yes}
| : ${ac_cv_func_raise=yes}
| : ${ac_cv_func_rand=yes}
| : ${ac_cv_func_random=yes}
| : ${ac_cv_func_readdir=yes}
| : ${ac_cv_func_readlink=yes}
| : ${ac_cv_func_readlinkat=yes}
| : ${ac_cv_func_readpassphrase=yes}
| : ${ac_cv_func_realpath=yes}
| : ${ac_cv_func_recvmsg=yes}
| : ${ac_cv_func_rename=yes}
| : ${ac_cv_func_remque=yes}
| : ${ac_cv_func_rindex=yes}
| : ${ac_cv_func_rresvport_af=yes}
| : ${ac_cv_func_scandir=yes}
| : ${ac_cv_func_scandir_b=yes}
| : ${ac_cv_func_sched_yield=yes}
| : ${ac_cv_func_select=yes}
| : ${ac_cv_func_sendmsg=yes}
| : ${ac_cv_func_setegid=yes}
| : ${ac_cv_func_setenv=yes}
| : ${ac_cv_func_seteuid=yes}
| : ${ac_cv_func_setgid=yes}
| : ${ac_cv_func_setgrent=yes}
| : ${ac_cv_func_setgroupent=yes}
| : ${ac_cv_func_setgroups=yes}
| : ${ac_cv_func_setlinebuf=yes}
| : ${ac_cv_func_setlocale=yes}
| : ${ac_cv_func_setlogin=yes}
| : ${ac_cv_func_setpassent=yes}
| : ${ac_cv_func_setpgid=yes}
| : ${ac_cv_func_setproctitle=yes}
| : ${ac_cv_func_setregid=yes}
| : ${ac_cv_func_setresgid=yes}
| : ${ac_cv_func_setresuid=yes}
| : ${ac_cv_func_setreuid=yes}
| : ${ac_cv_func_setrlimit=yes}
| : ${ac_cv_func_setsid=yes}
| : ${ac_cv_func_setsockopt=yes}
| : ${ac_cv_func_setuid=yes}
| : ${ac_cv_func_setvbuf=yes}
| : ${ac_cv_func_shmget=yes}
| : ${ac_cv_func_sigaction=yes}
| : ${ac_cv_func_sigaltstack=yes}
| : ${ac_cv_func_sigblock=yes}
| : ${ac_cv_func_siginterrupt=yes}
| : ${ac_cv_func_sigmask=yes}
| : ${ac_cv_func_sigprocmask=yes}
| : ${ac_cv_func_sigsetmask=yes}
| : ${ac_cv_func_sigvec=yes}
| : ${ac_cv_func_sleep=yes}
| : ${ac_cv_func_sprintf=yes}
| : ${ac_cv_func_snprintf=yes}
| : ${ac_cv_func_socketpair=yes}
| : ${ac_cv_func_srand=yes}
| : ${ac_cv_func_srandom=yes}
| : ${ac_cv_func_stat=yes}
| : ${ac_cv_func_statfs=yes}
| : ${ac_cv_func_statvfs=yes}
| : ${ac_cv_func_stpcpy=yes}
| : ${ac_cv_func_stpncpy=yes}
| : ${ac_cv_func_strbrk=yes}
| : ${ac_cv_func_strcasecmp=yes}
| : ${ac_cv_func_strcasecmp_l=yes}
| : ${ac_cv_func_strcasestr=yes}
| : ${ac_cv_func_strcasestr_l=yes}
| : ${ac_cv_func_strchr=yes}
| : ${ac_cv_func_strrchr=yes}
| : ${ac_cv_func_strcspn=yes}
| : ${ac_cv_func_strdup=yes}
| : ${ac_cv_func_strerror=yes}
| : ${ac_cv_func_strerror_r=yes}
| : ${ac_cv_func_strftime=yes}
| : ${ac_cv_func_strlcat=yes}
| : ${ac_cv_func_strlcpy=yes}
| : ${ac_cv_func_strlen=yes}
| : ${ac_cv_func_strmode=yes}
| : ${ac_cv_func_strncasecmp=yes}
| : ${ac_cv_func_strncmp=yes}
| : ${ac_cv_func_strncmp_working=yes}
| : ${ac_cv_func_strndup=yes}
| : ${ac_cv_func_strnlen=yes}
| : ${ac_cv_func_strnlen_working=yes}
| : ${ac_cv_func_strpbrk=yes}
| : ${ac_cv_func_strptime=yes}
| : ${ac_cv_func_strsep=yes}
| : ${ac_cv_func_strsignal=yes}
| : ${ac_cv_func_strstr=yes}
| : ${ac_cv_func_strnstr=yes}
| : ${ac_cv_func_strtod=yes}
| : ${ac_cv_func_strtof=yes}
| : ${ac_cv_func_strtol=yes}
| : ${ac_cv_func_strtold=yes}
| : ${ac_cv_func_strtoll=yes}
| : ${ac_cv_func_strtonum=yes}
| : ${ac_cv_func_strtoul=yes}
| : ${ac_cv_func_strtoull=yes}
| : ${ac_cv_func_symlink=yes}
| : ${ac_cv_func_sysconf=yes}
| : ${ac_cv_func_sysctl=yes}
| : ${ac_cv_func_tcgetpgrp=yes}
| : ${ac_cv_func_tmpnam=yes}
| : ${ac_cv_func_time=yes}
| : ${ac_cv_func_times=yes}
| : ${ac_cv_func_towlower=yes}
| : ${ac_cv_func_truncate=yes}
| : ${ac_cv_func_tsearch=yes}
| : ${ac_cv_func_uname=yes}
| : ${ac_cv_func_unlink=yes}
| : ${ac_cv_func_unsetenv=yes}
| : ${ac_cv_func_user_from_uid=yes}
| : ${ac_cv_func_usleep=yes}
| : ${ac_cv_func_utime=yes}
| : ${ac_cv_func_utimes=yes}
| : ${ac_cv_func_vasprintf=yes}
| : ${ac_cv_func_vdprintf=yes}
| : ${ac_cv_func_vfork=yes}
| : ${ac_cv_func_vfork_working=yes}
| : ${ac_cv_func_vfprintf=yes}
| : ${ac_cv_func_vprintf=yes}
| : ${ac_cv_func_vsnprintf=yes}
| : ${ac_cv_func_vsprintf=yes}
| : ${ac_cv_func_waitpid=yes}
| : ${ac_cv_func_wait=yes}
| : ${ac_cv_func_waitid=yes}
| : ${ac_cv_func_wait2=yes}
| : ${ac_cv_func_wait3=yes}
| : ${ac_cv_func_wait3_rusage=yes}
| : ${ac_cv_func_wait4=yes}
| : ${ac_cv_func_wait6=yes}
| : ${ac_cv_func_warn=yes}
| : ${ac_cv_func_warnx=yes}
| : ${ac_cv_func_wcrtomb=yes}
| : ${ac_cv_func_wcscoll=yes}
| : ${ac_cv_func_wcslen=yes}
| : ${ac_cv_func_wcsnlen=yes}
| : ${ac_cv_func_wcswidth=yes}
| : ${ac_cv_func_wctob=yes}
| : ${ac_cv_func_wcwidth=yes}
| : ${ac_cv_func_wmemchr=yes}
| : ${ac_cv_func_wmemcpy=yes}
| : ${ac_cv_func_yp_match=yes}
| 
| # misc utx
| : ${ac_cv_func_endutxent=yes}
| : ${ac_cv_func_getutxent=yes}
| : ${ac_cv_func_getutxid=yes}
| : ${ac_cv_func_getutxline=yes}
| : ${ac_cv_func_getutxuser=yes}
| : ${ac_cv_func_pututxline=yes}
| : ${ac_cv_func_setutxdb=yes}
| : ${ac_cv_func_setutxent=yes}
| : ${ac_cv_func_endutent=no}
| : ${ac_cv_func_getutent=no}
| : ${ac_cv_func_getutid=no}
| : ${ac_cv_func_getutline=no}
| : ${ac_cv_func_pututline=no}
| : ${ac_cv_func_setutent=no}
| : ${ac_cv_func_utmpname=no}
| 
| # non existing functions
| : ${ac_cv_func_argz_count=no}
| : ${ac_cv_func_argz_next=no}
| : ${ac_cv_func_argz_stringify=no}
| : ${ac_cv_func_obstacks=no}
| : ${ac_cv_func_pstat_getdynamic=no}
| : ${ac_cv_func_rawmemchr=no}
| : ${ac_cv_func_yield=no}
| 
| : ${ac_cv_have___va_copy=yes}
| : ${ac_cv_have_clock_t=yes}
| : ${ac_cv_have_control_in_msghdr=yes}
| : ${ac_cv_have_getopt_optreset=yes}
| : ${ac_cv_have_int64_t=yes}
| : ${ac_cv_have_intxx_t=yes}
| : ${ac_cv_have_mode_t=yes}
| : ${ac_cv_have_pid_t=yes}
| : ${ac_cv_have_pw_change_in_struct_passwd=yes}
| : ${ac_cv_have_pw_class_in_struct_passwd=yes}
| : ${ac_cv_have_pw_expire_in_struct_passwd=yes}
| : ${ac_cv_have_sa_family_t=yes}
| : ${ac_cv_have_size_t=yes}
| : ${ac_cv_have_ss_family_in_struct_ss=yes}
| : ${ac_cv_have_ssize_t=yes}
| : ${ac_cv_have_struct_addrinfo=yes}
| : ${ac_cv_have_struct_in6_addr=yes}
| : ${ac_cv_have_struct_sockaddr_in6=yes}
| : ${ac_cv_have_struct_sockaddr_storage=yes}
| : ${ac_cv_have_struct_timeval=yes}
| : ${ac_cv_have_u_char=yes}
| : ${ac_cv_have_u_int64_t=yes}
| : ${ac_cv_have_u_int=yes}
| : ${ac_cv_have_u_intxx_t=yes}
| : ${ac_cv_have_va_copy=yes}
| 
| : ${ac_cv_have_decl_GLOB_NOMATCH=yes}
| : ${ac_cv_have_decl_LLONG_MAX=yes}
| : ${ac_cv_have_decl_MAXSYMLINKS=yes}
| : ${ac_cv_have_decl_O_NONBLOCK=yes}
| : ${ac_cv_have_decl_RLIMIT_NPROC=yes}
| : ${ac_cv_have_decl_SHUT_RD=yes}
| : ${ac_cv_have_decl__Exit=yes}
| : ${ac_cv_have_decl_abort=yes}
| : ${ac_cv_have_decl_alarm=yes}
| : ${ac_cv_have_decl_alphasort=yes}
| : ${ac_cv_have_decl_atof=yes}
| : ${ac_cv_have_decl_atol=yes}
| : ${ac_cv_have_decl_atoll=yes}
| : ${ac_cv_have_decl_btowc=yes}
| : ${ac_cv_have_decl_calloc=yes}
| : ${ac_cv_have_decl_chdir=yes}
| : ${ac_cv_have_decl_chown=yes}
| : ${ac_cv_have_decl_clearerr_unlocked=yes}
| : ${ac_cv_have_decl_clock=yes}
| : ${ac_cv_have_decl_closedir=yes}
| : ${ac_cv_have_decl_dprintf=yes}
| : ${ac_cv_have_decl_dup2=yes}
| : ${ac_cv_have_decl_dup=yes}
| : ${ac_cv_have_decl_endusershell=yes}
| : ${ac_cv_have_decl_errno=yes}
| : ${ac_cv_have_decl_faccessat=yes}
| : ${ac_cv_have_decl_fchdir=yes}
| : ${ac_cv_have_decl_fchmodat=yes}
| : ${ac_cv_have_decl_fchownat=yes}
| : ${ac_cv_have_decl_fcntl=yes}
| : ${ac_cv_have_decl_fdopendir=yes}
| : ${ac_cv_have_decl_feof_unlocked=yes}
| : ${ac_cv_have_decl_feof_unlocked_fgets_unlocked=yes}
| : ${ac_cv_have_decl_ferror_unlocked=yes}
| : ${ac_cv_have_decl_ffsl=yes}
| : ${ac_cv_have_decl_ffsll=yes}
| : ${ac_cv_have_decl_fpurge=yes}
| : ${ac_cv_have_decl_free=yes}
| : ${ac_cv_have_decl_frexpl=yes}
| : ${ac_cv_have_decl_fseeko=yes}
| : ${ac_cv_have_decl_fstat=yes}
| : ${ac_cv_have_decl_fstatat=yes}
| : ${ac_cv_have_decl_fsync=yes}
| : ${ac_cv_have_decl_ftello=yes}
| : ${ac_cv_have_decl_ftruncate=yes}
| : ${ac_cv_have_decl_getc_unlocked=yes}
| : ${ac_cv_have_decl_getchar_unlocked=yes}
| : ${ac_cv_have_decl_getcwd=yes}
| : ${ac_cv_have_decl_getdelim=yes}
| : ${ac_cv_have_decl_getdomainname=yes}
| : ${ac_cv_have_decl_getdtablesize=yes}
| : ${ac_cv_have_decl_getenv=yes}
| : ${ac_cv_have_decl_getgroups=yes}
| : ${ac_cv_have_decl_gethostname=yes}
| : ${ac_cv_have_decl_getline=yes}
| : ${ac_cv_have_decl_getloadavg=yes}
| : ${ac_cv_have_decl_getlogin=yes}
| : ${ac_cv_have_decl_getlogin_r=yes}
| : ${ac_cv_have_decl_getopt=yes}
| : ${ac_cv_have_decl_getpagesize=yes}
| : ${ac_cv_have_decl_getrlimit=yes}
| : ${ac_cv_have_decl_getrusage=yes}
| : ${ac_cv_have_decl_getsubopt=yes}
| : ${ac_cv_have_decl_gettimeofday=yes}
| : ${ac_cv_have_decl_getusershell=yes}
| : ${ac_cv_have_decl_getwd=yes}
| : ${ac_cv_have_decl_grantpt=yes}
| : ${ac_cv_have_decl_h_errno=yes}
| : ${ac_cv_have_decl_imaxabs=yes}
| : ${ac_cv_have_decl_imaxdiv=yes}
| : ${ac_cv_have_decl_initstate=yes}
| : ${ac_cv_have_decl_isatty=yes}
| : ${ac_cv_have_decl_isblank=yes}
| : ${ac_cv_have_decl_iswblank=yes}
| : ${ac_cv_have_decl_iswctype=yes}
| : ${ac_cv_have_decl_lchmod=yes}
| : ${ac_cv_have_decl_lchown=yes}
| : ${ac_cv_have_decl_link=yes}
| : ${ac_cv_have_decl_linkat=yes}
| : ${ac_cv_have_decl_lseek=yes}
| : ${ac_cv_have_decl_lstat=yes}
| : ${ac_cv_have_decl_malloc=yes}
| : ${ac_cv_have_decl_mbrlen=yes}
| : ${ac_cv_have_decl_mbrtowc=yes}
| : ${ac_cv_have_decl_mbsinit=yes}
| : ${ac_cv_have_decl_mbsnrtowcs=yes}
| : ${ac_cv_have_decl_mbsrtowcs=yes}
| : ${ac_cv_have_decl_memmem=yes}
| : ${ac_cv_have_decl_memrchr=yes}
| : ${ac_cv_have_decl_mkdirat=yes}
| : ${ac_cv_have_decl_mkdtemp=yes}
| : ${ac_cv_have_decl_mkfifo=yes}
| : ${ac_cv_have_decl_mkfifoat=yes}
| : ${ac_cv_have_decl_mknod=yes}
| : ${ac_cv_have_decl_mknodat=yes}
| : ${ac_cv_have_decl_mkstemp=yes}
| : ${ac_cv_have_decl_nl_langinfo=yes}
| : ${ac_cv_have_decl_offsetof=yes}
| : ${ac_cv_have_decl_openat=yes}
| : ${ac_cv_have_decl_opendir=yes}
| : ${ac_cv_have_decl_pclose=yes}
| : ${ac_cv_have_decl_pipe=yes}
| : ${ac_cv_have_decl_popen=yes}
| : ${ac_cv_have_decl_posix_openpt=yes}
| : ${ac_cv_have_decl_posix_spawn=yes}
| : ${ac_cv_have_decl_posix_spawn_file_actions_addclose=yes}
| : ${ac_cv_have_decl_posix_spawn_file_actions_adddup2=yes}
| : ${ac_cv_have_decl_posix_spawn_file_actions_addopen=yes}
| : ${ac_cv_have_decl_posix_spawn_file_actions_destroy=yes}
| : ${ac_cv_have_decl_posix_spawn_file_actions_init=yes}
| : ${ac_cv_have_decl_posix_spawnattr_destroy=yes}
| : ${ac_cv_have_decl_posix_spawnattr_getflags=yes}
| : ${ac_cv_have_decl_posix_spawnattr_getpgroup=yes}
| : ${ac_cv_have_decl_posix_spawnattr_getschedparam=yes}
| : ${ac_cv_have_decl_posix_spawnattr_getschedpolicy=yes}
| : ${ac_cv_have_decl_posix_spawnattr_getsigdefault=yes}
| : ${ac_cv_have_decl_posix_spawnattr_getsigmask=yes}
| : ${ac_cv_have_decl_posix_spawnattr_init=yes}
| : ${ac_cv_have_decl_posix_spawnattr_setflags=yes}
| : ${ac_cv_have_decl_posix_spawnattr_setpgroup=yes}
| : ${ac_cv_have_decl_posix_spawnattr_setschedparam=yes}
| : ${ac_cv_have_decl_posix_spawnattr_setschedpolicy=yes}
| : ${ac_cv_have_decl_posix_spawnattr_setsigdefault=yes}
| : ${ac_cv_have_decl_posix_spawnattr_setsigmask=yes}
| : ${ac_cv_have_decl_posix_spawnp=yes}
| : ${ac_cv_have_decl_pread=yes}
| : ${ac_cv_have_decl_pselect=yes}
| : ${ac_cv_have_decl_pthread_sigmask=yes}
| : ${ac_cv_have_decl_ptsname=yes}
| : ${ac_cv_have_decl_putc_unlocked=yes}
| : ${ac_cv_have_decl_putchar_unlocked=yes}
| : ${ac_cv_have_decl_pwrite=yes}
| : ${ac_cv_have_decl_random=yes}
| : ${ac_cv_have_decl_rawmemchr=yes}
| : ${ac_cv_have_decl_readdir=yes}
| : ${ac_cv_have_decl_readlink=yes}
| : ${ac_cv_have_decl_readlinkat=yes}
| : ${ac_cv_have_decl_realloc=yes}
| : ${ac_cv_have_decl_realpath=yes}
| : ${ac_cv_have_decl_renameat=yes}
| : ${ac_cv_have_decl_rewinddir=yes}
| : ${ac_cv_have_decl_rmdir=yes}
| : ${ac_cv_have_decl_rpmatch=yes}
| : ${ac_cv_have_decl_sbrk=yes}
| : ${ac_cv_have_decl_scandir=yes}
| : ${ac_cv_have_decl_select=yes}
| : ${ac_cv_have_decl_setenv=yes}
| : ${ac_cv_have_decl_sethostname=yes}
| : ${ac_cv_have_decl_setlocale=yes}
| : ${ac_cv_have_decl_setrlimit=yes}
| : ${ac_cv_have_decl_setstate=yes}
| : ${ac_cv_have_decl_setusershell=yes}
| : ${ac_cv_have_decl_sigaction=yes}
| : ${ac_cv_have_decl_sigaddset=yes}
| : ${ac_cv_have_decl_sigaltstack=yes}
| : ${ac_cv_have_decl_sigdelset=yes}
| : ${ac_cv_have_decl_sigemptyset=yes}
| : ${ac_cv_have_decl_sigfillset=yes}
| : ${ac_cv_have_decl_sigismember=yes}
| : ${ac_cv_have_decl_sigpending=yes}
| : ${ac_cv_have_decl_sigprocmask=yes}
| : ${ac_cv_have_decl_sleep=yes}
| : ${ac_cv_have_decl_snprintf=yes}
| : ${ac_cv_have_decl_srandom=yes}
| : ${ac_cv_have_decl_stat=yes}
| : ${ac_cv_have_decl_stpcpy=yes}
| : ${ac_cv_have_decl_stpncpy=yes}
| : ${ac_cv_have_decl_strcasestr=yes}
| : ${ac_cv_have_decl_strdup=yes}
| : ${ac_cv_have_decl_strerror_r=yes}
| : ${ac_cv_have_decl_strncat=yes}
| : ${ac_cv_have_decl_strndup=yes}
| : ${ac_cv_have_decl_strnlen=yes}
| : ${ac_cv_have_decl_strpbrk=yes}
| : ${ac_cv_have_decl_strsep=yes}
| : ${ac_cv_have_decl_strsignal=yes}
| : ${ac_cv_have_decl_strstr=yes}
| : ${ac_cv_have_decl_strtod=yes}
| : ${ac_cv_have_decl_strtoimax=yes}
| : ${ac_cv_have_decl_strtok_r=yes}
| : ${ac_cv_have_decl_strtoll=yes}
| : ${ac_cv_have_decl_strtoull=yes}
| : ${ac_cv_have_decl_strtoumax=yes}
| : ${ac_cv_have_decl_symlink=yes}
| : ${ac_cv_have_decl_symlinkat=yes}
| : ${ac_cv_have_decl_sys_siglist=yes}
| : ${ac_cv_have_decl_tcsendbreak=yes}
| : ${ac_cv_have_decl_times=yes}
| : ${ac_cv_have_decl_tmpfile=yes}
| : ${ac_cv_have_decl_towctrans=yes}
| : ${ac_cv_have_decl_ttyname_r=yes}
| : ${ac_cv_have_decl_unlink=yes}
| : ${ac_cv_have_decl_unlinkat=yes}
| : ${ac_cv_have_decl_unlockpt=yes}
| : ${ac_cv_have_decl_unsetenv=yes}
| : ${ac_cv_have_decl_usleep=yes}
| : ${ac_cv_have_decl_vasprintf=yes}
| : ${ac_cv_have_decl_vdprintf=yes}
| : ${ac_cv_have_decl_vsnprintf=yes}
| : ${ac_cv_have_decl_waitpid=yes}
| : ${ac_cv_have_decl_wcpcpy=yes}
| : ${ac_cv_have_decl_wcpncpy=yes}
| : ${ac_cv_have_decl_wcrtomb=yes}
| : ${ac_cv_have_decl_wcscasecmp=yes}
| : ${ac_cv_have_decl_wcscat=yes}
| : ${ac_cv_have_decl_wcschr=yes}
| : ${ac_cv_have_decl_wcscmp=yes}
| : ${ac_cv_have_decl_wcscoll=yes}
| : ${ac_cv_have_decl_wcscpy=yes}
| : ${ac_cv_have_decl_wcscspn=yes}
| : ${ac_cv_have_decl_wcsdup=yes}
| : ${ac_cv_have_decl_wcslen=yes}
| : ${ac_cv_have_decl_wcsncasecmp=yes}
| : ${ac_cv_have_decl_wcsncat=yes}
| : ${ac_cv_have_decl_wcsncmp=yes}
| : ${ac_cv_have_decl_wcsncpy=yes}
| : ${ac_cv_have_decl_wcsnlen=yes}
| : ${ac_cv_have_decl_wcsnrtombs=yes}
| : ${ac_cv_have_decl_wcspbrk=yes}
| : ${ac_cv_have_decl_wcsrchr=yes}
| : ${ac_cv_have_decl_wcsrtombs=yes}
| : ${ac_cv_have_decl_wcsspn=yes}
| : ${ac_cv_have_decl_wcsstr=yes}
| : ${ac_cv_have_decl_wcstok=yes}
| : ${ac_cv_have_decl_wcswidth=yes}
| : ${ac_cv_have_decl_wcsxfrm=yes}
| : ${ac_cv_have_decl_wctob=yes}
| : ${ac_cv_have_decl_wctrans=yes}
| : ${ac_cv_have_decl_wctype=yes}
| : ${ac_cv_have_decl_wcwidth=yes}
| : ${ac_cv_have_decl_wmemchr=yes}
| : ${ac_cv_have_decl_wmemcmp=yes}
| : ${ac_cv_have_decl_wmemcpy=yes}
| : ${ac_cv_have_decl_wmemmove=yes}
| : ${ac_cv_have_decl_wmemset=yes}
| : ${ac_cv_have_decl_writev=yes}
| 
| # long file name support test invasively touches localbase, always true
| : ${ac_cv_sys_long_file_names=yes}
| 
| # function specific
| 
| : ${gl_cv_func_btowc_eof=yes}
| : ${gl_cv_func_btowc_nul=yes}
| : ${gl_cv_func_fcntl_f_dupfd_cloexec=yes}
| : ${gl_cv_func_fnmatch_posix=yes}
| : ${gl_cv_func_fopen_slash=yes}
| : ${gl_cv_func_frexp_no_libm=yes}
| : ${gl_cv_func_fseeko=yes}
| : ${gl_cv_func_ftello=yes}
| : ${gl_cv_func_getcwd_null=yes}
| : ${gl_cv_func_getcwd_posix_signature=yes}
| : ${gl_cv_func_getopt_posix=yes}
| : ${gl_cv_func_isnand_no_libm=yes}
| : ${gl_cv_func_ldexp_no_libm=yes}
| : ${gl_cv_func_lseek_pipe=yes}
| : ${gl_cv_func_lstat_dereferences_slashed_symlink=yes}
| : ${gl_cv_func_malloc_0_nonnull=1}
| : ${gl_cv_func_malloc_posix=yes}
| : ${gl_cv_func_mbrtowc_incomplete_state=yes}
| : ${gl_cv_func_mbrtowc_nul_retval=yes}
| : ${gl_cv_func_mbrtowc_null_arg1=yes}
| : ${gl_cv_func_mbrtowc_null_arg2=yes}
| : ${gl_cv_func_mbrtowc_retval=yes}
| : ${gl_cv_func_mbrtowc_sanitycheck=yes}
| : ${gl_cv_func_open_slash=yes}
| : ${gl_cv_func_printf_directive_a=yes}
| : ${gl_cv_func_printf_directive_f=yes}
| : ${gl_cv_func_printf_directive_ls=yes}
| : ${gl_cv_func_printf_directive_n=yes}
| : ${gl_cv_func_printf_flag_grouping=yes}
| : ${gl_cv_func_printf_flag_leftadjust=yes}
| : ${gl_cv_func_printf_flag_zero=yes}
| : ${gl_cv_func_printf_infinite=yes}
| : ${gl_cv_func_printf_long_double=yes}
| : ${gl_cv_func_printf_positions=yes}
| : ${gl_cv_func_printf_precision=yes}
| : ${gl_cv_func_printf_sizes_c99=yes}
| : ${gl_cv_func_sigprocmask=1}
| : ${gl_cv_func_snprintf_retval_c99=yes}
| : ${gl_cv_func_snprintf_size1=yes}
| : ${gl_cv_func_snprintf_usable=yes}
| : ${gl_cv_func_spawnattr_setschedparam=yes}
| : ${gl_cv_func_spawnattr_setschedpolicy=yes}
| : ${gl_cv_func_stat_dir_slash=yes}
| : ${gl_cv_func_stat_file_slash=yes}
| : ${gl_cv_func_stpncpy=yes}
| : ${gl_cv_func_va_copy=yes}
| : ${gl_cv_func_wcrtomb_retval=yes}
| : ${gt_cv_func_unsetenv_ret=int}
| 
| : ${gl_cv_have_include_next=yes}
| 
| : ${gl_cv_have_raw_decl_rawmemchr=yes}
| : ${gl_cv_have_raw_decl__Exit=yes}
| : ${gl_cv_have_raw_decl_alphasort=yes}
| : ${gl_cv_have_raw_decl_atoll=yes}
| : ${gl_cv_have_raw_decl_btowc=yes}
| : ${gl_cv_have_raw_decl_chdir=yes}
| : ${gl_cv_have_raw_decl_chown=yes}
| : ${gl_cv_have_raw_decl_closedir=yes}
| : ${gl_cv_have_raw_decl_dprintf=yes}
| : ${gl_cv_have_raw_decl_dup2=yes}
| : ${gl_cv_have_raw_decl_dup=yes}
| : ${gl_cv_have_raw_decl_endusershell=yes}
| : ${gl_cv_have_raw_decl_faccessat=yes}
| : ${gl_cv_have_raw_decl_fchdir=yes}
| : ${gl_cv_have_raw_decl_fchmodat=yes}
| : ${gl_cv_have_raw_decl_fchownat=yes}
| : ${gl_cv_have_raw_decl_fcntl=yes}
| : ${gl_cv_have_raw_decl_fdopendir=yes}
| : ${gl_cv_have_raw_decl_ffsl=yes}
| : ${gl_cv_have_raw_decl_ffsll=yes}
| : ${gl_cv_have_raw_decl_fpurge=yes}
| : ${gl_cv_have_raw_decl_fseeko=yes}
| : ${gl_cv_have_raw_decl_fstat=yes}
| : ${gl_cv_have_raw_decl_fstatat=yes}
| : ${gl_cv_have_raw_decl_fsync=yes}
| : ${gl_cv_have_raw_decl_ftello=yes}
| : ${gl_cv_have_raw_decl_ftruncate=yes}
| : ${gl_cv_have_raw_decl_getcwd=yes}
| : ${gl_cv_have_raw_decl_getdelim=yes}
| : ${gl_cv_have_raw_decl_getdomainname=yes}
| : ${gl_cv_have_raw_decl_getdtablesize=yes}
| : ${gl_cv_have_raw_decl_getgroups=yes}
| : ${gl_cv_have_raw_decl_getdtablesize=yes}
| : ${gl_cv_have_raw_decl_getgroups=yes}
| : ${gl_cv_have_raw_decl_gethostname=yes}
| : ${gl_cv_have_raw_decl_getline=yes}
| : ${gl_cv_have_raw_decl_getloadavg=yes}
| : ${gl_cv_have_raw_decl_getlogin=yes}
| : ${gl_cv_have_raw_decl_getlogin_r=yes}
| : ${gl_cv_have_raw_decl_getpagesize=yes}
| : ${gl_cv_have_raw_decl_getsubopt=yes}
| : ${gl_cv_have_raw_decl_gettimeofday=yes}
| : ${gl_cv_have_raw_decl_getusershell=yes}
| : ${gl_cv_have_raw_decl_grantpt=yes}
| : ${gl_cv_have_raw_decl_imaxabs=yes}
| : ${gl_cv_have_raw_decl_imaxdiv=yes}
| : ${gl_cv_have_raw_decl_initstate=yes}
| : ${gl_cv_have_raw_decl_isatty=yes}
| : ${gl_cv_have_raw_decl_iswctype=yes}
| : ${gl_cv_have_raw_decl_lchmod=yes}
| : ${gl_cv_have_raw_decl_lchown=yes}
| : ${gl_cv_have_raw_decl_link=yes}
| : ${gl_cv_have_raw_decl_linkat=yes}
| : ${gl_cv_have_raw_decl_lseek=yes}
| : ${gl_cv_have_raw_decl_lstat=yes}
| : ${gl_cv_have_raw_decl_mbrlen=yes}
| : ${gl_cv_have_raw_decl_mbrtowc=yes}
| : ${gl_cv_have_raw_decl_mbsinit=yes}
| : ${gl_cv_have_raw_decl_mbsnrtowcs=yes}
| : ${gl_cv_have_raw_decl_mbsrtowcs=yes}
| : ${gl_cv_have_raw_decl_mkdirat=yes}
| : ${gl_cv_have_raw_decl_mkdtemp=yes}
| : ${gl_cv_have_raw_decl_mkfifo=yes}
| : ${gl_cv_have_raw_decl_mkfifoat=yes}
| : ${gl_cv_have_raw_decl_mknod=yes}
| : ${gl_cv_have_raw_decl_mknodat=yes}
| : ${gl_cv_have_raw_decl_mkstemp=yes}
| : ${gl_cv_have_raw_decl_nl_langinfo=yes}
| : ${gl_cv_have_raw_decl_openat=yes}
| : ${gl_cv_have_raw_decl_opendir=yes}
| : ${gl_cv_have_raw_decl_pclose=yes}
| : ${gl_cv_have_raw_decl_pipe=yes}
| : ${gl_cv_have_raw_decl_popen=yes}
| : ${gl_cv_have_raw_decl_posix_openpt=yes}
| : ${gl_cv_have_raw_decl_posix_spawn=yes}
| : ${gl_cv_have_raw_decl_posix_openpt=yes}
| : ${gl_cv_have_raw_decl_posix_spawn=yes}
| : ${gl_cv_have_raw_decl_posix_spawn_file_actions_addclose=yes}
| : ${gl_cv_have_raw_decl_posix_spawn_file_actions_adddup2=yes}
| : ${gl_cv_have_raw_decl_posix_spawn_file_actions_addopen=yes}
| : ${gl_cv_have_raw_decl_posix_spawn_file_actions_destroy=yes}
| : ${gl_cv_have_raw_decl_posix_spawn_file_actions_init=yes}
| : ${gl_cv_have_raw_decl_posix_spawnattr_destroy=yes}
| : ${gl_cv_have_raw_decl_posix_spawnattr_getflags=yes}
| : ${gl_cv_have_raw_decl_posix_spawnattr_getpgroup=yes}
| : ${gl_cv_have_raw_decl_posix_spawnattr_getschedparam=yes}
| : ${gl_cv_have_raw_decl_posix_spawnattr_getschedpolicy=yes}
| : ${gl_cv_have_raw_decl_posix_spawnattr_getsigdefault=yes}
| : ${gl_cv_have_raw_decl_posix_spawnattr_getsigmask=yes}
| : ${gl_cv_have_raw_decl_posix_spawnattr_init=yes}
| : ${gl_cv_have_raw_decl_posix_spawnattr_setflags=yes}
| : ${gl_cv_have_raw_decl_posix_spawnattr_setpgroup=yes}
| : ${gl_cv_have_raw_decl_posix_spawnattr_setschedparam=yes}
| : ${gl_cv_have_raw_decl_posix_spawnattr_setschedpolicy=yes}
| : ${gl_cv_have_raw_decl_posix_spawnattr_setsigdefault=yes}
| : ${gl_cv_have_raw_decl_posix_spawnattr_setsigmask=yes}
| : ${gl_cv_have_raw_decl_posix_spawnp=yes}
| : ${gl_cv_have_raw_decl_pread=yes}
| : ${gl_cv_have_raw_decl_pselect=yes}
| : ${gl_cv_have_raw_decl_pthread_sigmask=yes}
| : ${gl_cv_have_raw_decl_ptsname=yes}
| : ${gl_cv_have_raw_decl_pwrite=yes}
| : ${gl_cv_have_raw_decl_random=yes}
| : ${gl_cv_have_raw_decl_readdir=yes}
| : ${gl_cv_have_raw_decl_readlink=yes}
| : ${gl_cv_have_raw_decl_readlinkat=yes}
| : ${gl_cv_have_raw_decl_realpath=yes}
| : ${gl_cv_have_raw_decl_renameat=yes}
| : ${gl_cv_have_raw_decl_rewinddir=yes}
| : ${gl_cv_have_raw_decl_rmdir=yes}
| : ${gl_cv_have_raw_decl_rpmatch=yes}
| : ${gl_cv_have_raw_decl_scandir=yes}
| : ${gl_cv_have_raw_decl_select=yes}
| : ${gl_cv_have_raw_decl_setenv=yes}
| : ${gl_cv_have_raw_decl_sethostname=yes}
| : ${gl_cv_have_raw_decl_setlocale=yes}
| : ${gl_cv_have_raw_decl_setstate=yes}
| : ${gl_cv_have_raw_decl_setusershell=yes}
| : ${gl_cv_have_raw_decl_sigaction=yes}
| : ${gl_cv_have_raw_decl_sigaddset=yes}
| : ${gl_cv_have_raw_decl_sigdelset=yes}
| : ${gl_cv_have_raw_decl_sigemptyset=yes}
| : ${gl_cv_have_raw_decl_sigfillset=yes}
| : ${gl_cv_have_raw_decl_sigismember=yes}
| : ${gl_cv_have_raw_decl_sigpending=yes}
| : ${gl_cv_have_raw_decl_sigprocmask=yes}
| : ${gl_cv_have_raw_decl_sleep=yes}
| : ${gl_cv_have_raw_decl_snprintf=yes}
| : ${gl_cv_have_raw_decl_srandom=yes}
| : ${gl_cv_have_raw_decl_stat=yes}
| : ${gl_cv_have_raw_decl_strerror_r=yes}
| : ${gl_cv_have_raw_decl_strtod=yes}
| : ${gl_cv_have_raw_decl_strtoimax=yes}
| : ${gl_cv_have_raw_decl_strtoll=yes}
| : ${gl_cv_have_raw_decl_strtoull=yes}
| : ${gl_cv_have_raw_decl_strtoumax=yes}
| : ${gl_cv_have_raw_decl_symlink=yes}
| : ${gl_cv_have_raw_decl_symlinkat=yes}
| : ${gl_cv_have_raw_decl_tmpfile=yes}
| : ${gl_cv_have_raw_decl_towctrans=yes}
| : ${gl_cv_have_raw_decl_ttyname_r=yes}
| : ${gl_cv_have_raw_decl_unlink=yes}
| : ${gl_cv_have_raw_decl_unlinkat=yes}
| : ${gl_cv_have_raw_decl_unlockpt=yes}
| : ${gl_cv_have_raw_decl_unsetenv=yes}
| : ${gl_cv_have_raw_decl_usleep=yes}
| : ${gl_cv_have_raw_decl_vdprintf=yes}
| : ${gl_cv_have_raw_decl_vsnprintf=yes}
| : ${gl_cv_have_raw_decl_waitpid=yes}
| : ${gl_cv_have_raw_decl_wcpcpy=yes}
| : ${gl_cv_have_raw_decl_wcpncpy=yes}
| : ${gl_cv_have_raw_decl_wcrtomb=yes}
| : ${gl_cv_have_raw_decl_wcscasecmp=yes}
| : ${gl_cv_have_raw_decl_wcscat=yes}
| : ${gl_cv_have_raw_decl_wcschr=yes}
| : ${gl_cv_have_raw_decl_wcscmp=yes}
| : ${gl_cv_have_raw_decl_wcscoll=yes}
| : ${gl_cv_have_raw_decl_wcscpy=yes}
| : ${gl_cv_have_raw_decl_wcscspn=yes}
| : ${gl_cv_have_raw_decl_wcsdup=yes}
| : ${gl_cv_have_raw_decl_wcslen=yes}
| : ${gl_cv_have_raw_decl_wcsncasecmp=yes}
| : ${gl_cv_have_raw_decl_wcsncat=yes}
| : ${gl_cv_have_raw_decl_wcsncmp=yes}
| : ${gl_cv_have_raw_decl_wcsncpy=yes}
| : ${gl_cv_have_raw_decl_wcsnlen=yes}
| : ${gl_cv_have_raw_decl_wcsnrtombs=yes}
| : ${gl_cv_have_raw_decl_wcspbrk=yes}
| : ${gl_cv_have_raw_decl_wcsrchr=yes}
| : ${gl_cv_have_raw_decl_wcsrtombs=yes}
| : ${gl_cv_have_raw_decl_wcsspn=yes}
| : ${gl_cv_have_raw_decl_wcsstr=yes}
| : ${gl_cv_have_raw_decl_wcstok=yes}
| : ${gl_cv_have_raw_decl_wcswidth=yes}
| : ${gl_cv_have_raw_decl_wcsxfrm=yes}
| : ${gl_cv_have_raw_decl_wctob=yes}
| : ${gl_cv_have_raw_decl_wctrans=yes}
| : ${gl_cv_have_raw_decl_wctype=yes}
| : ${gl_cv_have_raw_decl_wcwidth=yes}
| : ${gl_cv_have_raw_decl_wmemchr=yes}
| : ${gl_cv_have_raw_decl_wmemcmp=yes}
| : ${gl_cv_have_raw_decl_wmemcpy=yes}
| : ${gl_cv_have_raw_decl_wmemmove=yes}
| : ${gl_cv_have_raw_decl_wmemset=yes}
| 
| : ${gl_cv_header_errno_h_complete=yes}
| : ${gl_cv_header_inttypes_h=yes}
| : ${gl_cv_header_langinfo_codeset=yes}
| : ${gl_cv_header_langinfo_era=yes}
| : ${gl_cv_header_langinfo_t_fmt_ampm=yes}
| : ${gl_cv_header_langinfo_yesexpr=yes}
| : ${gl_cv_header_locale_h_posix2001=yes}
| : ${gl_cv_header_signal_h_SIGPIPE=yes}
| : ${gl_cv_header_stdint_h=yes}
| : ${gl_cv_header_sys_select_h_selfcontained=yes}
| 
configure:2229: checking for gcc
configure:2256: result: cc
configure:2485: checking for C compiler version
configure:2494: cc --version >&5
FreeBSD clang version 8.0.0 (tags/RELEASE_800/final 356365) (based on LLVM 8.0.0)
Target: x86_64-unknown-freebsd11.3
Thread model: posix
InstalledDir: /usr/bin
configure:2505: $? = 0
configure:2494: cc -v >&5
FreeBSD clang version 8.0.0 (tags/RELEASE_800/final 356365) (based on LLVM 8.0.0)
Target: x86_64-unknown-freebsd11.3
Thread model: posix
InstalledDir: /usr/bin
configure:2505: $? = 0
configure:2494: cc -V >&5
cc: error: argument to '-V' is missing (expected 1 value)
cc: error: no input files
configure:2505: $? = 1
configure:2494: cc -qversion >&5
cc: error: unknown argument '-qversion', did you mean '--version'?
cc: error: no input files
configure:2505: $? = 1
configure:2525: checking whether the C compiler works
configure:2547: cc -O2 -pipe  -fstack-protector-strong -fno-strict-aliasing    -fstack-protector-strong  conftest.c  >&5
configure:2551: $? = 0
configure:2599: result: yes
configure:2602: checking for C compiler default output file name
configure:2604: result: a.out
configure:2610: checking for suffix of executables
configure:2617: cc -o conftest -O2 -pipe  -fstack-protector-strong -fno-strict-aliasing    -fstack-protector-strong  conftest.c  >&5
configure:2621: $? = 0
configure:2643: result: 
configure:2665: checking whether we are cross compiling
configure:2673: cc -o conftest -O2 -pipe  -fstack-protector-strong -fno-strict-aliasing    -fstack-protector-strong  conftest.c  >&5
configure:2677: $? = 0
configure:2684: ./conftest
configure:2688: $? = 0
configure:2703: result: no
configure:2708: checking for suffix of object files
configure:2730: cc -c -O2 -pipe  -fstack-protector-strong -fno-strict-aliasing   conftest.c >&5
configure:2734: $? = 0
configure:2755: result: o
configure:2759: checking whether we are using the GNU C compiler
configure:2778: cc -c -O2 -pipe  -fstack-protector-strong -fno-strict-aliasing   conftest.c >&5
configure:2778: $? = 0
configure:2787: result: yes
configure:2796: checking whether cc accepts -g
configure:2816: cc -c -g  conftest.c >&5
configure:2816: $? = 0
configure:2857: result: yes
configure:2874: checking for cc option to accept ISO C89
configure:2937: cc  -c -O2 -pipe  -fstack-protector-strong -fno-strict-aliasing   conftest.c >&5
configure:2937: $? = 0
configure:2950: result: none needed
configure:2984: checking for a BSD-compatible install
configure:3052: result: /usr/bin/install -c
configure:3063: checking whether make sets $(MAKE)
configure:3085: result: yes
configure:3097: checking for pthread_create in -lpthread
configure:3122: cc -o conftest -O2 -pipe  -fstack-protector-strong -fno-strict-aliasing    -fstack-protector-strong  conftest.c -lpthread   >&5
configure:3122: $? = 0
configure:3131: result: yes
configure:3142: checking for connect in -lsocket
configure:3167: cc -o conftest -O2 -pipe  -fstack-protector-strong -fno-strict-aliasing    -fstack-protector-strong  conftest.c -lsocket  -lpthread  >&5
/usr/bin/ld: cannot find -lsocket
cc: error: linker command failed with exit code 1 (use -v to see invocation)
configure:3167: $? = 1
configure: failed program was:
| /* confdefs.h */
| #define PACKAGE_NAME "pwol"
| #define PACKAGE_TARNAME "pwol"
| #define PACKAGE_VERSION "1.5"
| #define PACKAGE_STRING "pwol 1.5"
| #define PACKAGE_BUGREPORT "pen@lysator.liu.se"
| #define PACKAGE_URL "https://github.com/ptrrkssn/pwol"
| #define HAVE_LIBPTHREAD 1
| /* end confdefs.h.  */
| 
| /* Override any GCC internal prototype to avoid an error.
|    Use char because int might match the return type of a GCC
|    builtin and then its argument prototype would still apply.  */
| #ifdef __cplusplus
| extern "C"
| #endif
| char connect ();
| int
| main ()
| {
| return connect ();
|   ;
|   return 0;
| }
configure:3176: result: no
configure:3187: checking for gethostbyname in -lnsl
configure:3212: cc -o conftest -O2 -pipe  -fstack-protector-strong -fno-strict-aliasing    -fstack-protector-strong  conftest.c -lnsl  -lpthread  >&5
/usr/bin/ld: cannot find -lnsl
cc: error: linker command failed with exit code 1 (use -v to see invocation)
configure:3212: $? = 1
configure: failed program was:
| /* confdefs.h */
| #define PACKAGE_NAME "pwol"
| #define PACKAGE_TARNAME "pwol"
| #define PACKAGE_VERSION "1.5"
| #define PACKAGE_STRING "pwol 1.5"
| #define PACKAGE_BUGREPORT "pen@lysator.liu.se"
| #define PACKAGE_URL "https://github.com/ptrrkssn/pwol"
| #define HAVE_LIBPTHREAD 1
| /* end confdefs.h.  */
| 
| /* Override any GCC internal prototype to avoid an error.
|    Use char because int might match the return type of a GCC
|    builtin and then its argument prototype would still apply.  */
| #ifdef __cplusplus
| extern "C"
| #endif
| char gethostbyname ();
| int
| main ()
| {
| return gethostbyname ();
|   ;
|   return 0;
| }
configure:3221: result: no
configure:3239: checking how to run the C preprocessor
configure:3309: result: cpp
configure:3329: cpp  conftest.c
configure:3329: $? = 0
configure:3343: cpp  conftest.c
conftest.c:10:10: fatal error: 'ac_nonexistent.h' file not found
#include <ac_nonexistent.h>
         ^~~~~~~~~~~~~~~~~~
1 error generated.
configure:3343: $? = 1
configure: failed program was:
| /* confdefs.h */
| #define PACKAGE_NAME "pwol"
| #define PACKAGE_TARNAME "pwol"
| #define PACKAGE_VERSION "1.5"
| #define PACKAGE_STRING "pwol 1.5"
| #define PACKAGE_BUGREPORT "pen@lysator.liu.se"
| #define PACKAGE_URL "https://github.com/ptrrkssn/pwol"
| #define HAVE_LIBPTHREAD 1
| /* end confdefs.h.  */
| #include <ac_nonexistent.h>
configure:3372: checking for grep that handles long lines and -e
configure:3430: result: /usr/bin/grep
configure:3435: checking for egrep
configure:3497: result: /usr/bin/egrep
configure:3502: checking for ANSI C header files
configure:3606: result: yes
configure:3619: checking for sys/types.h
configure:3619: result: yes
configure:3619: checking for sys/stat.h
configure:3619: result: yes
configure:3619: checking for stdlib.h
configure:3619: result: yes
configure:3619: checking for string.h
configure:3619: result: yes
configure:3619: checking for memory.h
configure:3619: result: yes
configure:3619: checking for strings.h
configure:3619: result: yes
configure:3619: checking for inttypes.h
configure:3619: result: yes
configure:3619: checking for stdint.h
configure:3619: result: yes
configure:3619: checking for unistd.h
configure:3619: result: yes
configure:3634: checking for arpa/inet.h
configure:3634: result: yes
configure:3634: checking for fcntl.h
configure:3634: result: yes
configure:3634: checking for netdb.h
configure:3634: result: yes
configure:3634: checking for netinet/in.h
configure:3634: result: yes
configure:3634: checking for stdlib.h
configure:3634: result: yes
configure:3634: checking for string.h
configure:3634: result: yes
configure:3634: checking for sys/socket.h
configure:3634: result: yes
configure:3634: checking syslog.h usability
configure:3634: cc -c -O2 -pipe  -fstack-protector-strong -fno-strict-aliasing   conftest.c >&5
configure:3634: $? = 0
configure:3634: result: yes
configure:3634: checking syslog.h presence
configure:3634: cpp  conftest.c
configure:3634: $? = 0
configure:3634: result: yes
configure:3634: checking for syslog.h
configure:3634: result: yes
configure:3634: checking for unistd.h
configure:3634: result: yes
configure:3646: checking for pid_t
configure:3646: result: yes
configure:3657: checking for size_t
configure:3657: result: yes
configure:3668: checking for ssize_t
configure:3668: result: yes
configure:3683: checking for vfork.h
configure:3683: result: no
configure:3696: checking for fork
configure:3696: result: yes
configure:3696: checking for vfork
configure:3696: result: yes
configure:3706: checking for working fork
configure:3728: cc -o conftest -O2 -pipe  -fstack-protector-strong -fno-strict-aliasing    -fstack-protector-strong  conftest.c -lpthread  >&5
configure:3728: $? = 0
configure:3728: ./conftest
configure:3728: $? = 0
configure:3738: result: yes
configure:3759: checking for working vfork
configure:3869: result: yes
configure:3896: checking for stdlib.h
configure:3896: result: yes
configure:3906: checking for GNU libc compatible malloc
configure:3940: result: yes
configure:3963: checking for stdlib.h
configure:3963: result: yes
configure:3973: checking for GNU libc compatible realloc
configure:3997: cc -o conftest -O2 -pipe  -fstack-protector-strong -fno-strict-aliasing    -fstack-protector-strong  conftest.c -lpthread  >&5
configure:3997: $? = 0
configure:3997: ./conftest
configure:3997: $? = 0
configure:4007: result: yes
configure:4031: checking for dup2
configure:4031: result: yes
configure:4031: checking for memset
configure:4031: result: yes
configure:4031: checking for socket
configure:4031: cc -o conftest -O2 -pipe  -fstack-protector-strong -fno-strict-aliasing    -fstack-protector-strong  conftest.c -lpthread  >&5
configure:4031: $? = 0
configure:4031: result: yes
configure:4031: checking for strchr
configure:4031: result: yes
configure:4031: checking for strdup
configure:4031: result: yes
configure:4031: checking for strerror
configure:4031: result: yes
configure:4157: creating ./config.status

## ---------------------- ##
## Running config.status. ##
## ---------------------- ##

This file was extended by pwol config.status 1.5, which was
generated by GNU Autoconf 2.69.  Invocation command line was

  CONFIG_FILES    = 
  CONFIG_HEADERS  = 
  CONFIG_LINKS    = 
  CONFIG_COMMANDS = 
  $ ./config.status 

on filur00

config.status:830: creating Makefile
config.status:830: creating pwol.1
config.status:830: creating pwol.conf.5
config.status:830: creating pkgs/Makefile.port
config.status:830: creating config.h

## ---------------- ##
## Cache variables. ##
## ---------------- ##

ac_cv_c_compiler_gnu=yes
ac_cv_c_int16_t=yes
ac_cv_c_int32_t=yes
ac_cv_c_int64_t=yes
ac_cv_c_int8_t=yes
ac_cv_c_uint16_t=yes
ac_cv_c_uint32_t=yes
ac_cv_c_uint64_t=yes
ac_cv_c_uint8_t=yes
ac_cv_env_CC_set=set
ac_cv_env_CC_value=cc
ac_cv_env_CFLAGS_set=set
ac_cv_env_CFLAGS_value='-O2 -pipe  -fstack-protector-strong -fno-strict-aliasing '
ac_cv_env_CPPFLAGS_set=set
ac_cv_env_CPPFLAGS_value=''
ac_cv_env_CPP_set=set
ac_cv_env_CPP_value=cpp
ac_cv_env_LDFLAGS_set=set
ac_cv_env_LDFLAGS_value=' -fstack-protector-strong '
ac_cv_env_LIBS_set=set
ac_cv_env_LIBS_value=''
ac_cv_env_build_alias_set=set
ac_cv_env_build_alias_value=amd64-portbld-freebsd11.3
ac_cv_env_host_alias_set=''
ac_cv_env_host_alias_value=''
ac_cv_env_target_alias_set=''
ac_cv_env_target_alias_value=''
ac_cv_func___b64_ntop=yes
ac_cv_func___b64_pton=yes
ac_cv_func__getlong=yes
ac_cv_func__getshort=yes
ac_cv_func__stat=yes
ac_cv_func_abs=yes
ac_cv_func_accept4=yes
ac_cv_func_accept=yes
ac_cv_func_acl_create_entry_np=yes
ac_cv_func_acl_delete_def_file=yes
ac_cv_func_acl_delete_fd_np=yes
ac_cv_func_acl_delete_file_np=yes
ac_cv_func_acl_free=yes
ac_cv_func_acl_from_text=yes
ac_cv_func_acl_get_fd=yes
ac_cv_func_acl_get_file=yes
ac_cv_func_acl_set_fd=yes
ac_cv_func_acl_set_file=yes
ac_cv_func_alarm=yes
ac_cv_func_alloca=yes
ac_cv_func_alphasort=yes
ac_cv_func_arc4random=yes
ac_cv_func_arc4random_buf=yes
ac_cv_func_arc4random_uniform=yes
ac_cv_func_argz_count=no
ac_cv_func_argz_next=no
ac_cv_func_argz_stringify=no
ac_cv_func_asprintf=yes
ac_cv_func_atexit=yes
ac_cv_func_atoll=yes
ac_cv_func_basename=yes
ac_cv_func_bcmp=yes
ac_cv_func_bcopy=yes
ac_cv_func_bindresvport_sa=yes
ac_cv_func_bsearch=yes
ac_cv_func_btowc=yes
ac_cv_func_bzero=yes
ac_cv_func_calloc=yes
ac_cv_func_chown=yes
ac_cv_func_clock=yes
ac_cv_func_clock_gettime=yes
ac_cv_func_closedir=yes
ac_cv_func_closefrom=yes
ac_cv_func_daemon=yes
ac_cv_func_dirfd=yes
ac_cv_func_dirname=yes
ac_cv_func_dlopen=yes
ac_cv_func_dprintf=yes
ac_cv_func_dup2=yes
ac_cv_func_eaccess=yes
ac_cv_func_endgrent=yes
ac_cv_func_endutent=no
ac_cv_func_endutxent=yes
ac_cv_func_err=yes
ac_cv_func_errx=yes
ac_cv_func_fchmod=yes
ac_cv_func_fchown=yes
ac_cv_func_fcntl=yes
ac_cv_func_ffs=yes
ac_cv_func_ffsl=yes
ac_cv_func_ffsll=yes
ac_cv_func_fileno=yes
ac_cv_func_fls=yes
ac_cv_func_flsl=yes
ac_cv_func_flsll=yes
ac_cv_func_fork=yes
ac_cv_func_fork_working=yes
ac_cv_func_fork_works=yes
ac_cv_func_fprintf=yes
ac_cv_func_fpurge=yes
ac_cv_func_freeaddrinfo=yes
ac_cv_func_fstat=yes
ac_cv_func_fstatat=yes
ac_cv_func_fstatfs=yes
ac_cv_func_fstatvfs=yes
ac_cv_func_fsync=yes
ac_cv_func_futimes=yes
ac_cv_func_fwprintf=yes
ac_cv_func_gai_strerror=yes
ac_cv_func_getaddrinfo=yes
ac_cv_func_getcwd=yes
ac_cv_func_getdelim=yes
ac_cv_func_getdtablesize=yes
ac_cv_func_getegid=yes
ac_cv_func_getenv=yes
ac_cv_func_geteuid=yes
ac_cv_func_getgid=yes
ac_cv_func_getgrent=yes
ac_cv_func_getgrouplist=yes
ac_cv_func_gethostbyname=yes
ac_cv_func_gethostname=yes
ac_cv_func_getline=yes
ac_cv_func_getnameinfo=yes
ac_cv_func_getopt=yes
ac_cv_func_getopt_long_only=yes
ac_cv_func_getpagesize=yes
ac_cv_func_getpeereid=yes
ac_cv_func_getpgid=yes
ac_cv_func_getpgrp=yes
ac_cv_func_getpgrp_void=yes
ac_cv_func_getpid=yes
ac_cv_func_getrlimit=yes
ac_cv_func_getrusage=yes
ac_cv_func_gettimeofday=yes
ac_cv_func_getttyent=yes
ac_cv_func_getuid=yes
ac_cv_func_getutent=no
ac_cv_func_getutid=no
ac_cv_func_getutline=no
ac_cv_func_getutxent=yes
ac_cv_func_getutxid=yes
ac_cv_func_getutxline=yes
ac_cv_func_getutxuser=yes
ac_cv_func_getwd=yes
ac_cv_func_glob=yes
ac_cv_func_group_from_gid=yes
ac_cv_func_index=yes
ac_cv_func_inet_aton=yes
ac_cv_func_inet_ntoa=yes
ac_cv_func_inet_ntop=yes
ac_cv_func_innetgr=yes
ac_cv_func_insque=yes
ac_cv_func_isascii=yes
ac_cv_func_isblank=yes
ac_cv_func_issetugid=yes
ac_cv_func_iswblank=yes
ac_cv_func_iswcntrl=yes
ac_cv_func_iswctype=yes
ac_cv_func_kill=yes
ac_cv_func_killpg=yes
ac_cv_func_labs=yes
ac_cv_func_link=yes
ac_cv_func_llabs=yes
ac_cv_func_localtime=yes
ac_cv_func_login_getcapbool=yes
ac_cv_func_lstat=yes
ac_cv_func_lstat_dereferences_slashed_symlink=yes
ac_cv_func_malloc=yes
ac_cv_func_malloc_0_nonnull=yes
ac_cv_func_mblen=yes
ac_cv_func_mbrlen=yes
ac_cv_func_mbrtowc=yes
ac_cv_func_mbsinit=yes
ac_cv_func_mbsnrtowcs=yes
ac_cv_func_mbsrtowcs=yes
ac_cv_func_mbstowcs=yes
ac_cv_func_mbtowc=yes
ac_cv_func_memchr=yes
ac_cv_func_memcmp=yes
ac_cv_func_memcpy=yes
ac_cv_func_memmove=yes
ac_cv_func_memset=yes
ac_cv_func_mincore=yes
ac_cv_func_mkdtemp=yes
ac_cv_func_mkstemp=yes
ac_cv_func_mkstemps=yes
ac_cv_func_mktemp=yes
ac_cv_func_mktemps=yes
ac_cv_func_mlock=yes
ac_cv_func_mmap=yes
ac_cv_func_mmap_fixed_mapped=yes
ac_cv_func_mprotect=yes
ac_cv_func_munlock=yes
ac_cv_func_munmap=yes
ac_cv_func_newlocale=yes
ac_cv_func_nl_langinfo=yes
ac_cv_func_obstacks=no
ac_cv_func_opendir=yes
ac_cv_func_pam_getenvlist=yes
ac_cv_func_pam_putenv=yes
ac_cv_func_pathconf=yes
ac_cv_func_pipe=yes
ac_cv_func_poll=yes
ac_cv_func_posix_spawn=yes
ac_cv_func_pread=yes
ac_cv_func_printf=yes
ac_cv_func_psignal=yes
ac_cv_func_pstat_getdynamic=no
ac_cv_func_pthread_cond_broadcast=yes
ac_cv_func_pthread_cond_destroy=yes
ac_cv_func_pthread_cond_init=yes
ac_cv_func_pthread_cond_signal=yes
ac_cv_func_pthread_cond_timedwait=yes
ac_cv_func_pthread_cond_wait=yes
ac_cv_func_pthread_equal=yes
ac_cv_func_pthread_exit=yes
ac_cv_func_pthread_mutex_destroy=yes
ac_cv_func_pthread_mutex_init=yes
ac_cv_func_pthread_mutex_lock=yes
ac_cv_func_pthread_mutex_unlock=yes
ac_cv_func_pthread_self=yes
ac_cv_func_putc=yes
ac_cv_func_putc_unlocked=yes
ac_cv_func_putchar=yes
ac_cv_func_putchar_unlocked=yes
ac_cv_func_putenv=yes
ac_cv_func_pututline=no
ac_cv_func_pututxline=yes
ac_cv_func_putw=yes
ac_cv_func_pwrite=yes
ac_cv_func_raise=yes
ac_cv_func_rand=yes
ac_cv_func_random=yes
ac_cv_func_rawmemchr=no
ac_cv_func_readdir=yes
ac_cv_func_readlink=yes
ac_cv_func_readlinkat=yes
ac_cv_func_readpassphrase=yes
ac_cv_func_realloc_0_nonnull=yes
ac_cv_func_realpath=yes
ac_cv_func_recvmsg=yes
ac_cv_func_remque=yes
ac_cv_func_rename=yes
ac_cv_func_rindex=yes
ac_cv_func_rresvport_af=yes
ac_cv_func_scandir=yes
ac_cv_func_scandir_b=yes
ac_cv_func_sched_yield=yes
ac_cv_func_select=yes
ac_cv_func_sendmsg=yes
ac_cv_func_setegid=yes
ac_cv_func_setenv=yes
ac_cv_func_seteuid=yes
ac_cv_func_setgid=yes
ac_cv_func_setgrent=yes
ac_cv_func_setgroupent=yes
ac_cv_func_setgroups=yes
ac_cv_func_setlinebuf=yes
ac_cv_func_setlocale=yes
ac_cv_func_setlogin=yes
ac_cv_func_setpassent=yes
ac_cv_func_setpgid=yes
ac_cv_func_setproctitle=yes
ac_cv_func_setregid=yes
ac_cv_func_setresgid=yes
ac_cv_func_setresuid=yes
ac_cv_func_setreuid=yes
ac_cv_func_setrlimit=yes
ac_cv_func_setsid=yes
ac_cv_func_setsockopt=yes
ac_cv_func_setuid=yes
ac_cv_func_setutent=no
ac_cv_func_setutxdb=yes
ac_cv_func_setutxent=yes
ac_cv_func_setvbuf=yes
ac_cv_func_shmget=yes
ac_cv_func_sigaction=yes
ac_cv_func_sigaltstack=yes
ac_cv_func_sigblock=yes
ac_cv_func_siginterrupt=yes
ac_cv_func_sigmask=yes
ac_cv_func_sigprocmask=yes
ac_cv_func_sigsetmask=yes
ac_cv_func_sigvec=yes
ac_cv_func_sleep=yes
ac_cv_func_snprintf=yes
ac_cv_func_socket=yes
ac_cv_func_socketpair=yes
ac_cv_func_sprintf=yes
ac_cv_func_srand=yes
ac_cv_func_srandom=yes
ac_cv_func_stat=yes
ac_cv_func_statfs=yes
ac_cv_func_statvfs=yes
ac_cv_func_stpcpy=yes
ac_cv_func_stpncpy=yes
ac_cv_func_strbrk=yes
ac_cv_func_strcasecmp=yes
ac_cv_func_strcasecmp_l=yes
ac_cv_func_strcasestr=yes
ac_cv_func_strcasestr_l=yes
ac_cv_func_strchr=yes
ac_cv_func_strchrnul=yes
ac_cv_func_strcspn=yes
ac_cv_func_strdup=yes
ac_cv_func_strerror=yes
ac_cv_func_strerror_r=yes
ac_cv_func_strftime=yes
ac_cv_func_strlcat=yes
ac_cv_func_strlcpy=yes
ac_cv_func_strlen=yes
ac_cv_func_strmode=yes
ac_cv_func_strncasecmp=yes
ac_cv_func_strncmp=yes
ac_cv_func_strncmp_working=yes
ac_cv_func_strndup=yes
ac_cv_func_strnlen=yes
ac_cv_func_strnlen_working=yes
ac_cv_func_strnstr=yes
ac_cv_func_strpbrk=yes
ac_cv_func_strptime=yes
ac_cv_func_strrchr=yes
ac_cv_func_strsep=yes
ac_cv_func_strsignal=yes
ac_cv_func_strstr=yes
ac_cv_func_strtod=yes
ac_cv_func_strtof=yes
ac_cv_func_strtol=yes
ac_cv_func_strtold=yes
ac_cv_func_strtoll=yes
ac_cv_func_strtonum=yes
ac_cv_func_strtoul=yes
ac_cv_func_strtoull=yes
ac_cv_func_symlink=yes
ac_cv_func_sysconf=yes
ac_cv_func_sysctl=yes
ac_cv_func_tcgetpgrp=yes
ac_cv_func_time=yes
ac_cv_func_times=yes
ac_cv_func_tmpnam=yes
ac_cv_func_towlower=yes
ac_cv_func_truncate=yes
ac_cv_func_tsearch=yes
ac_cv_func_uname=yes
ac_cv_func_unlink=yes
ac_cv_func_unsetenv=yes
ac_cv_func_uselocale=yes
ac_cv_func_user_from_uid=yes
ac_cv_func_usleep=yes
ac_cv_func_utime=yes
ac_cv_func_utimes=yes
ac_cv_func_utmpname=no
ac_cv_func_vasprintf=yes
ac_cv_func_vdprintf=yes
ac_cv_func_vfork=yes
ac_cv_func_vfork_working=yes
ac_cv_func_vfork_works=yes
ac_cv_func_vfprintf=yes
ac_cv_func_vprintf=yes
ac_cv_func_vsnprintf=yes
ac_cv_func_vsprintf=yes
ac_cv_func_wait2=yes
ac_cv_func_wait3=yes
ac_cv_func_wait3_rusage=yes
ac_cv_func_wait4=yes
ac_cv_func_wait6=yes
ac_cv_func_wait=yes
ac_cv_func_waitid=yes
ac_cv_func_waitpid=yes
ac_cv_func_warn=yes
ac_cv_func_warnx=yes
ac_cv_func_wcrtomb=yes
ac_cv_func_wcscoll=yes
ac_cv_func_wcslen=yes
ac_cv_func_wcsnlen=yes
ac_cv_func_wcswidth=yes
ac_cv_func_wctob=yes
ac_cv_func_wcwidth=yes
ac_cv_func_wmemchr=yes
ac_cv_func_wmemcpy=yes
ac_cv_func_yield=no
ac_cv_func_yp_match=yes
ac_cv_have___va_copy=yes
ac_cv_have_clock_t=yes
ac_cv_have_control_in_msghdr=yes
ac_cv_have_decl_GLOB_NOMATCH=yes
ac_cv_have_decl_LLONG_MAX=yes
ac_cv_have_decl_MAXSYMLINKS=yes
ac_cv_have_decl_O_NONBLOCK=yes
ac_cv_have_decl_RLIMIT_NPROC=yes
ac_cv_have_decl_SHUT_RD=yes
ac_cv_have_decl__Exit=yes
ac_cv_have_decl_abort=yes
ac_cv_have_decl_alarm=yes
ac_cv_have_decl_alphasort=yes
ac_cv_have_decl_atof=yes
ac_cv_have_decl_atol=yes
ac_cv_have_decl_atoll=yes
ac_cv_have_decl_btowc=yes
ac_cv_have_decl_calloc=yes
ac_cv_have_decl_chdir=yes
ac_cv_have_decl_chown=yes
ac_cv_have_decl_clearerr_unlocked=yes
ac_cv_have_decl_clock=yes
ac_cv_have_decl_closedir=yes
ac_cv_have_decl_dprintf=yes
ac_cv_have_decl_dup2=yes
ac_cv_have_decl_dup=yes
ac_cv_have_decl_endusershell=yes
ac_cv_have_decl_errno=yes
ac_cv_have_decl_faccessat=yes
ac_cv_have_decl_fchdir=yes
ac_cv_have_decl_fchmodat=yes
ac_cv_have_decl_fchownat=yes
ac_cv_have_decl_fcntl=yes
ac_cv_have_decl_fdopendir=yes
ac_cv_have_decl_feof_unlocked=yes
ac_cv_have_decl_feof_unlocked_fgets_unlocked=yes
ac_cv_have_decl_ferror_unlocked=yes
ac_cv_have_decl_ffsl=yes
ac_cv_have_decl_ffsll=yes
ac_cv_have_decl_fpurge=yes
ac_cv_have_decl_free=yes
ac_cv_have_decl_frexpl=yes
ac_cv_have_decl_fseeko=yes
ac_cv_have_decl_fstat=yes
ac_cv_have_decl_fstatat=yes
ac_cv_have_decl_fsync=yes
ac_cv_have_decl_ftello=yes
ac_cv_have_decl_ftruncate=yes
ac_cv_have_decl_getc_unlocked=yes
ac_cv_have_decl_getchar_unlocked=yes
ac_cv_have_decl_getcwd=yes
ac_cv_have_decl_getdelim=yes
ac_cv_have_decl_getdomainname=yes
ac_cv_have_decl_getdtablesize=yes
ac_cv_have_decl_getenv=yes
ac_cv_have_decl_getgroups=yes
ac_cv_have_decl_gethostname=yes
ac_cv_have_decl_getline=yes
ac_cv_have_decl_getloadavg=yes
ac_cv_have_decl_getlogin=yes
ac_cv_have_decl_getlogin_r=yes
ac_cv_have_decl_getopt=yes
ac_cv_have_decl_getpagesize=yes
ac_cv_have_decl_getrlimit=yes
ac_cv_have_decl_getrusage=yes
ac_cv_have_decl_getsubopt=yes
ac_cv_have_decl_gettimeofday=yes
ac_cv_have_decl_getusershell=yes
ac_cv_have_decl_getwd=yes
ac_cv_have_decl_grantpt=yes
ac_cv_have_decl_h_errno=yes
ac_cv_have_decl_imaxabs=yes
ac_cv_have_decl_imaxdiv=yes
ac_cv_have_decl_initstate=yes
ac_cv_have_decl_isatty=yes
ac_cv_have_decl_isblank=yes
ac_cv_have_decl_iswblank=yes
ac_cv_have_decl_iswctype=yes
ac_cv_have_decl_lchmod=yes
ac_cv_have_decl_lchown=yes
ac_cv_have_decl_link=yes
ac_cv_have_decl_linkat=yes
ac_cv_have_decl_lseek=yes
ac_cv_have_decl_lstat=yes
ac_cv_have_decl_malloc=yes
ac_cv_have_decl_mbrlen=yes
ac_cv_have_decl_mbrtowc=yes
ac_cv_have_decl_mbsinit=yes
ac_cv_have_decl_mbsnrtowcs=yes
ac_cv_have_decl_mbsrtowcs=yes
ac_cv_have_decl_memmem=yes
ac_cv_have_decl_memrchr=yes
ac_cv_have_decl_mkdirat=yes
ac_cv_have_decl_mkdtemp=yes
ac_cv_have_decl_mkfifo=yes
ac_cv_have_decl_mkfifoat=yes
ac_cv_have_decl_mknod=yes
ac_cv_have_decl_mknodat=yes
ac_cv_have_decl_mkstemp=yes
ac_cv_have_decl_nl_langinfo=yes
ac_cv_have_decl_offsetof=yes
ac_cv_have_decl_openat=yes
ac_cv_have_decl_opendir=yes
ac_cv_have_decl_pclose=yes
ac_cv_have_decl_pipe=yes
ac_cv_have_decl_popen=yes
ac_cv_have_decl_posix_openpt=yes
ac_cv_have_decl_posix_spawn=yes
ac_cv_have_decl_posix_spawn_file_actions_addclose=yes
ac_cv_have_decl_posix_spawn_file_actions_adddup2=yes
ac_cv_have_decl_posix_spawn_file_actions_addopen=yes
ac_cv_have_decl_posix_spawn_file_actions_destroy=yes
ac_cv_have_decl_posix_spawn_file_actions_init=yes
ac_cv_have_decl_posix_spawnattr_destroy=yes
ac_cv_have_decl_posix_spawnattr_getflags=yes
ac_cv_have_decl_posix_spawnattr_getpgroup=yes
ac_cv_have_decl_posix_spawnattr_getschedparam=yes
ac_cv_have_decl_posix_spawnattr_getschedpolicy=yes
ac_cv_have_decl_posix_spawnattr_getsigdefault=yes
ac_cv_have_decl_posix_spawnattr_getsigmask=yes
ac_cv_have_decl_posix_spawnattr_init=yes
ac_cv_have_decl_posix_spawnattr_setflags=yes
ac_cv_have_decl_posix_spawnattr_setpgroup=yes
ac_cv_have_decl_posix_spawnattr_setschedparam=yes
ac_cv_have_decl_posix_spawnattr_setschedpolicy=yes
ac_cv_have_decl_posix_spawnattr_setsigdefault=yes
ac_cv_have_decl_posix_spawnattr_setsigmask=yes
ac_cv_have_decl_posix_spawnp=yes
ac_cv_have_decl_pread=yes
ac_cv_have_decl_pselect=yes
ac_cv_have_decl_pthread_sigmask=yes
ac_cv_have_decl_ptsname=yes
ac_cv_have_decl_putc_unlocked=yes
ac_cv_have_decl_putchar_unlocked=yes
ac_cv_have_decl_pwrite=yes
ac_cv_have_decl_random=yes
ac_cv_have_decl_rawmemchr=yes
ac_cv_have_decl_readdir=yes
ac_cv_have_decl_readlink=yes
ac_cv_have_decl_readlinkat=yes
ac_cv_have_decl_realloc=yes
ac_cv_have_decl_realpath=yes
ac_cv_have_decl_renameat=yes
ac_cv_have_decl_rewinddir=yes
ac_cv_have_decl_rmdir=yes
ac_cv_have_decl_rpmatch=yes
ac_cv_have_decl_sbrk=yes
ac_cv_have_decl_scandir=yes
ac_cv_have_decl_select=yes
ac_cv_have_decl_setenv=yes
ac_cv_have_decl_sethostname=yes
ac_cv_have_decl_setlocale=yes
ac_cv_have_decl_setrlimit=yes
ac_cv_have_decl_setstate=yes
ac_cv_have_decl_setusershell=yes
ac_cv_have_decl_sigaction=yes
ac_cv_have_decl_sigaddset=yes
ac_cv_have_decl_sigaltstack=yes
ac_cv_have_decl_sigdelset=yes
ac_cv_have_decl_sigemptyset=yes
ac_cv_have_decl_sigfillset=yes
ac_cv_have_decl_sigismember=yes
ac_cv_have_decl_sigpending=yes
ac_cv_have_decl_sigprocmask=yes
ac_cv_have_decl_sleep=yes
ac_cv_have_decl_snprintf=yes
ac_cv_have_decl_srandom=yes
ac_cv_have_decl_stat=yes
ac_cv_have_decl_stpcpy=yes
ac_cv_have_decl_stpncpy=yes
ac_cv_have_decl_strcasestr=yes
ac_cv_have_decl_strdup=yes
ac_cv_have_decl_strerror_r=yes
ac_cv_have_decl_strncat=yes
ac_cv_have_decl_strndup=yes
ac_cv_have_decl_strnlen=yes
ac_cv_have_decl_strpbrk=yes
ac_cv_have_decl_strsep=yes
ac_cv_have_decl_strsignal=yes
ac_cv_have_decl_strstr=yes
ac_cv_have_decl_strtod=yes
ac_cv_have_decl_strtoimax=yes
ac_cv_have_decl_strtok_r=yes
ac_cv_have_decl_strtoll=yes
ac_cv_have_decl_strtoull=yes
ac_cv_have_decl_strtoumax=yes
ac_cv_have_decl_symlink=yes
ac_cv_have_decl_symlinkat=yes
ac_cv_have_decl_sys_siglist=yes
ac_cv_have_decl_tcsendbreak=yes
ac_cv_have_decl_times=yes
ac_cv_have_decl_tmpfile=yes
ac_cv_have_decl_towctrans=yes
ac_cv_have_decl_ttyname_r=yes
ac_cv_have_decl_unlink=yes
ac_cv_have_decl_unlinkat=yes
ac_cv_have_decl_unlockpt=yes
ac_cv_have_decl_unsetenv=yes
ac_cv_have_decl_usleep=yes
ac_cv_have_decl_vasprintf=yes
ac_cv_have_decl_vdprintf=yes
ac_cv_have_decl_vsnprintf=yes
ac_cv_have_decl_waitpid=yes
ac_cv_have_decl_wcpcpy=yes
ac_cv_have_decl_wcpncpy=yes
ac_cv_have_decl_wcrtomb=yes
ac_cv_have_decl_wcscasecmp=yes
ac_cv_have_decl_wcscat=yes
ac_cv_have_decl_wcschr=yes
ac_cv_have_decl_wcscmp=yes
ac_cv_have_decl_wcscoll=yes
ac_cv_have_decl_wcscpy=yes
ac_cv_have_decl_wcscspn=yes
ac_cv_have_decl_wcsdup=yes
ac_cv_have_decl_wcslen=yes
ac_cv_have_decl_wcsncasecmp=yes
ac_cv_have_decl_wcsncat=yes
ac_cv_have_decl_wcsncmp=yes
ac_cv_have_decl_wcsncpy=yes
ac_cv_have_decl_wcsnlen=yes
ac_cv_have_decl_wcsnrtombs=yes
ac_cv_have_decl_wcspbrk=yes
ac_cv_have_decl_wcsrchr=yes
ac_cv_have_decl_wcsrtombs=yes
ac_cv_have_decl_wcsspn=yes
ac_cv_have_decl_wcsstr=yes
ac_cv_have_decl_wcstok=yes
ac_cv_have_decl_wcswidth=yes
ac_cv_have_decl_wcsxfrm=yes
ac_cv_have_decl_wctob=yes
ac_cv_have_decl_wctrans=yes
ac_cv_have_decl_wctype=yes
ac_cv_have_decl_wcwidth=yes
ac_cv_have_decl_wmemchr=yes
ac_cv_have_decl_wmemcmp=yes
ac_cv_have_decl_wmemcpy=yes
ac_cv_have_decl_wmemmove=yes
ac_cv_have_decl_wmemset=yes
ac_cv_have_decl_writev=yes
ac_cv_have_getopt_optreset=yes
ac_cv_have_int64_t=yes
ac_cv_have_intxx_t=yes
ac_cv_have_mode_t=yes
ac_cv_have_pid_t=yes
ac_cv_have_pw_change_in_struct_passwd=yes
ac_cv_have_pw_class_in_struct_passwd=yes
ac_cv_have_pw_expire_in_struct_passwd=yes
ac_cv_have_sa_family_t=yes
ac_cv_have_size_t=yes
ac_cv_have_ss_family_in_struct_ss=yes
ac_cv_have_ssize_t=yes
ac_cv_have_struct_addrinfo=yes
ac_cv_have_struct_in6_addr=yes
ac_cv_have_struct_sockaddr_in6=yes
ac_cv_have_struct_sockaddr_storage=yes
ac_cv_have_struct_timeval=yes
ac_cv_have_u_char=yes
ac_cv_have_u_int64_t=yes
ac_cv_have_u_int=yes
ac_cv_have_u_intxx_t=yes
ac_cv_have_va_copy=yes
ac_cv_header_alloca_h=no
ac_cv_header_argz_h=no
ac_cv_header_arpa_inet_h=yes
ac_cv_header_arpa_nameser_h=yes
ac_cv_header_byteswap_h=no
ac_cv_header_ctype_h=yes
ac_cv_header_dirent_h=yes
ac_cv_header_dl_h=no
ac_cv_header_dlfcn_h=yes
ac_cv_header_elf_h=yes
ac_cv_header_err_h=yes
ac_cv_header_errno_h=yes
ac_cv_header_fcntl_h=yes
ac_cv_header_float_h=yes
ac_cv_header_floatingpoint_h=yes
ac_cv_header_getopt_h=yes
ac_cv_header_glob_h=yes
ac_cv_header_inttypes_h=yes
ac_cv_header_langinfo_h=yes
ac_cv_header_libgen_h=yes
ac_cv_header_libutil_h=yes
ac_cv_header_limits_h=yes
ac_cv_header_locale_h=yes
ac_cv_header_login_cap_h=yes
ac_cv_header_math_h=yes
ac_cv_header_memory_h=yes
ac_cv_header_minix_config_h=no
ac_cv_header_net_if_h=yes
ac_cv_header_net_if_media_h=yes
ac_cv_header_net_if_tap_h=yes
ac_cv_header_net_if_tun_h=yes
ac_cv_header_netdb_h=yes
ac_cv_header_netinet_in_h=yes
ac_cv_header_paths_h=yes
ac_cv_header_poll_h=yes
ac_cv_header_pthread_h=yes
ac_cv_header_pwd_h=yes
ac_cv_header_random_h=no
ac_cv_header_readpassphrase_h=yes
ac_cv_header_resolv_h=yes
ac_cv_header_rpc_types_h=yes
ac_cv_header_sched_h=yes
ac_cv_header_search_h=yes
ac_cv_header_security_pam_appl_h=yes
ac_cv_header_signal_h=yes
ac_cv_header_spawn_h=yes
ac_cv_header_stdarg_h=yes
ac_cv_header_stdbool_h=yes
ac_cv_header_stdc=yes
ac_cv_header_stddef_h=yes
ac_cv_header_stdint_h=yes
ac_cv_header_stdio_h=yes
ac_cv_header_stdlib_h=yes
ac_cv_header_string_h=yes
ac_cv_header_strings_h=yes
ac_cv_header_sys_acl_h=yes
ac_cv_header_sys_cdefs_h=yes
ac_cv_header_sys_fcntl_h=yes
ac_cv_header_sys_file_h=yes
ac_cv_header_sys_ioctl_h=yes
ac_cv_header_sys_mman_h=yes
ac_cv_header_sys_mount_h=yes
ac_cv_header_sys_msg_h=yes
ac_cv_header_sys_param_h=yes
ac_cv_header_sys_poll_h=yes
ac_cv_header_sys_ptrace_h=yes
ac_cv_header_sys_resource_h=yes
ac_cv_header_sys_select_h=yes
ac_cv_header_sys_socket_h=yes
ac_cv_header_sys_stat_h=yes
ac_cv_header_sys_statvfs_h=yes
ac_cv_header_sys_sysctl_h=yes
ac_cv_header_sys_time_h=yes
ac_cv_header_sys_timers_h=yes
ac_cv_header_sys_times_h=yes
ac_cv_header_sys_types_h=yes
ac_cv_header_sys_uio_h=yes
ac_cv_header_sys_un_h=yes
ac_cv_header_sys_wait_h=yes
ac_cv_header_syslog_h=yes
ac_cv_header_time_h=yes
ac_cv_header_ttyent_h=yes
ac_cv_header_ucontext_h=yes
ac_cv_header_unistd_h=yes
ac_cv_header_utime_h=yes
ac_cv_header_utmp_h=no
ac_cv_header_utmpx_h=yes
ac_cv_header_vfork_h=no
ac_cv_header_vis_h=yes
ac_cv_header_wchar_h=yes
ac_cv_header_wctype_h=yes
ac_cv_header_zlib_h=yes
ac_cv_lib_crypt_crypt=yes
ac_cv_lib_edit_el_init=yes
ac_cv_lib_nsl_gethostbyname=no
ac_cv_lib_pam_pam_set_item=yes
ac_cv_lib_pthread_pthread_create=yes
ac_cv_lib_socket_connect=no
ac_cv_lib_z_deflate=yes
ac_cv_libc_defines___progname=yes
ac_cv_libc_defines_sys_errlist=yes
ac_cv_libc_defines_sys_nerr=yes
ac_cv_member_HEADER_ad=yes
ac_cv_member_struct___res_state_retrans=yes
ac_cv_member_struct_sigaction_sa_sigaction=yes
ac_cv_member_struct_sockaddr_in6_sin6_scope_id=yes
ac_cv_member_struct_stat_st_blksize=yes
ac_cv_objext=o
ac_cv_path_BZIP2=/usr/bin/bzip2
ac_cv_path_EGREP=/usr/bin/egrep
ac_cv_path_FGREP=/usr/bin/fgrep
ac_cv_path_GREP=/usr/bin/grep
ac_cv_path_GZIP=/usr/bin/gzip
ac_cv_path_MKTEMP_COMMAND=/usr/bin/mktemp
ac_cv_path_SED=/usr/bin/sed
ac_cv_path_install=/usr/bin/install
ac_cv_path_mkdir=/bin/mkdir
ac_cv_prog_AWK=/usr/bin/awk
ac_cv_prog_CPP=cpp
ac_cv_prog_SED=/usr/bin/sed
ac_cv_prog_ac_ct_CC=cc
ac_cv_prog_cc_c89=''
ac_cv_prog_cc_g=yes
ac_cv_prog_make_make_set=yes
ac_cv_sys_long_file_names=yes
ac_cv_type__Bool=yes
ac_cv_type_char=yes
ac_cv_type_char_p=yes
ac_cv_type_fsblkcnt_t=yes
ac_cv_type_fsfilcnt_t=yes
ac_cv_type_in_addr_t=yes
ac_cv_type_in_port_t=yes
ac_cv_type_int16_t=yes
ac_cv_type_int32_t=yes
ac_cv_type_int=yes
ac_cv_type_intmax_t=yes
ac_cv_type_long=yes
ac_cv_type_long_double=yes
ac_cv_type_long_long=yes
ac_cv_type_long_long_int=yes
ac_cv_type_mbstate_t=yes
ac_cv_type_mode_t=yes
ac_cv_type_nlink_t=yes
ac_cv_type_off_t=yes
ac_cv_type_pid_t=yes
ac_cv_type_posix_spawn_file_actions_t=yes
ac_cv_type_posix_spawnattr_t=yes
ac_cv_type_ptrdiff_t=yes
ac_cv_type_short=yes
ac_cv_type_sig_atomic_t=yes
ac_cv_type_sigset_t=yes
ac_cv_type_size_t=yes
ac_cv_type_socklen_t=yes
ac_cv_type_ssize_t=yes
ac_cv_type_stack_t=yes
ac_cv_type_struct_timespec=yes
ac_cv_type_u_char=yes
ac_cv_type_u_int16_t=yes
ac_cv_type_u_int32_t=yes
ac_cv_type_u_int8_t=yes
ac_cv_type_u_int=yes
ac_cv_type_u_long=yes
ac_cv_type_u_short=yes
ac_cv_type_uid_t=yes
ac_cv_type_uintptr_t=yes
ac_cv_type_unsigned_char=yes
ac_cv_type_unsigned_int=yes
ac_cv_type_unsigned_long=yes
ac_cv_type_unsigned_long_long=yes
ac_cv_type_unsigned_long_long_int=yes
ac_cv_type_unsigned_short=yes
ac_cv_type_volatile_sig_atomic_t=yes
ac_cv_type_wchar_t=yes
ac_cv_type_wint_t=yes
am_cv_prog_tar_ustar=/usr/bin/tar
cl_cv_prog_LN=/bin/ln
cl_cv_prog_cp='/bin/cp -p'
gl_cv_func_btowc_eof=yes
gl_cv_func_btowc_nul=yes
gl_cv_func_fcntl_f_dupfd_cloexec=yes
gl_cv_func_fnmatch_posix=yes
gl_cv_func_fopen_slash=yes
gl_cv_func_frexp_no_libm=yes
gl_cv_func_fseeko=yes
gl_cv_func_ftello=yes
gl_cv_func_getcwd_null=yes
gl_cv_func_getcwd_posix_signature=yes
gl_cv_func_getopt_posix=yes
gl_cv_func_isnand_no_libm=yes
gl_cv_func_ldexp_no_libm=yes
gl_cv_func_lseek_pipe=yes
gl_cv_func_lstat_dereferences_slashed_symlink=yes
gl_cv_func_malloc_0_nonnull=1
gl_cv_func_malloc_posix=yes
gl_cv_func_mbrtowc_incomplete_state=yes
gl_cv_func_mbrtowc_nul_retval=yes
gl_cv_func_mbrtowc_null_arg1=yes
gl_cv_func_mbrtowc_null_arg2=yes
gl_cv_func_mbrtowc_retval=yes
gl_cv_func_mbrtowc_sanitycheck=yes
gl_cv_func_open_slash=yes
gl_cv_func_printf_directive_a=yes
gl_cv_func_printf_directive_f=yes
gl_cv_func_printf_directive_ls=yes
gl_cv_func_printf_directive_n=yes
gl_cv_func_printf_flag_grouping=yes
gl_cv_func_printf_flag_leftadjust=yes
gl_cv_func_printf_flag_zero=yes
gl_cv_func_printf_infinite=yes
gl_cv_func_printf_long_double=yes
gl_cv_func_printf_positions=yes
gl_cv_func_printf_precision=yes
gl_cv_func_printf_sizes_c99=yes
gl_cv_func_sigprocmask=1
gl_cv_func_snprintf_retval_c99=yes
gl_cv_func_snprintf_size1=yes
gl_cv_func_snprintf_usable=yes
gl_cv_func_spawnattr_setschedparam=yes
gl_cv_func_spawnattr_setschedpolicy=yes
gl_cv_func_stat_dir_slash=yes
gl_cv_func_stat_file_slash=yes
gl_cv_func_stpncpy=yes
gl_cv_func_va_copy=yes
gl_cv_func_wcrtomb_retval=yes
gl_cv_have_include_next=yes
gl_cv_have_raw_decl__Exit=yes
gl_cv_have_raw_decl_alphasort=yes
gl_cv_have_raw_decl_atoll=yes
gl_cv_have_raw_decl_btowc=yes
gl_cv_have_raw_decl_chdir=yes
gl_cv_have_raw_decl_chown=yes
gl_cv_have_raw_decl_closedir=yes
gl_cv_have_raw_decl_dprintf=yes
gl_cv_have_raw_decl_dup2=yes
gl_cv_have_raw_decl_dup=yes
gl_cv_have_raw_decl_endusershell=yes
gl_cv_have_raw_decl_faccessat=yes
gl_cv_have_raw_decl_fchdir=yes
gl_cv_have_raw_decl_fchmodat=yes
gl_cv_have_raw_decl_fchownat=yes
gl_cv_have_raw_decl_fcntl=yes
gl_cv_have_raw_decl_fdopendir=yes
gl_cv_have_raw_decl_ffsl=yes
gl_cv_have_raw_decl_ffsll=yes
gl_cv_have_raw_decl_fpurge=yes
gl_cv_have_raw_decl_fseeko=yes
gl_cv_have_raw_decl_fstat=yes
gl_cv_have_raw_decl_fstatat=yes
gl_cv_have_raw_decl_fsync=yes
gl_cv_have_raw_decl_ftello=yes
gl_cv_have_raw_decl_ftruncate=yes
gl_cv_have_raw_decl_getcwd=yes
gl_cv_have_raw_decl_getdelim=yes
gl_cv_have_raw_decl_getdomainname=yes
gl_cv_have_raw_decl_getdtablesize=yes
gl_cv_have_raw_decl_getgroups=yes
gl_cv_have_raw_decl_gethostname=yes
gl_cv_have_raw_decl_getline=yes
gl_cv_have_raw_decl_getloadavg=yes
gl_cv_have_raw_decl_getlogin=yes
gl_cv_have_raw_decl_getlogin_r=yes
gl_cv_have_raw_decl_getpagesize=yes
gl_cv_have_raw_decl_getsubopt=yes
gl_cv_have_raw_decl_gettimeofday=yes
gl_cv_have_raw_decl_getusershell=yes
gl_cv_have_raw_decl_grantpt=yes
gl_cv_have_raw_decl_imaxabs=yes
gl_cv_have_raw_decl_imaxdiv=yes
gl_cv_have_raw_decl_initstate=yes
gl_cv_have_raw_decl_isatty=yes
gl_cv_have_raw_decl_iswctype=yes
gl_cv_have_raw_decl_lchmod=yes
gl_cv_have_raw_decl_lchown=yes
gl_cv_have_raw_decl_link=yes
gl_cv_have_raw_decl_linkat=yes
gl_cv_have_raw_decl_lseek=yes
gl_cv_have_raw_decl_lstat=yes
gl_cv_have_raw_decl_mbrlen=yes
gl_cv_have_raw_decl_mbrtowc=yes
gl_cv_have_raw_decl_mbsinit=yes
gl_cv_have_raw_decl_mbsnrtowcs=yes
gl_cv_have_raw_decl_mbsrtowcs=yes
gl_cv_have_raw_decl_memcpy=no
gl_cv_have_raw_decl_memmem=yes
gl_cv_have_raw_decl_memrchr=yes
gl_cv_have_raw_decl_mkdirat=yes
gl_cv_have_raw_decl_mkdtemp=yes
gl_cv_have_raw_decl_mkfifo=yes
gl_cv_have_raw_decl_mkfifoat=yes
gl_cv_have_raw_decl_mknod=yes
gl_cv_have_raw_decl_mknodat=yes
gl_cv_have_raw_decl_mkstemp=yes
gl_cv_have_raw_decl_nl_langinfo=yes
gl_cv_have_raw_decl_openat=yes
gl_cv_have_raw_decl_opendir=yes
gl_cv_have_raw_decl_pclose=yes
gl_cv_have_raw_decl_pipe=yes
gl_cv_have_raw_decl_popen=yes
gl_cv_have_raw_decl_posix_openpt=yes
gl_cv_have_raw_decl_posix_spawn=yes
gl_cv_have_raw_decl_posix_spawn_file_actions_addclose=yes
gl_cv_have_raw_decl_posix_spawn_file_actions_adddup2=yes
gl_cv_have_raw_decl_posix_spawn_file_actions_addopen=yes
gl_cv_have_raw_decl_posix_spawn_file_actions_destroy=yes
gl_cv_have_raw_decl_posix_spawn_file_actions_init=yes
gl_cv_have_raw_decl_posix_spawnattr_destroy=yes
gl_cv_have_raw_decl_posix_spawnattr_getflags=yes
gl_cv_have_raw_decl_posix_spawnattr_getpgroup=yes
gl_cv_have_raw_decl_posix_spawnattr_getschedparam=yes
gl_cv_have_raw_decl_posix_spawnattr_getschedpolicy=yes
gl_cv_have_raw_decl_posix_spawnattr_getsigdefault=yes
gl_cv_have_raw_decl_posix_spawnattr_getsigmask=yes
gl_cv_have_raw_decl_posix_spawnattr_init=yes
gl_cv_have_raw_decl_posix_spawnattr_setflags=yes
gl_cv_have_raw_decl_posix_spawnattr_setpgroup=yes
gl_cv_have_raw_decl_posix_spawnattr_setschedparam=yes
gl_cv_have_raw_decl_posix_spawnattr_setschedpolicy=yes
gl_cv_have_raw_decl_posix_spawnattr_setsigdefault=yes
gl_cv_have_raw_decl_posix_spawnattr_setsigmask=yes
gl_cv_have_raw_decl_posix_spawnp=yes
gl_cv_have_raw_decl_pread=yes
gl_cv_have_raw_decl_pselect=yes
gl_cv_have_raw_decl_pthread_sigmask=yes
gl_cv_have_raw_decl_ptsname=yes
gl_cv_have_raw_decl_pwrite=yes
gl_cv_have_raw_decl_random=yes
gl_cv_have_raw_decl_rawmemchr=yes
gl_cv_have_raw_decl_readdir=yes
gl_cv_have_raw_decl_readlink=yes
gl_cv_have_raw_decl_readlinkat=yes
gl_cv_have_raw_decl_realpath=yes
gl_cv_have_raw_decl_renameat=yes
gl_cv_have_raw_decl_rewinddir=yes
gl_cv_have_raw_decl_rmdir=yes
gl_cv_have_raw_decl_rpmatch=yes
gl_cv_have_raw_decl_scandir=yes
gl_cv_have_raw_decl_select=yes
gl_cv_have_raw_decl_setenv=yes
gl_cv_have_raw_decl_sethostname=yes
gl_cv_have_raw_decl_setlocale=yes
gl_cv_have_raw_decl_setstate=yes
gl_cv_have_raw_decl_setusershell=yes
gl_cv_have_raw_decl_sigaction=yes
gl_cv_have_raw_decl_sigaddset=yes
gl_cv_have_raw_decl_sigdelset=yes
gl_cv_have_raw_decl_sigemptyset=yes
gl_cv_have_raw_decl_sigfillset=yes
gl_cv_have_raw_decl_sigismember=yes
gl_cv_have_raw_decl_sigpending=yes
gl_cv_have_raw_decl_sigprocmask=yes
gl_cv_have_raw_decl_sleep=yes
gl_cv_have_raw_decl_snprintf=yes
gl_cv_have_raw_decl_srandom=yes
gl_cv_have_raw_decl_stat=yes
gl_cv_have_raw_decl_stpcpy=yes
gl_cv_have_raw_decl_stpncpy=yes
gl_cv_have_raw_decl_strcasestr=yes
gl_cv_have_raw_decl_strchrnul=yes
gl_cv_have_raw_decl_strdup=yes
gl_cv_have_raw_decl_strerror_r=yes
gl_cv_have_raw_decl_strncat=yes
gl_cv_have_raw_decl_strndup=yes
gl_cv_have_raw_decl_strnlen=yes
gl_cv_have_raw_decl_strpbrk=yes
gl_cv_have_raw_decl_strsep=yes
gl_cv_have_raw_decl_strsignal=yes
gl_cv_have_raw_decl_strtod=yes
gl_cv_have_raw_decl_strtoimax=yes
gl_cv_have_raw_decl_strtok_r=yes
gl_cv_have_raw_decl_strtoll=yes
gl_cv_have_raw_decl_strtoull=yes
gl_cv_have_raw_decl_strtoumax=yes
gl_cv_have_raw_decl_strverscmp=no
gl_cv_have_raw_decl_symlink=yes
gl_cv_have_raw_decl_symlinkat=yes
gl_cv_have_raw_decl_tmpfile=yes
gl_cv_have_raw_decl_towctrans=yes
gl_cv_have_raw_decl_ttyname_r=yes
gl_cv_have_raw_decl_unlink=yes
gl_cv_have_raw_decl_unlinkat=yes
gl_cv_have_raw_decl_unlockpt=yes
gl_cv_have_raw_decl_unsetenv=yes
gl_cv_have_raw_decl_usleep=yes
gl_cv_have_raw_decl_vdprintf=yes
gl_cv_have_raw_decl_vsnprintf=yes
gl_cv_have_raw_decl_waitpid=yes
gl_cv_have_raw_decl_wcpcpy=yes
gl_cv_have_raw_decl_wcpncpy=yes
gl_cv_have_raw_decl_wcrtomb=yes
gl_cv_have_raw_decl_wcscasecmp=yes
gl_cv_have_raw_decl_wcscat=yes
gl_cv_have_raw_decl_wcschr=yes
gl_cv_have_raw_decl_wcscmp=yes
gl_cv_have_raw_decl_wcscoll=yes
gl_cv_have_raw_decl_wcscpy=yes
gl_cv_have_raw_decl_wcscspn=yes
gl_cv_have_raw_decl_wcsdup=yes
gl_cv_have_raw_decl_wcslen=yes
gl_cv_have_raw_decl_wcsncasecmp=yes
gl_cv_have_raw_decl_wcsncat=yes
gl_cv_have_raw_decl_wcsncmp=yes
gl_cv_have_raw_decl_wcsncpy=yes
gl_cv_have_raw_decl_wcsnlen=yes
gl_cv_have_raw_decl_wcsnrtombs=yes
gl_cv_have_raw_decl_wcspbrk=yes
gl_cv_have_raw_decl_wcsrchr=yes
gl_cv_have_raw_decl_wcsrtombs=yes
gl_cv_have_raw_decl_wcsspn=yes
gl_cv_have_raw_decl_wcsstr=yes
gl_cv_have_raw_decl_wcstok=yes
gl_cv_have_raw_decl_wcswidth=yes
gl_cv_have_raw_decl_wcsxfrm=yes
gl_cv_have_raw_decl_wctob=yes
gl_cv_have_raw_decl_wctrans=yes
gl_cv_have_raw_decl_wctype=yes
gl_cv_have_raw_decl_wcwidth=yes
gl_cv_have_raw_decl_wmemchr=yes
gl_cv_have_raw_decl_wmemcmp=yes
gl_cv_have_raw_decl_wmemcpy=yes
gl_cv_have_raw_decl_wmemmove=yes
gl_cv_have_raw_decl_wmemset=yes
gl_cv_header_errno_h_complete=yes
gl_cv_header_inttypes_h=yes
gl_cv_header_langinfo_codeset=yes
gl_cv_header_langinfo_era=yes
gl_cv_header_langinfo_t_fmt_ampm=yes
gl_cv_header_langinfo_yesexpr=yes
gl_cv_header_locale_h_posix2001=yes
gl_cv_header_signal_h_SIGPIPE=yes
gl_cv_header_stdint_h=yes
gl_cv_header_sys_select_h_selfcontained=yes
gl_cv_header_wchar_h_correct_inline=yes
gl_cv_sigaltstack_low_base=yes
gl_cv_size_max=yes
gl_cv_sys_struct_timespec_in_time_h=yes
gl_cv_sys_struct_timeval=yes
gl_cv_type_sigset_t=yes
gl_cv_type_wchar_t_signed=yes
gl_cv_type_wctrans_t=yes
gl_cv_type_wctype_t=yes
gl_cv_type_wint_t_signed=yes
gl_cv_var_stdin_large_offset=yes
gt_cv_c_intmax_t=yes
gt_cv_c_wchar_t=yes
gt_cv_c_wint_t=yes
gt_cv_func_printf_posix=yes
gt_cv_func_unsetenv_ret=int
gt_cv_int_divbyzero_sigfpe=yes
gt_cv_siginfo_t=yes
gt_cv_ssize_t=yes
lt_cv_path_MAGIC_CMD=/usr/bin/file
lt_cv_sys_max_cmd_len=262144

## ----------------- ##
## Output variables. ##
## ----------------- ##

CC='cc'
CFLAGS='-O2 -pipe  -fstack-protector-strong -fno-strict-aliasing '
CPP='cpp'
CPPFLAGS=''
DEFS='-DHAVE_CONFIG_H'
ECHO_C=''
ECHO_N='-n'
ECHO_T=''
EGREP='/usr/bin/egrep'
EXEEXT=''
GREP='/usr/bin/grep'
INSTALL_DATA='install  -m 0644'
INSTALL_PROGRAM='install  -s -m 555'
INSTALL_SCRIPT='install  -m 555'
LDFLAGS=' -fstack-protector-strong '
LIBOBJS=''
LIBS='-lpthread '
LTLIBOBJS=''
OBJEXT='o'
PACKAGE_BUGREPORT='pen@lysator.liu.se'
PACKAGE_NAME='pwol'
PACKAGE_STRING='pwol 1.5'
PACKAGE_TARNAME='pwol'
PACKAGE_URL='https://github.com/ptrrkssn/pwol'
PACKAGE_VERSION='1.5'
PATH_SEPARATOR=':'
SET_MAKE=''
SHELL='/bin/sh'
ac_ct_CC='cc'
bindir='${exec_prefix}/bin'
build_alias='amd64-portbld-freebsd11.3'
datadir='${datarootdir}'
datarootdir='${prefix}/share'
docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
dvidir='${docdir}'
exec_prefix='${prefix}'
host_alias=''
htmldir='${docdir}'
includedir='${prefix}/include'
infodir='/usr/local/share/info'
libdir='${exec_prefix}/lib'
libexecdir='${exec_prefix}/libexec'
localedir='${datarootdir}/locale'
localstatedir='/var'
mandir='/usr/local/man'
oldincludedir='/usr/include'
pdfdir='${docdir}'
prefix='/usr/local'
program_transform_name='s,x,x,'
psdir='${docdir}'
sbindir='${exec_prefix}/sbin'
sharedstatedir='${prefix}/com'
sysconfdir='${prefix}/etc'
target_alias=''

## ----------- ##
## confdefs.h. ##
## ----------- ##

/* confdefs.h */
#define PACKAGE_NAME "pwol"
#define PACKAGE_TARNAME "pwol"
#define PACKAGE_VERSION "1.5"
#define PACKAGE_STRING "pwol 1.5"
#define PACKAGE_BUGREPORT "pen@lysator.liu.se"
#define PACKAGE_URL "https://github.com/ptrrkssn/pwol"
#define HAVE_LIBPTHREAD 1
#define STDC_HEADERS 1
#define HAVE_SYS_TYPES_H 1
#define HAVE_SYS_STAT_H 1
#define HAVE_STDLIB_H 1
#define HAVE_STRING_H 1
#define HAVE_MEMORY_H 1
#define HAVE_STRINGS_H 1
#define HAVE_INTTYPES_H 1
#define HAVE_STDINT_H 1
#define HAVE_UNISTD_H 1
#define HAVE_ARPA_INET_H 1
#define HAVE_FCNTL_H 1
#define HAVE_NETDB_H 1
#define HAVE_NETINET_IN_H 1
#define HAVE_STDLIB_H 1
#define HAVE_STRING_H 1
#define HAVE_SYS_SOCKET_H 1
#define HAVE_SYSLOG_H 1
#define HAVE_UNISTD_H 1
#define HAVE_FORK 1
#define HAVE_VFORK 1
#define HAVE_WORKING_VFORK 1
#define HAVE_WORKING_FORK 1
#define HAVE_STDLIB_H 1
#define HAVE_MALLOC 1
#define HAVE_STDLIB_H 1
#define HAVE_REALLOC 1
#define HAVE_DUP2 1
#define HAVE_MEMSET 1
#define HAVE_SOCKET 1
#define HAVE_STRCHR 1
#define HAVE_STRDUP 1
#define HAVE_STRERROR 1

configure: exit 0




#! /bin/sh
# Generated by configure.
# Run this file to recreate the current configuration.
# Compiler output produced by configure, useful for debugging
# configure, is in config.log if it exists.

debug=false
ac_cs_recheck=false
ac_cs_silent=false

SHELL=${CONFIG_SHELL-/bin/sh}
export SHELL
## -------------------- ##
## M4sh Initialization. ##
## -------------------- ##

# Be more Bourne compatible
DUALCASE=1; export DUALCASE # for MKS sh
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
  setopt NO_GLOB_SUBST
else
  case `(set -o) 2>/dev/null` in #(
  *posix*) :
    set -o posix ;; #(
  *) :
     ;;
esac
fi


as_nl='
'
export as_nl
# Printing a long string crashes Solaris 7 /usr/bin/printf.
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
# Prefer a ksh shell builtin over an external printf program on Solaris,
# but without wasting forks for bash or zsh.
if test -z "$BASH_VERSION$ZSH_VERSION" \
    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='print -r --'
  as_echo_n='print -rn --'
elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='printf %s\n'
  as_echo_n='printf %s'
else
  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
    as_echo_n='/usr/ucb/echo -n'
  else
    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
    as_echo_n_body='eval
      arg=$1;
      case $arg in #(
      *"$as_nl"*)
	expr "X$arg" : "X\\(.*\\)$as_nl";
	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
      esac;
      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
    '
    export as_echo_n_body
    as_echo_n='sh -c $as_echo_n_body as_echo'
  fi
  export as_echo_body
  as_echo='sh -c $as_echo_body as_echo'
fi

# The user is always right.
if test "${PATH_SEPARATOR+set}" != set; then
  PATH_SEPARATOR=:
  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
      PATH_SEPARATOR=';'
  }
fi


# IFS
# We need space, tab and new line, in precisely that order.  Quoting is
# there to prevent editors from complaining about space-tab.
# (If _AS_PATH_WALK were called with IFS unset, it would disable word
# splitting by setting IFS to empty value.)
IFS=" ""	$as_nl"

# Find who we are.  Look in the path if we contain no directory separator.
as_myself=
case $0 in #((
  *[\\/]* ) as_myself=$0 ;;
  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
  done
IFS=$as_save_IFS

     ;;
esac
# We did not find ourselves, most probably we were run as `sh COMMAND'
# in which case we are not to be found in the path.
if test "x$as_myself" = x; then
  as_myself=$0
fi
if test ! -f "$as_myself"; then
  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
  exit 1
fi

# Unset variables that we do not need and which cause bugs (e.g. in
# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
# suppresses any "Segmentation fault" message there.  '((' could
# trigger a bug in pdksh 5.2.14.
for as_var in BASH_ENV ENV MAIL MAILPATH
do eval test x\${$as_var+set} = xset \
  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
done
PS1='$ '
PS2='> '
PS4='+ '

# NLS nuisances.
LC_ALL=C
export LC_ALL
LANGUAGE=C
export LANGUAGE

# CDPATH.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH


# as_fn_error STATUS ERROR [LINENO LOG_FD]
# ----------------------------------------
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
# script with STATUS, using 1 if that was 0.
as_fn_error ()
{
  as_status=$1; test $as_status -eq 0 && as_status=1
  if test "$4"; then
    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
  fi
  $as_echo "$as_me: error: $2" >&2
  as_fn_exit $as_status
} # as_fn_error


# as_fn_set_status STATUS
# -----------------------
# Set $? to STATUS, without forking.
as_fn_set_status ()
{
  return $1
} # as_fn_set_status

# as_fn_exit STATUS
# -----------------
# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
as_fn_exit ()
{
  set +e
  as_fn_set_status $1
  exit $1
} # as_fn_exit

# as_fn_unset VAR
# ---------------
# Portably unset VAR.
as_fn_unset ()
{
  { eval $1=; unset $1;}
}
as_unset=as_fn_unset
# as_fn_append VAR VALUE
# ----------------------
# Append the text in VALUE to the end of the definition contained in VAR. Take
# advantage of any shell optimizations that allow amortized linear growth over
# repeated appends, instead of the typical quadratic growth present in naive
# implementations.
if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
  eval 'as_fn_append ()
  {
    eval $1+=\$2
  }'
else
  as_fn_append ()
  {
    eval $1=\$$1\$2
  }
fi # as_fn_append

# as_fn_arith ARG...
# ------------------
# Perform arithmetic evaluation on the ARGs, and store the result in the
# global $as_val. Take advantage of shells that can avoid forks. The arguments
# must be portable across $(()) and expr.
if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
  eval 'as_fn_arith ()
  {
    as_val=$(( $* ))
  }'
else
  as_fn_arith ()
  {
    as_val=`expr "$@" || test $? -eq 1`
  }
fi # as_fn_arith


if expr a : '\(a\)' >/dev/null 2>&1 &&
   test "X`expr 00001 : '.*\(...\)'`" = X001; then
  as_expr=expr
else
  as_expr=false
fi

if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
  as_basename=basename
else
  as_basename=false
fi

if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
  as_dirname=dirname
else
  as_dirname=false
fi

as_me=`$as_basename -- "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
	 X"$0" : 'X\(//\)$' \| \
	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X/"$0" |
    sed '/^.*\/\([^/][^/]*\)\/*$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`

# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits

ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in #(((((
-n*)
  case `echo 'xy\c'` in
  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
  xy)  ECHO_C='\c';;
  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
       ECHO_T='	';;
  esac;;
*)
  ECHO_N='-n';;
esac

rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
  rm -f conf$$.dir/conf$$.file
else
  rm -f conf$$.dir
  mkdir conf$$.dir 2>/dev/null
fi
if (echo >conf$$.file) 2>/dev/null; then
  if ln -s conf$$.file conf$$ 2>/dev/null; then
    as_ln_s='ln -s'
    # ... but there are two gotchas:
    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
    # In both cases, we have to default to `cp -pR'.
    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
      as_ln_s='cp -pR'
  elif ln conf$$.file conf$$ 2>/dev/null; then
    as_ln_s=ln
  else
    as_ln_s='cp -pR'
  fi
else
  as_ln_s='cp -pR'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null


# as_fn_mkdir_p
# -------------
# Create "$as_dir" as a directory, including parents if necessary.
as_fn_mkdir_p ()
{

  case $as_dir in #(
  -*) as_dir=./$as_dir;;
  esac
  test -d "$as_dir" || eval $as_mkdir_p || {
    as_dirs=
    while :; do
      case $as_dir in #(
      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
      *) as_qdir=$as_dir;;
      esac
      as_dirs="'$as_qdir' $as_dirs"
      as_dir=`$as_dirname -- "$as_dir" ||
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$as_dir" : 'X\(//\)[^/]' \| \
	 X"$as_dir" : 'X\(//\)$' \| \
	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_dir" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
      test -d "$as_dir" && break
    done
    test -z "$as_dirs" || eval "mkdir $as_dirs"
  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"


} # as_fn_mkdir_p
if mkdir -p . 2>/dev/null; then
  as_mkdir_p='mkdir -p "$as_dir"'
else
  test -d ./-p && rmdir ./-p
  as_mkdir_p=false
fi


# as_fn_executable_p FILE
# -----------------------
# Test if FILE is an executable regular file.
as_fn_executable_p ()
{
  test -f "$1" && test -x "$1"
} # as_fn_executable_p
as_test_x='test -x'
as_executable_p=as_fn_executable_p

# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"

# Sed expression to map a string onto a valid variable name.
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"


exec 6>&1
## ----------------------------------- ##
## Main body of $CONFIG_STATUS script. ##
## ----------------------------------- ##
# Save the log message, to keep $0 and so on meaningful, and to
# report actual input values of CONFIG_FILES etc. instead of their
# values after options handling.
ac_log="
This file was extended by pwol $as_me 1.5, which was
generated by GNU Autoconf 2.69.  Invocation command line was

  CONFIG_FILES    = $CONFIG_FILES
  CONFIG_HEADERS  = $CONFIG_HEADERS
  CONFIG_LINKS    = $CONFIG_LINKS
  CONFIG_COMMANDS = $CONFIG_COMMANDS
  $ $0 $@

on `(hostname || uname -n) 2>/dev/null | sed 1q`
"

# Files that config.status was made for.
config_files=" Makefile pwol.1 pwol.conf.5 pkgs/Makefile.port"
config_headers=" config.h"

ac_cs_usage="\
\`$as_me' instantiates files and other configuration actions
from templates according to the current configuration.  Unless the files
and actions are specified as TAGs, all are instantiated by default.

Usage: $0 [OPTION]... [TAG]...

  -h, --help       print this help, then exit
  -V, --version    print version number and configuration settings, then exit
      --config     print configuration, then exit
  -q, --quiet, --silent
                   do not print progress messages
  -d, --debug      don't remove temporary files
      --recheck    update $as_me by reconfiguring in the same conditions
      --file=FILE[:TEMPLATE]
                   instantiate the configuration file FILE
      --header=FILE[:TEMPLATE]
                   instantiate the configuration header FILE

Configuration files:
$config_files

Configuration headers:
$config_headers

Report bugs to <pen@lysator.liu.se>.
pwol home page: <https://github.com/ptrrkssn/pwol>."

ac_cs_config="'--prefix=/usr/local' '--localstatedir=/var' '--mandir=/usr/local/man' '--infodir=/usr/local/share/info/' '--build=amd64-portbld-freebsd11.3' 'build_alias=amd64-portbld-freebsd11.3' 'CC=cc' 'CFLAGS=-O2 -pipe  -fstack-protector-strong -fno-strict-aliasing ' 'LDFLAGS= -fstack-protector-strong ' 'LIBS=' 'CPPFLAGS=' 'CPP=cpp'"
ac_cs_version="\
pwol config.status 1.5
configured by ./configure, generated by GNU Autoconf 2.69,
  with options \"$ac_cs_config\"

Copyright (C) 2012 Free Software Foundation, Inc.
This config.status script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it."

ac_pwd='/usr/ports/sysutils/pwol/work/pwol-1.5'
srcdir='.'
INSTALL='/usr/bin/install -c'
test -n "$AWK" || AWK=awk
# The default lists apply if the user does not specify any file.
ac_need_defaults=:
while test $# != 0
do
  case $1 in
  --*=?*)
    ac_option=`expr "X$1" : 'X\([^=]*\)='`
    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
    ac_shift=:
    ;;
  --*=)
    ac_option=`expr "X$1" : 'X\([^=]*\)='`
    ac_optarg=
    ac_shift=:
    ;;
  *)
    ac_option=$1
    ac_optarg=$2
    ac_shift=shift
    ;;
  esac

  case $ac_option in
  # Handling of the options.
  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
    ac_cs_recheck=: ;;
  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
    $as_echo "$ac_cs_version"; exit ;;
  --config | --confi | --conf | --con | --co | --c )
    $as_echo "$ac_cs_config"; exit ;;
  --debug | --debu | --deb | --de | --d | -d )
    debug=: ;;
  --file | --fil | --fi | --f )
    $ac_shift
    case $ac_optarg in
    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
    '') as_fn_error $? "missing file argument" ;;
    esac
    as_fn_append CONFIG_FILES " '$ac_optarg'"
    ac_need_defaults=false;;
  --header | --heade | --head | --hea )
    $ac_shift
    case $ac_optarg in
    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
    esac
    as_fn_append CONFIG_HEADERS " '$ac_optarg'"
    ac_need_defaults=false;;
  --he | --h)
    # Conflict between --help and --header
    as_fn_error $? "ambiguous option: \`$1'
Try \`$0 --help' for more information.";;
  --help | --hel | -h )
    $as_echo "$ac_cs_usage"; exit ;;
  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
  | -silent | --silent | --silen | --sile | --sil | --si | --s)
    ac_cs_silent=: ;;

  # This is an error.
  -*) as_fn_error $? "unrecognized option: \`$1'
Try \`$0 --help' for more information." ;;

  *) as_fn_append ac_config_targets " $1"
     ac_need_defaults=false ;;

  esac
  shift
done

ac_configure_extra_args=

if $ac_cs_silent; then
  exec 6>/dev/null
  ac_configure_extra_args="$ac_configure_extra_args --silent"
fi

if $ac_cs_recheck; then
  set X /bin/sh './configure'  '--prefix=/usr/local' '--localstatedir=/var' '--mandir=/usr/local/man' '--infodir=/usr/local/share/info/' '--build=amd64-portbld-freebsd11.3' 'build_alias=amd64-portbld-freebsd11.3' 'CC=cc' 'CFLAGS=-O2 -pipe  -fstack-protector-strong -fno-strict-aliasing ' 'LDFLAGS= -fstack-protector-strong ' 'LIBS=' 'CPPFLAGS=' 'CPP=cpp' $ac_configure_extra_args --no-create --no-recursion
  shift
  $as_echo "running CONFIG_SHELL=/bin/sh $*" >&6
  CONFIG_SHELL='/bin/sh'
  export CONFIG_SHELL
  exec "$@"
fi

exec 5>>config.log
{
  echo
  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## Running $as_me. ##
_ASBOX
  $as_echo "$ac_log"
} >&5


# Handling of arguments.
for ac_config_target in $ac_config_targets
do
  case $ac_config_target in
    "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
    "pwol.1") CONFIG_FILES="$CONFIG_FILES pwol.1" ;;
    "pwol.conf.5") CONFIG_FILES="$CONFIG_FILES pwol.conf.5" ;;
    "pkgs/Makefile.port") CONFIG_FILES="$CONFIG_FILES pkgs/Makefile.port" ;;

  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
  esac
done


# If the user did not use the arguments to specify the items to instantiate,
# then the envvar interface is used.  Set only those that are not.
# We use the long form for the default assignment because of an extremely
# bizarre bug on SunOS 4.1.3.
if $ac_need_defaults; then
  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
fi

# Have a temporary directory for convenience.  Make it in the build tree
# simply because there is no reason against having it here, and in addition,
# creating and moving files from /tmp can sometimes cause problems.
# Hook for its removal unless debugging.
# Note that there is a small window in which the directory will not be cleaned:
# after its creation but before its name has been assigned to `$tmp'.
$debug ||
{
  tmp= ac_tmp=
  trap 'exit_status=$?
  : "${ac_tmp:=$tmp}"
  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
' 0
  trap 'as_fn_exit 1' 1 2 13 15
}
# Create a (secure) tmp directory for tmp files.

{
  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
  test -d "$tmp"
}  ||
{
  tmp=./conf$$-$RANDOM
  (umask 077 && mkdir "$tmp")
} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
ac_tmp=$tmp

# Set up the scripts for CONFIG_FILES section.
# No need to generate them if there are no CONFIG_FILES.
# This happens for instance with `./config.status config.h'.
if test -n "$CONFIG_FILES"; then


ac_cr=`echo X | tr X '\015'`
# On cygwin, bash can eat \r inside `` if the user requested igncr.
# But we know of no other shell where ac_cr would be empty at this
# point, so we can use a bashism as a fallback.
if test "x$ac_cr" = x; then
  eval ac_cr=\$\'\\r\'
fi
ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
  ac_cs_awk_cr='\\r'
else
  ac_cs_awk_cr=$ac_cr
fi

echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
cat >>"$ac_tmp/subs1.awk" <<\_ACAWK &&
S["LTLIBOBJS"]=""
S["LIBOBJS"]=""
S["EGREP"]="/usr/bin/egrep"
S["GREP"]="/usr/bin/grep"
S["CPP"]="cpp"
S["SET_MAKE"]=""
S["INSTALL_DATA"]="install  -m 0644"
S["INSTALL_SCRIPT"]="install  -m 555"
S["INSTALL_PROGRAM"]="install  -s -m 555"
S["OBJEXT"]="o"
S["EXEEXT"]=""
S["ac_ct_CC"]="cc"
S["CPPFLAGS"]=""
S["LDFLAGS"]=" -fstack-protector-strong "
S["CFLAGS"]="-O2 -pipe  -fstack-protector-strong -fno-strict-aliasing "
S["CC"]="cc"
S["target_alias"]=""
S["host_alias"]=""
S["build_alias"]="amd64-portbld-freebsd11.3"
S["LIBS"]="-lpthread "
S["ECHO_T"]=""
S["ECHO_N"]="-n"
S["ECHO_C"]=""
S["DEFS"]="-DHAVE_CONFIG_H"
S["mandir"]="/usr/local/man"
S["localedir"]="${datarootdir}/locale"
S["libdir"]="${exec_prefix}/lib"
S["psdir"]="${docdir}"
S["pdfdir"]="${docdir}"
S["dvidir"]="${docdir}"
S["htmldir"]="${docdir}"
S["infodir"]="/usr/local/share/info"
S["docdir"]="${datarootdir}/doc/${PACKAGE_TARNAME}"
S["oldincludedir"]="/usr/include"
S["includedir"]="${prefix}/include"
S["localstatedir"]="/var"
S["sharedstatedir"]="${prefix}/com"
S["sysconfdir"]="${prefix}/etc"
S["datadir"]="${datarootdir}"
S["datarootdir"]="${prefix}/share"
S["libexecdir"]="${exec_prefix}/libexec"
S["sbindir"]="${exec_prefix}/sbin"
S["bindir"]="${exec_prefix}/bin"
S["program_transform_name"]="s,x,x,"
S["prefix"]="/usr/local"
S["exec_prefix"]="${prefix}"
S["PACKAGE_URL"]="https://github.com/ptrrkssn/pwol"
S["PACKAGE_BUGREPORT"]="pen@lysator.liu.se"
S["PACKAGE_STRING"]="pwol 1.5"
S["PACKAGE_VERSION"]="1.5"
S["PACKAGE_TARNAME"]="pwol"
S["PACKAGE_NAME"]="pwol"
S["PATH_SEPARATOR"]=":"
S["SHELL"]="/bin/sh"
_ACAWK
cat >>"$ac_tmp/subs1.awk" <<_ACAWK &&
  for (key in S) S_is_set[key] = 1
  FS = ""

}
{
  line = $ 0
  nfields = split(line, field, "@")
  substed = 0
  len = length(field[1])
  for (i = 2; i < nfields; i++) {
    key = field[i]
    keylen = length(key)
    if (S_is_set[key]) {
      value = S[key]
      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
      len += length(value) + length(field[++i])
      substed = 1
    } else
      len += 1 + keylen
  }

  print line
}

_ACAWK
if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
else
  cat
fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
fi # test -n "$CONFIG_FILES"

# Set up the scripts for CONFIG_HEADERS section.
# No need to generate them if there are no CONFIG_HEADERS.
# This happens for instance with `./config.status Makefile'.
if test -n "$CONFIG_HEADERS"; then
cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
BEGIN {
D["PACKAGE_NAME"]=" \"pwol\""
D["PACKAGE_TARNAME"]=" \"pwol\""
D["PACKAGE_VERSION"]=" \"1.5\""
D["PACKAGE_STRING"]=" \"pwol 1.5\""
D["PACKAGE_BUGREPORT"]=" \"pen@lysator.liu.se\""
D["PACKAGE_URL"]=" \"https://github.com/ptrrkssn/pwol\""
D["HAVE_LIBPTHREAD"]=" 1"
D["STDC_HEADERS"]=" 1"
D["HAVE_SYS_TYPES_H"]=" 1"
D["HAVE_SYS_STAT_H"]=" 1"
D["HAVE_STDLIB_H"]=" 1"
D["HAVE_STRING_H"]=" 1"
D["HAVE_MEMORY_H"]=" 1"
D["HAVE_STRINGS_H"]=" 1"
D["HAVE_INTTYPES_H"]=" 1"
D["HAVE_STDINT_H"]=" 1"
D["HAVE_UNISTD_H"]=" 1"
D["HAVE_ARPA_INET_H"]=" 1"
D["HAVE_FCNTL_H"]=" 1"
D["HAVE_NETDB_H"]=" 1"
D["HAVE_NETINET_IN_H"]=" 1"
D["HAVE_STDLIB_H"]=" 1"
D["HAVE_STRING_H"]=" 1"
D["HAVE_SYS_SOCKET_H"]=" 1"
D["HAVE_SYSLOG_H"]=" 1"
D["HAVE_UNISTD_H"]=" 1"
D["HAVE_FORK"]=" 1"
D["HAVE_VFORK"]=" 1"
D["HAVE_WORKING_VFORK"]=" 1"
D["HAVE_WORKING_FORK"]=" 1"
D["HAVE_STDLIB_H"]=" 1"
D["HAVE_MALLOC"]=" 1"
D["HAVE_STDLIB_H"]=" 1"
D["HAVE_REALLOC"]=" 1"
D["HAVE_DUP2"]=" 1"
D["HAVE_MEMSET"]=" 1"
D["HAVE_SOCKET"]=" 1"
D["HAVE_STRCHR"]=" 1"
D["HAVE_STRDUP"]=" 1"
D["HAVE_STRERROR"]=" 1"
  for (key in D) D_is_set[key] = 1
  FS = ""
}
/^[\t ]*#[\t ]*(define|undef)[\t ]+[_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ][_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789]*([\t (]|$)/ {
  line = $ 0
  split(line, arg, " ")
  if (arg[1] == "#") {
    defundef = arg[2]
    mac1 = arg[3]
  } else {
    defundef = substr(arg[1], 2)
    mac1 = arg[2]
  }
  split(mac1, mac2, "(") #)
  macro = mac2[1]
  prefix = substr(line, 1, index(line, defundef) - 1)
  if (D_is_set[macro]) {
    # Preserve the white space surrounding the "#".
    print prefix "define", macro P[macro] D[macro]
    next
  } else {
    # Replace #undef with comments.  This is necessary, for example,
    # in the case of _POSIX_SOURCE, which is predefined and required
    # on some systems where configure will not decide to define it.
    if (defundef == "undef") {
      print "/*", prefix defundef, macro, "*/"
      next
    }
  }
}
{ print }
_ACAWK
  as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
fi # test -n "$CONFIG_HEADERS"


eval set X "  :F $CONFIG_FILES  :H $CONFIG_HEADERS    "
shift
for ac_tag
do
  case $ac_tag in
  :[FHLC]) ac_mode=$ac_tag; continue;;
  esac
  case $ac_mode$ac_tag in
  :[FHL]*:*);;
  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
  :[FH]-) ac_tag=-:-;;
  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
  esac
  ac_save_IFS=$IFS
  IFS=:
  set x $ac_tag
  IFS=$ac_save_IFS
  shift
  ac_file=$1
  shift

  case $ac_mode in
  :L) ac_source=$1;;
  :[FH])
    ac_file_inputs=
    for ac_f
    do
      case $ac_f in
      -) ac_f="$ac_tmp/stdin";;
      *) # Look for the file first in the build tree, then in the source tree
	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
	 # because $ac_f cannot contain `:'.
	 test -f "$ac_f" ||
	   case $ac_f in
	   [\\/$]*) false;;
	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
	   esac ||
	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
      esac
      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
      as_fn_append ac_file_inputs " '$ac_f'"
    done

    # Let's still pretend it is `configure' which instantiates (i.e., don't
    # use $as_me), people would be surprised to read:
    #    /* config.h.  Generated by config.status.  */
    configure_input='Generated from '`
	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
	`' by configure.'
    if test x"$ac_file" != x-; then
      configure_input="$ac_file.  $configure_input"
      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
$as_echo "$as_me: creating $ac_file" >&6;}
    fi
    # Neutralize special characters interpreted by sed in replacement strings.
    case $configure_input in #(
    *\&* | *\|* | *\\* )
       ac_sed_conf_input=`$as_echo "$configure_input" |
       sed 's/[\\\\&|]/\\\\&/g'`;; #(
    *) ac_sed_conf_input=$configure_input;;
    esac

    case $ac_tag in
    *:-:* | *:-) cat >"$ac_tmp/stdin" \
      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
    esac
    ;;
  esac

  ac_dir=`$as_dirname -- "$ac_file" ||
$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$ac_file" : 'X\(//\)[^/]' \| \
	 X"$ac_file" : 'X\(//\)$' \| \
	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$ac_file" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
  as_dir="$ac_dir"; as_fn_mkdir_p
  ac_builddir=.

case "$ac_dir" in
.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
*)
  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
  # A ".." for each directory in $ac_dir_suffix.
  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
  case $ac_top_builddir_sub in
  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
  esac ;;
esac
ac_abs_top_builddir=$ac_pwd
ac_abs_builddir=$ac_pwd$ac_dir_suffix
# for backward compatibility:
ac_top_builddir=$ac_top_build_prefix

case $srcdir in
  .)  # We are building in place.
    ac_srcdir=.
    ac_top_srcdir=$ac_top_builddir_sub
    ac_abs_top_srcdir=$ac_pwd ;;
  [\\/]* | ?:[\\/]* )  # Absolute name.
    ac_srcdir=$srcdir$ac_dir_suffix;
    ac_top_srcdir=$srcdir
    ac_abs_top_srcdir=$srcdir ;;
  *) # Relative name.
    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
    ac_top_srcdir=$ac_top_build_prefix$srcdir
    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
esac
ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix


  case $ac_mode in
  :F)
  #
  # CONFIG_FILE
  #

  case $INSTALL in
  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
  esac
# If the template does not know about datarootdir, expand it.
# FIXME: This hack should be removed a few years after 2.60.
ac_datarootdir_hack=; ac_datarootdir_seen=
ac_sed_dataroot='
/datarootdir/ {
  p
  q
}
/@datadir@/p
/@docdir@/p
/@infodir@/p
/@localedir@/p
/@mandir@/p'
case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
*datarootdir*) ac_datarootdir_seen=yes;;
*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
  ac_datarootdir_hack='
  s&@datadir@&${datarootdir}&g
  s&@docdir@&${datarootdir}/doc/${PACKAGE_TARNAME}&g
  s&@infodir@&/usr/local/share/info&g
  s&@localedir@&${datarootdir}/locale&g
  s&@mandir@&/usr/local/man&g
  s&\${datarootdir}&${prefix}/share&g' ;;
esac
ac_sed_extra="/^[	 ]*VPATH[	 ]*=[	 ]*/{
h
s///
s/^/:/
s/[	 ]*$/:/
s/:\$(srcdir):/:/g
s/:\${srcdir}:/:/g
s/:@srcdir@:/:/g
s/^:*//
s/:*$//
x
s/\(=[	 ]*\).*/\1/
G
s/\n//
s/^[^=]*=[	 ]*$//
}

:t
/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
s|@configure_input@|$ac_sed_conf_input|;t t
s&@top_builddir@&$ac_top_builddir_sub&;t t
s&@top_build_prefix@&$ac_top_build_prefix&;t t
s&@srcdir@&$ac_srcdir&;t t
s&@abs_srcdir@&$ac_abs_srcdir&;t t
s&@top_srcdir@&$ac_top_srcdir&;t t
s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
s&@builddir@&$ac_builddir&;t t
s&@abs_builddir@&$ac_abs_builddir&;t t
s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
s&@INSTALL@&$ac_INSTALL&;t t
$ac_datarootdir_hack
"
eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5

test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
      "$ac_tmp/out"`; test -z "$ac_out"; } &&
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
which seems to be undefined.  Please make sure it is defined" >&5
$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
which seems to be undefined.  Please make sure it is defined" >&2;}

  rm -f "$ac_tmp/stdin"
  case $ac_file in
  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
  esac \
  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
 ;;
  :H)
  #
  # CONFIG_HEADER
  #
  if test x"$ac_file" != x-; then
    {
      $as_echo "/* $configure_input  */" \
      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
    } >"$ac_tmp/config.h" \
      || as_fn_error $? "could not create $ac_file" "$LINENO" 5
    if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
$as_echo "$as_me: $ac_file is unchanged" >&6;}
    else
      rm -f "$ac_file"
      mv "$ac_tmp/config.h" "$ac_file" \
	|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
    fi
  else
    $as_echo "/* $configure_input  */" \
      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
      || as_fn_error $? "could not create -" "$LINENO" 5
  fi
 ;;


  esac

done # for ac_tag


as_fn_exit 0




#! /bin/sh
# Guess values for system-dependent variables and create Makefiles.
# Generated by GNU Autoconf 2.69 for pwol 1.5.
#
# Report bugs to <pen@lysator.liu.se>.
#
#
# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
#
#
# This configure script is free software; the Free Software Foundation
# gives unlimited permission to copy, distribute and modify it.
## -------------------- ##
## M4sh Initialization. ##
## -------------------- ##

# Be more Bourne compatible
DUALCASE=1; export DUALCASE # for MKS sh
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
  setopt NO_GLOB_SUBST
else
  case `(set -o) 2>/dev/null` in #(
  *posix*) :
    set -o posix ;; #(
  *) :
     ;;
esac
fi


as_nl='
'
export as_nl
# Printing a long string crashes Solaris 7 /usr/bin/printf.
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
# Prefer a ksh shell builtin over an external printf program on Solaris,
# but without wasting forks for bash or zsh.
if test -z "$BASH_VERSION$ZSH_VERSION" \
    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='print -r --'
  as_echo_n='print -rn --'
elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='printf %s\n'
  as_echo_n='printf %s'
else
  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
    as_echo_n='/usr/ucb/echo -n'
  else
    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
    as_echo_n_body='eval
      arg=$1;
      case $arg in #(
      *"$as_nl"*)
	expr "X$arg" : "X\\(.*\\)$as_nl";
	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
      esac;
      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
    '
    export as_echo_n_body
    as_echo_n='sh -c $as_echo_n_body as_echo'
  fi
  export as_echo_body
  as_echo='sh -c $as_echo_body as_echo'
fi

# The user is always right.
if test "${PATH_SEPARATOR+set}" != set; then
  PATH_SEPARATOR=:
  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
      PATH_SEPARATOR=';'
  }
fi


# IFS
# We need space, tab and new line, in precisely that order.  Quoting is
# there to prevent editors from complaining about space-tab.
# (If _AS_PATH_WALK were called with IFS unset, it would disable word
# splitting by setting IFS to empty value.)
IFS=" ""	$as_nl"

# Find who we are.  Look in the path if we contain no directory separator.
as_myself=
case $0 in #((
  *[\\/]* ) as_myself=$0 ;;
  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
  done
IFS=$as_save_IFS

     ;;
esac
# We did not find ourselves, most probably we were run as `sh COMMAND'
# in which case we are not to be found in the path.
if test "x$as_myself" = x; then
  as_myself=$0
fi
if test ! -f "$as_myself"; then
  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
  exit 1
fi

# Unset variables that we do not need and which cause bugs (e.g. in
# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
# suppresses any "Segmentation fault" message there.  '((' could
# trigger a bug in pdksh 5.2.14.
for as_var in BASH_ENV ENV MAIL MAILPATH
do eval test x\${$as_var+set} = xset \
  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
done
PS1='$ '
PS2='> '
PS4='+ '

# NLS nuisances.
LC_ALL=C
export LC_ALL
LANGUAGE=C
export LANGUAGE

# CDPATH.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

# Use a proper internal environment variable to ensure we don't fall
  # into an infinite loop, continuously re-executing ourselves.
  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
    _as_can_reexec=no; export _as_can_reexec;
    # We cannot yet assume a decent shell, so we have to provide a
# neutralization value for shells without unset; and this also
# works around shells that cannot unset nonexistent variables.
# Preserve -v and -x to the replacement shell.
BASH_ENV=/dev/null
ENV=/dev/null
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
case $- in # ((((
  *v*x* | *x*v* ) as_opts=-vx ;;
  *v* ) as_opts=-v ;;
  *x* ) as_opts=-x ;;
  * ) as_opts= ;;
esac
exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
# Admittedly, this is quite paranoid, since all the known shells bail
# out after a failed `exec'.
$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
as_fn_exit 255
  fi
  # We don't want this to propagate to other subprocesses.
          { _as_can_reexec=; unset _as_can_reexec;}
if test "x$CONFIG_SHELL" = x; then
  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '\${1+\"\$@\"}'='\"\$@\"'
  setopt NO_GLOB_SUBST
else
  case \`(set -o) 2>/dev/null\` in #(
  *posix*) :
    set -o posix ;; #(
  *) :
     ;;
esac
fi
"
  as_required="as_fn_return () { (exit \$1); }
as_fn_success () { as_fn_return 0; }
as_fn_failure () { as_fn_return 1; }
as_fn_ret_success () { return 0; }
as_fn_ret_failure () { return 1; }

exitcode=0
as_fn_success || { exitcode=1; echo as_fn_success failed.; }
as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :

else
  exitcode=1; echo positional parameters were not saved.
fi
test x\$exitcode = x0 || exit 1
test -x / || exit 1"
  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
test \$(( 1 + 1 )) = 2 || exit 1"
  if (eval "$as_required") 2>/dev/null; then :
  as_have_required=yes
else
  as_have_required=no
fi
  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :

else
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
as_found=false
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  as_found=:
  case $as_dir in #(
	 /*)
	   for as_base in sh bash ksh sh5; do
	     # Try only shells that exist, to save several forks.
	     as_shell=$as_dir/$as_base
	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
  CONFIG_SHELL=$as_shell as_have_required=yes
		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
  break 2
fi
fi
	   done;;
       esac
  as_found=false
done
$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
  CONFIG_SHELL=$SHELL as_have_required=yes
fi; }
IFS=$as_save_IFS


      if test "x$CONFIG_SHELL" != x; then :
  export CONFIG_SHELL
             # We cannot yet assume a decent shell, so we have to provide a
# neutralization value for shells without unset; and this also
# works around shells that cannot unset nonexistent variables.
# Preserve -v and -x to the replacement shell.
BASH_ENV=/dev/null
ENV=/dev/null
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
case $- in # ((((
  *v*x* | *x*v* ) as_opts=-vx ;;
  *v* ) as_opts=-v ;;
  *x* ) as_opts=-x ;;
  * ) as_opts= ;;
esac
exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
# Admittedly, this is quite paranoid, since all the known shells bail
# out after a failed `exec'.
$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
exit 255
fi

    if test x$as_have_required = xno; then :
  $as_echo "$0: This script requires a shell more modern than all"
  $as_echo "$0: the shells that I found on your system."
  if test x${ZSH_VERSION+set} = xset ; then
    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
  else
    $as_echo "$0: Please tell bug-autoconf@gnu.org and pen@lysator.liu.se
$0: about your system, including any error possibly output
$0: before this message. Then install a modern shell, or
$0: manually run the script under such a shell if you do
$0: have one."
  fi
  exit 1
fi
fi
fi
SHELL=${CONFIG_SHELL-/bin/sh}
export SHELL
# Unset more variables known to interfere with behavior of common tools.
CLICOLOR_FORCE= GREP_OPTIONS=
unset CLICOLOR_FORCE GREP_OPTIONS

## --------------------- ##
## M4sh Shell Functions. ##
## --------------------- ##
# as_fn_unset VAR
# ---------------
# Portably unset VAR.
as_fn_unset ()
{
  { eval $1=; unset $1;}
}
as_unset=as_fn_unset

# as_fn_set_status STATUS
# -----------------------
# Set $? to STATUS, without forking.
as_fn_set_status ()
{
  return $1
} # as_fn_set_status

# as_fn_exit STATUS
# -----------------
# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
as_fn_exit ()
{
  set +e
  as_fn_set_status $1
  exit $1
} # as_fn_exit

# as_fn_mkdir_p
# -------------
# Create "$as_dir" as a directory, including parents if necessary.
as_fn_mkdir_p ()
{

  case $as_dir in #(
  -*) as_dir=./$as_dir;;
  esac
  test -d "$as_dir" || eval $as_mkdir_p || {
    as_dirs=
    while :; do
      case $as_dir in #(
      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
      *) as_qdir=$as_dir;;
      esac
      as_dirs="'$as_qdir' $as_dirs"
      as_dir=`$as_dirname -- "$as_dir" ||
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$as_dir" : 'X\(//\)[^/]' \| \
	 X"$as_dir" : 'X\(//\)$' \| \
	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_dir" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
      test -d "$as_dir" && break
    done
    test -z "$as_dirs" || eval "mkdir $as_dirs"
  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"


} # as_fn_mkdir_p

# as_fn_executable_p FILE
# -----------------------
# Test if FILE is an executable regular file.
as_fn_executable_p ()
{
  test -f "$1" && test -x "$1"
} # as_fn_executable_p
# as_fn_append VAR VALUE
# ----------------------
# Append the text in VALUE to the end of the definition contained in VAR. Take
# advantage of any shell optimizations that allow amortized linear growth over
# repeated appends, instead of the typical quadratic growth present in naive
# implementations.
if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
  eval 'as_fn_append ()
  {
    eval $1+=\$2
  }'
else
  as_fn_append ()
  {
    eval $1=\$$1\$2
  }
fi # as_fn_append

# as_fn_arith ARG...
# ------------------
# Perform arithmetic evaluation on the ARGs, and store the result in the
# global $as_val. Take advantage of shells that can avoid forks. The arguments
# must be portable across $(()) and expr.
if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
  eval 'as_fn_arith ()
  {
    as_val=$(( $* ))
  }'
else
  as_fn_arith ()
  {
    as_val=`expr "$@" || test $? -eq 1`
  }
fi # as_fn_arith


# as_fn_error STATUS ERROR [LINENO LOG_FD]
# ----------------------------------------
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
# script with STATUS, using 1 if that was 0.
as_fn_error ()
{
  as_status=$1; test $as_status -eq 0 && as_status=1
  if test "$4"; then
    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
  fi
  $as_echo "$as_me: error: $2" >&2
  as_fn_exit $as_status
} # as_fn_error

if expr a : '\(a\)' >/dev/null 2>&1 &&
   test "X`expr 00001 : '.*\(...\)'`" = X001; then
  as_expr=expr
else
  as_expr=false
fi

if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
  as_basename=basename
else
  as_basename=false
fi

if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
  as_dirname=dirname
else
  as_dirname=false
fi

as_me=`$as_basename -- "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
	 X"$0" : 'X\(//\)$' \| \
	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X/"$0" |
    sed '/^.*\/\([^/][^/]*\)\/*$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`

# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits


  as_lineno_1=$LINENO as_lineno_1a=$LINENO
  as_lineno_2=$LINENO as_lineno_2a=$LINENO
  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
  sed -n '
    p
    /[$]LINENO/=
  ' <$as_myself |
    sed '
      s/[$]LINENO.*/&-/
      t lineno
      b
      :lineno
      N
      :loop
      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
      t loop
      s/-\n.*//
    ' >$as_me.lineno &&
  chmod +x "$as_me.lineno" ||
    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }

  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
  # already done that, so ensure we don't try to do so again and fall
  # in an infinite loop.  This has already happened in practice.
  _as_can_reexec=no; export _as_can_reexec
  # Don't try to exec as it changes $[0], causing all sort of problems
  # (the dirname of $[0] is not the place where we might find the
  # original and so on.  Autoconf is especially sensitive to this).
  . "./$as_me.lineno"
  # Exit status is that of the last command.
  exit
}

ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in #(((((
-n*)
  case `echo 'xy\c'` in
  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
  xy)  ECHO_C='\c';;
  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
       ECHO_T='	';;
  esac;;
*)
  ECHO_N='-n';;
esac

rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
  rm -f conf$$.dir/conf$$.file
else
  rm -f conf$$.dir
  mkdir conf$$.dir 2>/dev/null
fi
if (echo >conf$$.file) 2>/dev/null; then
  if ln -s conf$$.file conf$$ 2>/dev/null; then
    as_ln_s='ln -s'
    # ... but there are two gotchas:
    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
    # In both cases, we have to default to `cp -pR'.
    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
      as_ln_s='cp -pR'
  elif ln conf$$.file conf$$ 2>/dev/null; then
    as_ln_s=ln
  else
    as_ln_s='cp -pR'
  fi
else
  as_ln_s='cp -pR'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null

if mkdir -p . 2>/dev/null; then
  as_mkdir_p='mkdir -p "$as_dir"'
else
  test -d ./-p && rmdir ./-p
  as_mkdir_p=false
fi

as_test_x='test -x'
as_executable_p=as_fn_executable_p

# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"

# Sed expression to map a string onto a valid variable name.
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"


test -n "$DJDIR" || exec 7<&0 </dev/null
exec 6>&1

# Name of the host.
# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
# so uname gets run too.
ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`

#
# Initializations.
#
ac_default_prefix=/usr/local
ac_clean_files=
ac_config_libobj_dir=.
LIBOBJS=
cross_compiling=no
subdirs=
MFLAGS=
MAKEFLAGS=

# Identity of this package.
PACKAGE_NAME='pwol'
PACKAGE_TARNAME='pwol'
PACKAGE_VERSION='1.5'
PACKAGE_STRING='pwol 1.5'
PACKAGE_BUGREPORT='pen@lysator.liu.se'
PACKAGE_URL='https://github.com/ptrrkssn/pwol'

ac_unique_file="pwol.c"
# Factoring default headers for most tests.
ac_includes_default="\
#include <stdio.h>
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
#ifdef HAVE_SYS_STAT_H
# include <sys/stat.h>
#endif
#ifdef STDC_HEADERS
# include <stdlib.h>
# include <stddef.h>
#else
# ifdef HAVE_STDLIB_H
#  include <stdlib.h>
# endif
#endif
#ifdef HAVE_STRING_H
# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
#  include <memory.h>
# endif
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#ifdef HAVE_INTTYPES_H
# include <inttypes.h>
#endif
#ifdef HAVE_STDINT_H
# include <stdint.h>
#endif
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif"

ac_subst_vars='LTLIBOBJS
LIBOBJS
EGREP
GREP
CPP
SET_MAKE
INSTALL_DATA
INSTALL_SCRIPT
INSTALL_PROGRAM
OBJEXT
EXEEXT
ac_ct_CC
CPPFLAGS
LDFLAGS
CFLAGS
CC
target_alias
host_alias
build_alias
LIBS
ECHO_T
ECHO_N
ECHO_C
DEFS
mandir
localedir
libdir
psdir
pdfdir
dvidir
htmldir
infodir
docdir
oldincludedir
includedir
localstatedir
sharedstatedir
sysconfdir
datadir
datarootdir
libexecdir
sbindir
bindir
program_transform_name
prefix
exec_prefix
PACKAGE_URL
PACKAGE_BUGREPORT
PACKAGE_STRING
PACKAGE_VERSION
PACKAGE_TARNAME
PACKAGE_NAME
PATH_SEPARATOR
SHELL'
ac_subst_files=''
ac_user_opts='
enable_option_checking
'
      ac_precious_vars='build_alias
host_alias
target_alias
CC
CFLAGS
LDFLAGS
LIBS
CPPFLAGS
CPP'


# Initialize some variables set by options.
ac_init_help=
ac_init_version=false
ac_unrecognized_opts=
ac_unrecognized_sep=
# The variables have the same names as the options, with
# dashes changed to underlines.
cache_file=/dev/null
exec_prefix=NONE
no_create=
no_recursion=
prefix=NONE
program_prefix=NONE
program_suffix=NONE
program_transform_name=s,x,x,
silent=
site=
srcdir=
verbose=
x_includes=NONE
x_libraries=NONE

# Installation directory options.
# These are left unexpanded so users can "make install exec_prefix=/foo"
# and all the variables that are supposed to be based on exec_prefix
# by default will actually change.
# Use braces instead of parens because sh, perl, etc. also accept them.
# (The list follows the same order as the GNU Coding Standards.)
bindir='${exec_prefix}/bin'
sbindir='${exec_prefix}/sbin'
libexecdir='${exec_prefix}/libexec'
datarootdir='${prefix}/share'
datadir='${datarootdir}'
sysconfdir='${prefix}/etc'
sharedstatedir='${prefix}/com'
localstatedir='${prefix}/var'
includedir='${prefix}/include'
oldincludedir='/usr/include'
docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
infodir='${datarootdir}/info'
htmldir='${docdir}'
dvidir='${docdir}'
pdfdir='${docdir}'
psdir='${docdir}'
libdir='${exec_prefix}/lib'
localedir='${datarootdir}/locale'
mandir='${datarootdir}/man'

ac_prev=
ac_dashdash=
for ac_option
do
  # If the previous option needs an argument, assign it.
  if test -n "$ac_prev"; then
    eval $ac_prev=\$ac_option
    ac_prev=
    continue
  fi

  case $ac_option in
  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
  *=)   ac_optarg= ;;
  *)    ac_optarg=yes ;;
  esac

  # Accept the important Cygnus configure options, so we can diagnose typos.

  case $ac_dashdash$ac_option in
  --)
    ac_dashdash=yes ;;

  -bindir | --bindir | --bindi | --bind | --bin | --bi)
    ac_prev=bindir ;;
  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
    bindir=$ac_optarg ;;

  -build | --build | --buil | --bui | --bu)
    ac_prev=build_alias ;;
  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
    build_alias=$ac_optarg ;;

  -cache-file | --cache-file | --cache-fil | --cache-fi \
  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
    ac_prev=cache_file ;;
  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
    cache_file=$ac_optarg ;;

  --config-cache | -C)
    cache_file=config.cache ;;

  -datadir | --datadir | --datadi | --datad)
    ac_prev=datadir ;;
  -datadir=* | --datadir=* | --datadi=* | --datad=*)
    datadir=$ac_optarg ;;

  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
  | --dataroo | --dataro | --datar)
    ac_prev=datarootdir ;;
  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
    datarootdir=$ac_optarg ;;

  -disable-* | --disable-*)
    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
    # Reject names that are not valid shell variable names.
    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
      as_fn_error $? "invalid feature name: $ac_useropt"
    ac_useropt_orig=$ac_useropt
    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
    case $ac_user_opts in
      *"
"enable_$ac_useropt"
"*) ;;
      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
	 ac_unrecognized_sep=', ';;
    esac
    eval enable_$ac_useropt=no ;;

  -docdir | --docdir | --docdi | --doc | --do)
    ac_prev=docdir ;;
  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
    docdir=$ac_optarg ;;

  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
    ac_prev=dvidir ;;
  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
    dvidir=$ac_optarg ;;

  -enable-* | --enable-*)
    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
    # Reject names that are not valid shell variable names.
    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
      as_fn_error $? "invalid feature name: $ac_useropt"
    ac_useropt_orig=$ac_useropt
    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
    case $ac_user_opts in
      *"
"enable_$ac_useropt"
"*) ;;
      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
	 ac_unrecognized_sep=', ';;
    esac
    eval enable_$ac_useropt=\$ac_optarg ;;

  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
  | --exec | --exe | --ex)
    ac_prev=exec_prefix ;;
  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
  | --exec=* | --exe=* | --ex=*)
    exec_prefix=$ac_optarg ;;

  -gas | --gas | --ga | --g)
    # Obsolete; use --with-gas.
    with_gas=yes ;;

  -help | --help | --hel | --he | -h)
    ac_init_help=long ;;
  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
    ac_init_help=recursive ;;
  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
    ac_init_help=short ;;

  -host | --host | --hos | --ho)
    ac_prev=host_alias ;;
  -host=* | --host=* | --hos=* | --ho=*)
    host_alias=$ac_optarg ;;

  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
    ac_prev=htmldir ;;
  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
  | --ht=*)
    htmldir=$ac_optarg ;;

  -includedir | --includedir | --includedi | --included | --include \
  | --includ | --inclu | --incl | --inc)
    ac_prev=includedir ;;
  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
  | --includ=* | --inclu=* | --incl=* | --inc=*)
    includedir=$ac_optarg ;;

  -infodir | --infodir | --infodi | --infod | --info | --inf)
    ac_prev=infodir ;;
  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
    infodir=$ac_optarg ;;

  -libdir | --libdir | --libdi | --libd)
    ac_prev=libdir ;;
  -libdir=* | --libdir=* | --libdi=* | --libd=*)
    libdir=$ac_optarg ;;

  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
  | --libexe | --libex | --libe)
    ac_prev=libexecdir ;;
  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
  | --libexe=* | --libex=* | --libe=*)
    libexecdir=$ac_optarg ;;

  -localedir | --localedir | --localedi | --localed | --locale)
    ac_prev=localedir ;;
  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
    localedir=$ac_optarg ;;

  -localstatedir | --localstatedir | --localstatedi | --localstated \
  | --localstate | --localstat | --localsta | --localst | --locals)
    ac_prev=localstatedir ;;
  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
    localstatedir=$ac_optarg ;;

  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
    ac_prev=mandir ;;
  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
    mandir=$ac_optarg ;;

  -nfp | --nfp | --nf)
    # Obsolete; use --without-fp.
    with_fp=no ;;

  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
  | --no-cr | --no-c | -n)
    no_create=yes ;;

  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
    no_recursion=yes ;;

  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
  | --oldin | --oldi | --old | --ol | --o)
    ac_prev=oldincludedir ;;
  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
    oldincludedir=$ac_optarg ;;

  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
    ac_prev=prefix ;;
  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
    prefix=$ac_optarg ;;

  -program-prefix | --program-prefix | --program-prefi | --program-pref \
  | --program-pre | --program-pr | --program-p)
    ac_prev=program_prefix ;;
  -program-prefix=* | --program-prefix=* | --program-prefi=* \
  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
    program_prefix=$ac_optarg ;;

  -program-suffix | --program-suffix | --program-suffi | --program-suff \
  | --program-suf | --program-su | --program-s)
    ac_prev=program_suffix ;;
  -program-suffix=* | --program-suffix=* | --program-suffi=* \
  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
    program_suffix=$ac_optarg ;;

  -program-transform-name | --program-transform-name \
  | --program-transform-nam | --program-transform-na \
  | --program-transform-n | --program-transform- \
  | --program-transform | --program-transfor \
  | --program-transfo | --program-transf \
  | --program-trans | --program-tran \
  | --progr-tra | --program-tr | --program-t)
    ac_prev=program_transform_name ;;
  -program-transform-name=* | --program-transform-name=* \
  | --program-transform-nam=* | --program-transform-na=* \
  | --program-transform-n=* | --program-transform-=* \
  | --program-transform=* | --program-transfor=* \
  | --program-transfo=* | --program-transf=* \
  | --program-trans=* | --program-tran=* \
  | --progr-tra=* | --program-tr=* | --program-t=*)
    program_transform_name=$ac_optarg ;;

  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
    ac_prev=pdfdir ;;
  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
    pdfdir=$ac_optarg ;;

  -psdir | --psdir | --psdi | --psd | --ps)
    ac_prev=psdir ;;
  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
    psdir=$ac_optarg ;;

  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
  | -silent | --silent | --silen | --sile | --sil)
    silent=yes ;;

  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
    ac_prev=sbindir ;;
  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
  | --sbi=* | --sb=*)
    sbindir=$ac_optarg ;;

  -sharedstatedir | --sharedstatedir | --sharedstatedi \
  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
  | --sharedst | --shareds | --shared | --share | --shar \
  | --sha | --sh)
    ac_prev=sharedstatedir ;;
  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
  | --sha=* | --sh=*)
    sharedstatedir=$ac_optarg ;;

  -site | --site | --sit)
    ac_prev=site ;;
  -site=* | --site=* | --sit=*)
    site=$ac_optarg ;;

  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
    ac_prev=srcdir ;;
  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
    srcdir=$ac_optarg ;;

  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
  | --syscon | --sysco | --sysc | --sys | --sy)
    ac_prev=sysconfdir ;;
  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
    sysconfdir=$ac_optarg ;;

  -target | --target | --targe | --targ | --tar | --ta | --t)
    ac_prev=target_alias ;;
  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
    target_alias=$ac_optarg ;;

  -v | -verbose | --verbose | --verbos | --verbo | --verb)
    verbose=yes ;;

  -version | --version | --versio | --versi | --vers | -V)
    ac_init_version=: ;;

  -with-* | --with-*)
    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
    # Reject names that are not valid shell variable names.
    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
      as_fn_error $? "invalid package name: $ac_useropt"
    ac_useropt_orig=$ac_useropt
    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
    case $ac_user_opts in
      *"
"with_$ac_useropt"
"*) ;;
      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
	 ac_unrecognized_sep=', ';;
    esac
    eval with_$ac_useropt=\$ac_optarg ;;

  -without-* | --without-*)
    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
    # Reject names that are not valid shell variable names.
    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
      as_fn_error $? "invalid package name: $ac_useropt"
    ac_useropt_orig=$ac_useropt
    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
    case $ac_user_opts in
      *"
"with_$ac_useropt"
"*) ;;
      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
	 ac_unrecognized_sep=', ';;
    esac
    eval with_$ac_useropt=no ;;

  --x)
    # Obsolete; use --with-x.
    with_x=yes ;;

  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
  | --x-incl | --x-inc | --x-in | --x-i)
    ac_prev=x_includes ;;
  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
    x_includes=$ac_optarg ;;

  -x-libraries | --x-libraries | --x-librarie | --x-librari \
  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
    ac_prev=x_libraries ;;
  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
    x_libraries=$ac_optarg ;;

  -*) as_fn_error $? "unrecognized option: \`$ac_option'
Try \`$0 --help' for more information"
    ;;

  *=*)
    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
    # Reject names that are not valid shell variable names.
    case $ac_envvar in #(
      '' | [0-9]* | *[!_$as_cr_alnum]* )
      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
    esac
    eval $ac_envvar=\$ac_optarg
    export $ac_envvar ;;

  *)
    # FIXME: should be removed in autoconf 3.0.
    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
    ;;

  esac
done

if test -n "$ac_prev"; then
  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
  as_fn_error $? "missing argument to $ac_option"
fi

if test -n "$ac_unrecognized_opts"; then
  case $enable_option_checking in
    no) ;;
    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
  esac
fi

# Check all directory arguments for consistency.
for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
		datadir sysconfdir sharedstatedir localstatedir includedir \
		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
		libdir localedir mandir
do
  eval ac_val=\$$ac_var
  # Remove trailing slashes.
  case $ac_val in
    */ )
      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
      eval $ac_var=\$ac_val;;
  esac
  # Be sure to have absolute directory names.
  case $ac_val in
    [\\/$]* | ?:[\\/]* )  continue;;
    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
  esac
  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
done

# There might be people who depend on the old broken behavior: `$host'
# used to hold the argument of --host etc.
# FIXME: To remove some day.
build=$build_alias
host=$host_alias
target=$target_alias

# FIXME: To remove some day.
if test "x$host_alias" != x; then
  if test "x$build_alias" = x; then
    cross_compiling=maybe
  elif test "x$build_alias" != "x$host_alias"; then
    cross_compiling=yes
  fi
fi

ac_tool_prefix=
test -n "$host_alias" && ac_tool_prefix=$host_alias-

test "$silent" = yes && exec 6>/dev/null


ac_pwd=`pwd` && test -n "$ac_pwd" &&
ac_ls_di=`ls -di .` &&
ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
  as_fn_error $? "working directory cannot be determined"
test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
  as_fn_error $? "pwd does not report name of working directory"


# Find the source files, if location was not specified.
if test -z "$srcdir"; then
  ac_srcdir_defaulted=yes
  # Try the directory containing this script, then the parent directory.
  ac_confdir=`$as_dirname -- "$as_myself" ||
$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$as_myself" : 'X\(//\)[^/]' \| \
	 X"$as_myself" : 'X\(//\)$' \| \
	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_myself" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
  srcdir=$ac_confdir
  if test ! -r "$srcdir/$ac_unique_file"; then
    srcdir=..
  fi
else
  ac_srcdir_defaulted=no
fi
if test ! -r "$srcdir/$ac_unique_file"; then
  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
fi
ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
ac_abs_confdir=`(
	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
	pwd)`
# When building in place, set srcdir=.
if test "$ac_abs_confdir" = "$ac_pwd"; then
  srcdir=.
fi
# Remove unnecessary trailing slashes from srcdir.
# Double slashes in file names in object file debugging info
# mess up M-x gdb in Emacs.
case $srcdir in
*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
esac
for ac_var in $ac_precious_vars; do
  eval ac_env_${ac_var}_set=\${${ac_var}+set}
  eval ac_env_${ac_var}_value=\$${ac_var}
  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
  eval ac_cv_env_${ac_var}_value=\$${ac_var}
done

#
# Report the --help message.
#
if test "$ac_init_help" = "long"; then
  # Omit some internal or obsolete options to make the list less imposing.
  # This message is too long to be a string in the A/UX 3.1 sh.
  cat <<_ACEOF
\`configure' configures pwol 1.5 to adapt to many kinds of systems.

Usage: $0 [OPTION]... [VAR=VALUE]...

To assign environment variables (e.g., CC, CFLAGS...), specify them as
VAR=VALUE.  See below for descriptions of some of the useful variables.

Defaults for the options are specified in brackets.

Configuration:
  -h, --help              display this help and exit
      --help=short        display options specific to this package
      --help=recursive    display the short help of all the included packages
  -V, --version           display version information and exit
  -q, --quiet, --silent   do not print \`checking ...' messages
      --cache-file=FILE   cache test results in FILE [disabled]
  -C, --config-cache      alias for \`--cache-file=config.cache'
  -n, --no-create         do not create output files
      --srcdir=DIR        find the sources in DIR [configure dir or \`..']

Installation directories:
  --prefix=PREFIX         install architecture-independent files in PREFIX
                          [$ac_default_prefix]
  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
                          [PREFIX]

By default, \`make install' will install all the files in
\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
an installation prefix other than \`$ac_default_prefix' using \`--prefix',
for instance \`--prefix=\$HOME'.

For better control, use the options below.

Fine tuning of the installation directories:
  --bindir=DIR            user executables [EPREFIX/bin]
  --sbindir=DIR           system admin executables [EPREFIX/sbin]
  --libexecdir=DIR        program executables [EPREFIX/libexec]
  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
  --libdir=DIR            object code libraries [EPREFIX/lib]
  --includedir=DIR        C header files [PREFIX/include]
  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
  --infodir=DIR           info documentation [DATAROOTDIR/info]
  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
  --mandir=DIR            man documentation [DATAROOTDIR/man]
  --docdir=DIR            documentation root [DATAROOTDIR/doc/pwol]
  --htmldir=DIR           html documentation [DOCDIR]
  --dvidir=DIR            dvi documentation [DOCDIR]
  --pdfdir=DIR            pdf documentation [DOCDIR]
  --psdir=DIR             ps documentation [DOCDIR]
_ACEOF

  cat <<\_ACEOF
_ACEOF
fi

if test -n "$ac_init_help"; then
  case $ac_init_help in
     short | recursive ) echo "Configuration of pwol 1.5:";;
   esac
  cat <<\_ACEOF

Some influential environment variables:
  CC          C compiler command
  CFLAGS      C compiler flags
  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
              nonstandard directory <lib dir>
  LIBS        libraries to pass to the linker, e.g. -l<library>
  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
              you have headers in a nonstandard directory <include dir>
  CPP         C preprocessor

Use these variables to override the choices made by `configure' or to help
it to find libraries and programs with nonstandard names/locations.

Report bugs to <pen@lysator.liu.se>.
pwol home page: <https://github.com/ptrrkssn/pwol>.
_ACEOF
ac_status=$?
fi

if test "$ac_init_help" = "recursive"; then
  # If there are subdirs, report their specific --help.
  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
    test -d "$ac_dir" ||
      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
      continue
    ac_builddir=.

case "$ac_dir" in
.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
*)
  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
  # A ".." for each directory in $ac_dir_suffix.
  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
  case $ac_top_builddir_sub in
  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
  esac ;;
esac
ac_abs_top_builddir=$ac_pwd
ac_abs_builddir=$ac_pwd$ac_dir_suffix
# for backward compatibility:
ac_top_builddir=$ac_top_build_prefix

case $srcdir in
  .)  # We are building in place.
    ac_srcdir=.
    ac_top_srcdir=$ac_top_builddir_sub
    ac_abs_top_srcdir=$ac_pwd ;;
  [\\/]* | ?:[\\/]* )  # Absolute name.
    ac_srcdir=$srcdir$ac_dir_suffix;
    ac_top_srcdir=$srcdir
    ac_abs_top_srcdir=$srcdir ;;
  *) # Relative name.
    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
    ac_top_srcdir=$ac_top_build_prefix$srcdir
    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
esac
ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix

    cd "$ac_dir" || { ac_status=$?; continue; }
    # Check for guested configure.
    if test -f "$ac_srcdir/configure.gnu"; then
      echo &&
      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
    elif test -f "$ac_srcdir/configure"; then
      echo &&
      $SHELL "$ac_srcdir/configure" --help=recursive
    else
      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
    fi || ac_status=$?
    cd "$ac_pwd" || { ac_status=$?; break; }
  done
fi

test -n "$ac_init_help" && exit $ac_status
if $ac_init_version; then
  cat <<\_ACEOF
pwol configure 1.5
generated by GNU Autoconf 2.69

Copyright (C) 2012 Free Software Foundation, Inc.
This configure script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it.
_ACEOF
  exit
fi

## ------------------------ ##
## Autoconf initialization. ##
## ------------------------ ##

# ac_fn_c_try_compile LINENO
# --------------------------
# Try to compile conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_compile ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  rm -f conftest.$ac_objext
  if { { ac_try="$ac_compile"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_compile") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    grep -v '^ *+' conftest.err >conftest.er1
    cat conftest.er1 >&5
    mv -f conftest.er1 conftest.err
  fi
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && {
	 test -z "$ac_c_werror_flag" ||
	 test ! -s conftest.err
       } && test -s conftest.$ac_objext; then :
  ac_retval=0
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

	ac_retval=1
fi
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
  as_fn_set_status $ac_retval

} # ac_fn_c_try_compile

# ac_fn_c_try_link LINENO
# -----------------------
# Try to link conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_link ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  rm -f conftest.$ac_objext conftest$ac_exeext
  if { { ac_try="$ac_link"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    grep -v '^ *+' conftest.err >conftest.er1
    cat conftest.er1 >&5
    mv -f conftest.er1 conftest.err
  fi
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && {
	 test -z "$ac_c_werror_flag" ||
	 test ! -s conftest.err
       } && test -s conftest$ac_exeext && {
	 test "$cross_compiling" = yes ||
	 test -x conftest$ac_exeext
       }; then :
  ac_retval=0
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

	ac_retval=1
fi
  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
  # interfere with the next link command; also delete a directory that is
  # left behind by Apple's compiler.  We do this before executing the actions.
  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
  as_fn_set_status $ac_retval

} # ac_fn_c_try_link

# ac_fn_c_try_cpp LINENO
# ----------------------
# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_cpp ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  if { { ac_try="$ac_cpp conftest.$ac_ext"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    grep -v '^ *+' conftest.err >conftest.er1
    cat conftest.er1 >&5
    mv -f conftest.er1 conftest.err
  fi
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } > conftest.i && {
	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
	 test ! -s conftest.err
       }; then :
  ac_retval=0
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

    ac_retval=1
fi
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
  as_fn_set_status $ac_retval

} # ac_fn_c_try_cpp

# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
# -------------------------------------------------------
# Tests whether HEADER exists, giving a warning if it cannot be compiled using
# the include files in INCLUDES and setting the cache variable VAR
# accordingly.
ac_fn_c_check_header_mongrel ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  if eval \${$3+:} false; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if eval \${$3+:} false; then :
  $as_echo_n "(cached) " >&6
fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
else
  # Is the header compilable?
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
$as_echo_n "checking $2 usability... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$4
#include <$2>
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_header_compiler=yes
else
  ac_header_compiler=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
$as_echo "$ac_header_compiler" >&6; }

# Is the header present?
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
$as_echo_n "checking $2 presence... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <$2>
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
  ac_header_preproc=yes
else
  ac_header_preproc=no
fi
rm -f conftest.err conftest.i conftest.$ac_ext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
$as_echo "$ac_header_preproc" >&6; }

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
  yes:no: )
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
    ;;
  no:yes:* )
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
( $as_echo "## --------------------------------- ##
## Report this to pen@lysator.liu.se ##
## --------------------------------- ##"
     ) | sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if eval \${$3+:} false; then :
  $as_echo_n "(cached) " >&6
else
  eval "$3=\$ac_header_compiler"
fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
fi
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno

} # ac_fn_c_check_header_mongrel

# ac_fn_c_try_run LINENO
# ----------------------
# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
# that executables *can* be run.
ac_fn_c_try_run ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  if { { ac_try="$ac_link"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
  { { case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_try") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; }; then :
  ac_retval=0
else
  $as_echo "$as_me: program exited with status $ac_status" >&5
       $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

       ac_retval=$ac_status
fi
  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
  as_fn_set_status $ac_retval

} # ac_fn_c_try_run

# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
# -------------------------------------------------------
# Tests whether HEADER exists and can be compiled using the include files in
# INCLUDES, setting the cache variable VAR accordingly.
ac_fn_c_check_header_compile ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if eval \${$3+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$4
#include <$2>
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  eval "$3=yes"
else
  eval "$3=no"
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno

} # ac_fn_c_check_header_compile

# ac_fn_c_check_type LINENO TYPE VAR INCLUDES
# -------------------------------------------
# Tests whether TYPE exists after having included INCLUDES, setting cache
# variable VAR accordingly.
ac_fn_c_check_type ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if eval \${$3+:} false; then :
  $as_echo_n "(cached) " >&6
else
  eval "$3=no"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$4
int
main ()
{
if (sizeof ($2))
	 return 0;
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$4
int
main ()
{
if (sizeof (($2)))
	    return 0;
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :

else
  eval "$3=yes"
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno

} # ac_fn_c_check_type

# ac_fn_c_check_func LINENO FUNC VAR
# ----------------------------------
# Tests whether FUNC exists, setting the cache variable VAR accordingly
ac_fn_c_check_func ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if eval \${$3+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
/* Define $2 to an innocuous variant, in case <limits.h> declares $2.
   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
#define $2 innocuous_$2

/* System header to define __stub macros and hopefully few prototypes,
    which can conflict with char $2 (); below.
    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
    <limits.h> exists even on freestanding compilers.  */

#ifdef __STDC__
# include <limits.h>
#else
# include <assert.h>
#endif

#undef $2

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char $2 ();
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined __stub_$2 || defined __stub___$2
choke me
#endif

int
main ()
{
return $2 ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  eval "$3=yes"
else
  eval "$3=no"
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno

} # ac_fn_c_check_func
cat >config.log <<_ACEOF
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.

It was created by pwol $as_me 1.5, which was
generated by GNU Autoconf 2.69.  Invocation command line was

  $ $0 $@

_ACEOF
exec 5>>config.log
{
cat <<_ASUNAME
## --------- ##
## Platform. ##
## --------- ##

hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
uname -m = `(uname -m) 2>/dev/null || echo unknown`
uname -r = `(uname -r) 2>/dev/null || echo unknown`
uname -s = `(uname -s) 2>/dev/null || echo unknown`
uname -v = `(uname -v) 2>/dev/null || echo unknown`

/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`

/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`

_ASUNAME

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    $as_echo "PATH: $as_dir"
  done
IFS=$as_save_IFS

} >&5

cat >&5 <<_ACEOF


## ----------- ##
## Core tests. ##
## ----------- ##

_ACEOF


# Keep a trace of the command line.
# Strip out --no-create and --no-recursion so they do not pile up.
# Strip out --silent because we don't want to record it for future runs.
# Also quote any args containing shell meta-characters.
# Make two passes to allow for proper duplicate-argument suppression.
ac_configure_args=
ac_configure_args0=
ac_configure_args1=
ac_must_keep_next=false
for ac_pass in 1 2
do
  for ac_arg
  do
    case $ac_arg in
    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
    | -silent | --silent | --silen | --sile | --sil)
      continue ;;
    *\'*)
      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
    esac
    case $ac_pass in
    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
    2)
      as_fn_append ac_configure_args1 " '$ac_arg'"
      if test $ac_must_keep_next = true; then
	ac_must_keep_next=false # Got value, back to normal.
      else
	case $ac_arg in
	  *=* | --config-cache | -C | -disable-* | --disable-* \
	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
	  | -with-* | --with-* | -without-* | --without-* | --x)
	    case "$ac_configure_args0 " in
	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
	    esac
	    ;;
	  -* ) ac_must_keep_next=true ;;
	esac
      fi
      as_fn_append ac_configure_args " '$ac_arg'"
      ;;
    esac
  done
done
{ ac_configure_args0=; unset ac_configure_args0;}
{ ac_configure_args1=; unset ac_configure_args1;}

# When interrupted or exit'd, cleanup temporary files, and complete
# config.log.  We remove comments because anyway the quotes in there
# would cause problems or look ugly.
# WARNING: Use '\'' to represent an apostrophe within the trap.
# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
trap 'exit_status=$?
  # Save into config.log some information that might help in debugging.
  {
    echo

    $as_echo "## ---------------- ##
## Cache variables. ##
## ---------------- ##"
    echo
    # The following way of writing the cache mishandles newlines in values,
(
  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
    eval ac_val=\$$ac_var
    case $ac_val in #(
    *${as_nl}*)
      case $ac_var in #(
      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
      esac
      case $ac_var in #(
      _ | IFS | as_nl) ;; #(
      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
      *) { eval $ac_var=; unset $ac_var;} ;;
      esac ;;
    esac
  done
  (set) 2>&1 |
    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
    *${as_nl}ac_space=\ *)
      sed -n \
	"s/'\''/'\''\\\\'\'''\''/g;
	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
      ;; #(
    *)
      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
      ;;
    esac |
    sort
)
    echo

    $as_echo "## ----------------- ##
## Output variables. ##
## ----------------- ##"
    echo
    for ac_var in $ac_subst_vars
    do
      eval ac_val=\$$ac_var
      case $ac_val in
      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
      esac
      $as_echo "$ac_var='\''$ac_val'\''"
    done | sort
    echo

    if test -n "$ac_subst_files"; then
      $as_echo "## ------------------- ##
## File substitutions. ##
## ------------------- ##"
      echo
      for ac_var in $ac_subst_files
      do
	eval ac_val=\$$ac_var
	case $ac_val in
	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
	esac
	$as_echo "$ac_var='\''$ac_val'\''"
      done | sort
      echo
    fi

    if test -s confdefs.h; then
      $as_echo "## ----------- ##
## confdefs.h. ##
## ----------- ##"
      echo
      cat confdefs.h
      echo
    fi
    test "$ac_signal" != 0 &&
      $as_echo "$as_me: caught signal $ac_signal"
    $as_echo "$as_me: exit $exit_status"
  } >&5
  rm -f core *.core core.conftest.* &&
    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
    exit $exit_status
' 0
for ac_signal in 1 2 13 15; do
  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
done
ac_signal=0

# confdefs.h avoids OS command line length limits that DEFS can exceed.
rm -f -r conftest* confdefs.h

$as_echo "/* confdefs.h */" > confdefs.h

# Predefined preprocessor variables.

cat >>confdefs.h <<_ACEOF
#define PACKAGE_NAME "$PACKAGE_NAME"
_ACEOF

cat >>confdefs.h <<_ACEOF
#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
_ACEOF

cat >>confdefs.h <<_ACEOF
#define PACKAGE_VERSION "$PACKAGE_VERSION"
_ACEOF

cat >>confdefs.h <<_ACEOF
#define PACKAGE_STRING "$PACKAGE_STRING"
_ACEOF

cat >>confdefs.h <<_ACEOF
#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
_ACEOF

cat >>confdefs.h <<_ACEOF
#define PACKAGE_URL "$PACKAGE_URL"
_ACEOF


# Let the site file select an alternate cache file if it wants to.
# Prefer an explicitly selected file to automatically selected ones.
ac_site_file1=NONE
ac_site_file2=NONE
if test -n "$CONFIG_SITE"; then
  # We do not want a PATH search for config.site.
  case $CONFIG_SITE in #((
    -*)  ac_site_file1=./$CONFIG_SITE;;
    */*) ac_site_file1=$CONFIG_SITE;;
    *)   ac_site_file1=./$CONFIG_SITE;;
  esac
elif test "x$prefix" != xNONE; then
  ac_site_file1=$prefix/share/config.site
  ac_site_file2=$prefix/etc/config.site
else
  ac_site_file1=$ac_default_prefix/share/config.site
  ac_site_file2=$ac_default_prefix/etc/config.site
fi
for ac_site_file in "$ac_site_file1" "$ac_site_file2"
do
  test "x$ac_site_file" = xNONE && continue
  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
$as_echo "$as_me: loading site script $ac_site_file" >&6;}
    sed 's/^/| /' "$ac_site_file" >&5
    . "$ac_site_file" \
      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "failed to load site script $ac_site_file
See \`config.log' for more details" "$LINENO" 5; }
  fi
done

if test -r "$cache_file"; then
  # Some versions of bash will fail to source /dev/null (special files
  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
$as_echo "$as_me: loading cache $cache_file" >&6;}
    case $cache_file in
      [\\/]* | ?:[\\/]* ) . "$cache_file";;
      *)                      . "./$cache_file";;
    esac
  fi
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
$as_echo "$as_me: creating cache $cache_file" >&6;}
  >$cache_file
fi

# Check that the precious variables saved in the cache have kept the same
# value.
ac_cache_corrupted=false
for ac_var in $ac_precious_vars; do
  eval ac_old_set=\$ac_cv_env_${ac_var}_set
  eval ac_new_set=\$ac_env_${ac_var}_set
  eval ac_old_val=\$ac_cv_env_${ac_var}_value
  eval ac_new_val=\$ac_env_${ac_var}_value
  case $ac_old_set,$ac_new_set in
    set,)
      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
      ac_cache_corrupted=: ;;
    ,set)
      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
      ac_cache_corrupted=: ;;
    ,);;
    *)
      if test "x$ac_old_val" != "x$ac_new_val"; then
	# differences in whitespace do not lead to failure.
	ac_old_val_w=`echo x $ac_old_val`
	ac_new_val_w=`echo x $ac_new_val`
	if test "$ac_old_val_w" != "$ac_new_val_w"; then
	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
	  ac_cache_corrupted=:
	else
	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
	  eval $ac_var=\$ac_old_val
	fi
	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
      fi;;
  esac
  # Pass precious variables to config.status.
  if test "$ac_new_set" = set; then
    case $ac_new_val in
    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
    *) ac_arg=$ac_var=$ac_new_val ;;
    esac
    case " $ac_configure_args " in
      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
    esac
  fi
done
if $ac_cache_corrupted; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
fi
## -------------------- ##
## Main body of script. ##
## -------------------- ##

ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu




ac_config_headers="$ac_config_headers config.h"


ac_aux_dir=
for ac_dir in aux "$srcdir"/aux; do
  if test -f "$ac_dir/install-sh"; then
    ac_aux_dir=$ac_dir
    ac_install_sh="$ac_aux_dir/install-sh -c"
    break
  elif test -f "$ac_dir/install.sh"; then
    ac_aux_dir=$ac_dir
    ac_install_sh="$ac_aux_dir/install.sh -c"
    break
  elif test -f "$ac_dir/shtool"; then
    ac_aux_dir=$ac_dir
    ac_install_sh="$ac_aux_dir/shtool install -c"
    break
  fi
done
if test -z "$ac_aux_dir"; then
  as_fn_error $? "cannot find install-sh, install.sh, or shtool in aux \"$srcdir\"/aux" "$LINENO" 5
fi

# These three variables are undocumented and unsupported,
# and are intended to be withdrawn in a future Autoconf release.
# They can cause serious problems if a builder's source tree is in a directory
# whose full name contains unusual characters.
ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.



# Checks for programs.
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
set dummy ${ac_tool_prefix}gcc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_CC="${ac_tool_prefix}gcc"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_CC"; then
  ac_ct_CC=$CC
  # Extract the first word of "gcc", so it can be a program name with args.
set dummy gcc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_CC"; then
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_CC="gcc"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
$as_echo "$ac_ct_CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_CC" = x; then
    CC=""
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    CC=$ac_ct_CC
  fi
else
  CC="$ac_cv_prog_CC"
fi

if test -z "$CC"; then
          if test -n "$ac_tool_prefix"; then
    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
set dummy ${ac_tool_prefix}cc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_CC="${ac_tool_prefix}cc"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi
fi
if test -z "$CC"; then
  # Extract the first word of "cc", so it can be a program name with args.
set dummy cc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
  ac_prog_rejected=no
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
       ac_prog_rejected=yes
       continue
     fi
    ac_cv_prog_CC="cc"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

if test $ac_prog_rejected = yes; then
  # We found a bogon in the path, so make sure we never use it.
  set dummy $ac_cv_prog_CC
  shift
  if test $# != 0; then
    # We chose a different compiler from the bogus one.
    # However, it has the same basename, so the bogon will be chosen
    # first if we set CC to just the basename; use the full file name.
    shift
    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
  fi
fi
fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$CC"; then
  if test -n "$ac_tool_prefix"; then
  for ac_prog in cl.exe
  do
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    test -n "$CC" && break
  done
fi
if test -z "$CC"; then
  ac_ct_CC=$CC
  for ac_prog in cl.exe
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_CC"; then
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_CC="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
$as_echo "$ac_ct_CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$ac_ct_CC" && break
done

  if test "x$ac_ct_CC" = x; then
    CC=""
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    CC=$ac_ct_CC
  fi
fi

fi


test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "no acceptable C compiler found in \$PATH
See \`config.log' for more details" "$LINENO" 5; }

# Provide some information about the compiler.
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
set X $ac_compile
ac_compiler=$2
for ac_option in --version -v -V -qversion; do
  { { ac_try="$ac_compiler $ac_option >&5"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    sed '10a\
... rest of stderr output deleted ...
         10q' conftest.err >conftest.er1
    cat conftest.er1 >&5
  fi
  rm -f conftest.er1 conftest.err
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
done

cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
ac_clean_files_save=$ac_clean_files
ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
# Try to create an executable without -o first, disregard a.out.
# It will help us diagnose broken compilers, and finding out an intuition
# of exeext.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
$as_echo_n "checking whether the C compiler works... " >&6; }
ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`

# The possible output files:
ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"

ac_rmfiles=
for ac_file in $ac_files
do
  case $ac_file in
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
  esac
done
rm -f $ac_rmfiles

if { { ac_try="$ac_link_default"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link_default") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then :
  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
# in a Makefile.  We should not override ac_cv_exeext if it was cached,
# so that the user can short-circuit this test for compilers unknown to
# Autoconf.
for ac_file in $ac_files ''
do
  test -f "$ac_file" || continue
  case $ac_file in
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
	;;
    [ab].out )
	# We found the default executable, but exeext='' is most
	# certainly right.
	break;;
    *.* )
	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
	then :; else
	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
	fi
	# We set ac_cv_exeext here because the later test for it is not
	# safe: cross compilers may not add the suffix if given an `-o'
	# argument, so we may need to know it at that point already.
	# Even if this section looks crufty: it has the advantage of
	# actually working.
	break;;
    * )
	break;;
  esac
done
test "$ac_cv_exeext" = no && ac_cv_exeext=

else
  ac_file=''
fi
if test -z "$ac_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error 77 "C compiler cannot create executables
See \`config.log' for more details" "$LINENO" 5; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
$as_echo_n "checking for C compiler default output file name... " >&6; }
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
$as_echo "$ac_file" >&6; }
ac_exeext=$ac_cv_exeext

rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
ac_clean_files=$ac_clean_files_save
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
$as_echo_n "checking for suffix of executables... " >&6; }
if { { ac_try="$ac_link"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then :
  # If both `conftest.exe' and `conftest' are `present' (well, observable)
# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
# work properly (i.e., refer to `conftest.exe'), while it won't with
# `rm'.
for ac_file in conftest.exe conftest conftest.*; do
  test -f "$ac_file" || continue
  case $ac_file in
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
	  break;;
    * ) break;;
  esac
done
else
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "cannot compute suffix of executables: cannot compile and link
See \`config.log' for more details" "$LINENO" 5; }
fi
rm -f conftest conftest$ac_cv_exeext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
$as_echo "$ac_cv_exeext" >&6; }

rm -f conftest.$ac_ext
EXEEXT=$ac_cv_exeext
ac_exeext=$EXEEXT
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <stdio.h>
int
main ()
{
FILE *f = fopen ("conftest.out", "w");
 return ferror (f) || fclose (f) != 0;

  ;
  return 0;
}
_ACEOF
ac_clean_files="$ac_clean_files conftest.out"
# Check that the compiler produces executables we can run.  If not, either
# the compiler is broken, or we cross compile.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
$as_echo_n "checking whether we are cross compiling... " >&6; }
if test "$cross_compiling" != yes; then
  { { ac_try="$ac_link"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
  if { ac_try='./conftest$ac_cv_exeext'
  { { case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_try") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; }; then
    cross_compiling=no
  else
    if test "$cross_compiling" = maybe; then
	cross_compiling=yes
    else
	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "cannot run C compiled programs.
If you meant to cross compile, use \`--host'.
See \`config.log' for more details" "$LINENO" 5; }
    fi
  fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
$as_echo "$cross_compiling" >&6; }

rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
ac_clean_files=$ac_clean_files_save
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
$as_echo_n "checking for suffix of object files... " >&6; }
if ${ac_cv_objext+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
rm -f conftest.o conftest.obj
if { { ac_try="$ac_compile"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_compile") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then :
  for ac_file in conftest.o conftest.obj conftest.*; do
  test -f "$ac_file" || continue;
  case $ac_file in
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
       break;;
  esac
done
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "cannot compute suffix of object files: cannot compile
See \`config.log' for more details" "$LINENO" 5; }
fi
rm -f conftest.$ac_cv_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
$as_echo "$ac_cv_objext" >&6; }
OBJEXT=$ac_cv_objext
ac_objext=$OBJEXT
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
if ${ac_cv_c_compiler_gnu+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{
#ifndef __GNUC__
       choke me
#endif

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_compiler_gnu=yes
else
  ac_compiler_gnu=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_cv_c_compiler_gnu=$ac_compiler_gnu

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
$as_echo "$ac_cv_c_compiler_gnu" >&6; }
if test $ac_compiler_gnu = yes; then
  GCC=yes
else
  GCC=
fi
ac_test_CFLAGS=${CFLAGS+set}
ac_save_CFLAGS=$CFLAGS
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
$as_echo_n "checking whether $CC accepts -g... " >&6; }
if ${ac_cv_prog_cc_g+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_save_c_werror_flag=$ac_c_werror_flag
   ac_c_werror_flag=yes
   ac_cv_prog_cc_g=no
   CFLAGS="-g"
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_cv_prog_cc_g=yes
else
  CFLAGS=""
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :

else
  ac_c_werror_flag=$ac_save_c_werror_flag
	 CFLAGS="-g"
	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_cv_prog_cc_g=yes
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
   ac_c_werror_flag=$ac_save_c_werror_flag
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
$as_echo "$ac_cv_prog_cc_g" >&6; }
if test "$ac_test_CFLAGS" = set; then
  CFLAGS=$ac_save_CFLAGS
elif test $ac_cv_prog_cc_g = yes; then
  if test "$GCC" = yes; then
    CFLAGS="-g -O2"
  else
    CFLAGS="-g"
  fi
else
  if test "$GCC" = yes; then
    CFLAGS="-O2"
  else
    CFLAGS=
  fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
if ${ac_cv_prog_cc_c89+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_cv_prog_cc_c89=no
ac_save_CC=$CC
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <stdarg.h>
#include <stdio.h>
struct stat;
/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
struct buf { int x; };
FILE * (*rcsopen) (struct buf *, struct stat *, int);
static char *e (p, i)
     char **p;
     int i;
{
  return p[i];
}
static char *f (char * (*g) (char **, int), char **p, ...)
{
  char *s;
  va_list v;
  va_start (v,p);
  s = g (p, va_arg (v,int));
  va_end (v);
  return s;
}

/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
   function prototypes and stuff, but not '\xHH' hex character constants.
   These don't provoke an error unfortunately, instead are silently treated
   as 'x'.  The following induces an error, until -std is added to get
   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
   array size at least.  It's necessary to write '\x00'==0 to get something
   that's true only with -std.  */
int osf4_cc_array ['\x00' == 0 ? 1 : -1];

/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
   inside strings and character constants.  */
#define FOO(x) 'x'
int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];

int test (int i, double x);
struct s1 {int (*f) (int a);};
struct s2 {int (*f) (double a);};
int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
int argc;
char **argv;
int
main ()
{
return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
  ;
  return 0;
}
_ACEOF
for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
do
  CC="$ac_save_CC $ac_arg"
  if ac_fn_c_try_compile "$LINENO"; then :
  ac_cv_prog_cc_c89=$ac_arg
fi
rm -f core conftest.err conftest.$ac_objext
  test "x$ac_cv_prog_cc_c89" != "xno" && break
done
rm -f conftest.$ac_ext
CC=$ac_save_CC

fi
# AC_CACHE_VAL
case "x$ac_cv_prog_cc_c89" in
  x)
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
$as_echo "none needed" >&6; } ;;
  xno)
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
$as_echo "unsupported" >&6; } ;;
  *)
    CC="$CC $ac_cv_prog_cc_c89"
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
esac
if test "x$ac_cv_prog_cc_c89" != xno; then :

fi

ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu

# Find a good install program.  We prefer a C program (faster),
# so one script is as good as another.  But avoid the broken or
# incompatible versions:
# SysV /etc/install, /usr/sbin/install
# SunOS /usr/etc/install
# IRIX /sbin/install
# AIX /bin/install
# AmigaOS /C/install, which installs bootblocks on floppy discs
# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
# AFS /usr/afsws/bin/install, which mishandles nonexistent args
# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
# OS/2's system install, which has a completely different semantic
# ./install, which can be erroneously created by make from ./install.sh.
# Reject install programs that cannot install multiple files.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
$as_echo_n "checking for a BSD-compatible install... " >&6; }
if test -z "$INSTALL"; then
if ${ac_cv_path_install+:} false; then :
  $as_echo_n "(cached) " >&6
else
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    # Account for people who put trailing slashes in PATH elements.
case $as_dir/ in #((
  ./ | .// | /[cC]/* | \
  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
  ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
  /usr/ucb/* ) ;;
  *)
    # OSF1 and SCO ODT 3.0 have their own names for install.
    # Don't use installbsd from OSF since it installs stuff as root
    # by default.
    for ac_prog in ginstall scoinst install; do
      for ac_exec_ext in '' $ac_executable_extensions; do
	if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
	  if test $ac_prog = install &&
	    grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
	    # AIX install.  It has an incompatible calling convention.
	    :
	  elif test $ac_prog = install &&
	    grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
	    # program-specific install script used by HP pwplus--don't use.
	    :
	  else
	    rm -rf conftest.one conftest.two conftest.dir
	    echo one > conftest.one
	    echo two > conftest.two
	    mkdir conftest.dir
	    if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
	      test -s conftest.one && test -s conftest.two &&
	      test -s conftest.dir/conftest.one &&
	      test -s conftest.dir/conftest.two
	    then
	      ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
	      break 3
	    fi
	  fi
	fi
      done
    done
    ;;
esac

  done
IFS=$as_save_IFS

rm -rf conftest.one conftest.two conftest.dir

fi
  if test "${ac_cv_path_install+set}" = set; then
    INSTALL=$ac_cv_path_install
  else
    # As a last resort, use the slow shell script.  Don't cache a
    # value for INSTALL within a source directory, because that will
    # break other packages using the cache if that directory is
    # removed, or if the value is a relative name.
    INSTALL=$ac_install_sh
  fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
$as_echo "$INSTALL" >&6; }

# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
# It thinks the first close brace ends the variable substitution.
test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'

test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'

test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
set x ${MAKE-make}
ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat >conftest.make <<\_ACEOF
SHELL = /bin/sh
all:
	@echo '@@@%%%=$(MAKE)=@@@%%%'
_ACEOF
# GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
case `${MAKE-make} -f conftest.make 2>/dev/null` in
  *@@@%%%=?*=@@@%%%*)
    eval ac_cv_prog_make_${ac_make}_set=yes;;
  *)
    eval ac_cv_prog_make_${ac_make}_set=no;;
esac
rm -f conftest.make
fi
if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
  SET_MAKE=
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
  SET_MAKE="MAKE=${MAKE-make}"
fi


# Checks for libraries.

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for pthread_create in -lpthread" >&5
$as_echo_n "checking for pthread_create in -lpthread... " >&6; }
if ${ac_cv_lib_pthread_pthread_create+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lpthread  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char pthread_create ();
int
main ()
{
return pthread_create ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_pthread_pthread_create=yes
else
  ac_cv_lib_pthread_pthread_create=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_create" >&5
$as_echo "$ac_cv_lib_pthread_pthread_create" >&6; }
if test "x$ac_cv_lib_pthread_pthread_create" = xyes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBPTHREAD 1
_ACEOF

  LIBS="-lpthread $LIBS"

fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for connect in -lsocket" >&5
$as_echo_n "checking for connect in -lsocket... " >&6; }
if ${ac_cv_lib_socket_connect+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lsocket  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char connect ();
int
main ()
{
return connect ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_socket_connect=yes
else
  ac_cv_lib_socket_connect=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_connect" >&5
$as_echo "$ac_cv_lib_socket_connect" >&6; }
if test "x$ac_cv_lib_socket_connect" = xyes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBSOCKET 1
_ACEOF

  LIBS="-lsocket $LIBS"

fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnsl" >&5
$as_echo_n "checking for gethostbyname in -lnsl... " >&6; }
if ${ac_cv_lib_nsl_gethostbyname+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lnsl  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char gethostbyname ();
int
main ()
{
return gethostbyname ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_nsl_gethostbyname=yes
else
  ac_cv_lib_nsl_gethostbyname=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_gethostbyname" >&5
$as_echo "$ac_cv_lib_nsl_gethostbyname" >&6; }
if test "x$ac_cv_lib_nsl_gethostbyname" = xyes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBNSL 1
_ACEOF

  LIBS="-lnsl $LIBS"

fi


# Checks for header files.
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
$as_echo_n "checking how to run the C preprocessor... " >&6; }
# On Suns, sometimes $CPP names a directory.
if test -n "$CPP" && test -d "$CPP"; then
  CPP=
fi
if test -z "$CPP"; then
  if ${ac_cv_prog_CPP+:} false; then :
  $as_echo_n "(cached) " >&6
else
      # Double quotes because CPP needs to be expanded
    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
    do
      ac_preproc_ok=false
for ac_c_preproc_warn_flag in '' yes
do
  # Use a header file that comes with gcc, so configuring glibc
  # with a fresh cross-compiler works.
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
  # <limits.h> exists even on freestanding compilers.
  # On the NeXT, cc -E runs the code through the compiler's parser,
  # not just through cpp. "Syntax error" is here to catch this case.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#ifdef __STDC__
# include <limits.h>
#else
# include <assert.h>
#endif
		     Syntax error
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :

else
  # Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.i conftest.$ac_ext

  # OK, works on sane cases.  Now check whether nonexistent headers
  # can be detected and how.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <ac_nonexistent.h>
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
  # Broken: success on invalid input.
continue
else
  # Passes both tests.
ac_preproc_ok=:
break
fi
rm -f conftest.err conftest.i conftest.$ac_ext

done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.i conftest.err conftest.$ac_ext
if $ac_preproc_ok; then :
  break
fi

    done
    ac_cv_prog_CPP=$CPP

fi
  CPP=$ac_cv_prog_CPP
else
  ac_cv_prog_CPP=$CPP
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
$as_echo "$CPP" >&6; }
ac_preproc_ok=false
for ac_c_preproc_warn_flag in '' yes
do
  # Use a header file that comes with gcc, so configuring glibc
  # with a fresh cross-compiler works.
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
  # <limits.h> exists even on freestanding compilers.
  # On the NeXT, cc -E runs the code through the compiler's parser,
  # not just through cpp. "Syntax error" is here to catch this case.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#ifdef __STDC__
# include <limits.h>
#else
# include <assert.h>
#endif
		     Syntax error
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :

else
  # Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.i conftest.$ac_ext

  # OK, works on sane cases.  Now check whether nonexistent headers
  # can be detected and how.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <ac_nonexistent.h>
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
  # Broken: success on invalid input.
continue
else
  # Passes both tests.
ac_preproc_ok=:
break
fi
rm -f conftest.err conftest.i conftest.$ac_ext

done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.i conftest.err conftest.$ac_ext
if $ac_preproc_ok; then :

else
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
See \`config.log' for more details" "$LINENO" 5; }
fi

ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
if ${ac_cv_path_GREP+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -z "$GREP"; then
  ac_path_GREP_found=false
  # Loop through the user's path and test for each of PROGNAME-LIST
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_prog in grep ggrep; do
    for ac_exec_ext in '' $ac_executable_extensions; do
      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
      as_fn_executable_p "$ac_path_GREP" || continue
# Check for GNU ac_path_GREP and select it if it is found.
  # Check for GNU $ac_path_GREP
case `"$ac_path_GREP" --version 2>&1` in
*GNU*)
  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
*)
  ac_count=0
  $as_echo_n 0123456789 >"conftest.in"
  while :
  do
    cat "conftest.in" "conftest.in" >"conftest.tmp"
    mv "conftest.tmp" "conftest.in"
    cp "conftest.in" "conftest.nl"
    $as_echo 'GREP' >> "conftest.nl"
    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
    as_fn_arith $ac_count + 1 && ac_count=$as_val
    if test $ac_count -gt ${ac_path_GREP_max-0}; then
      # Best one so far, save it but keep looking for a better one
      ac_cv_path_GREP="$ac_path_GREP"
      ac_path_GREP_max=$ac_count
    fi
    # 10*(2^10) chars as input seems more than enough
    test $ac_count -gt 10 && break
  done
  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
esac

      $ac_path_GREP_found && break 3
    done
  done
  done
IFS=$as_save_IFS
  if test -z "$ac_cv_path_GREP"; then
    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
  fi
else
  ac_cv_path_GREP=$GREP
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
$as_echo "$ac_cv_path_GREP" >&6; }
 GREP="$ac_cv_path_GREP"


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
$as_echo_n "checking for egrep... " >&6; }
if ${ac_cv_path_EGREP+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
   then ac_cv_path_EGREP="$GREP -E"
   else
     if test -z "$EGREP"; then
  ac_path_EGREP_found=false
  # Loop through the user's path and test for each of PROGNAME-LIST
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_prog in egrep; do
    for ac_exec_ext in '' $ac_executable_extensions; do
      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
      as_fn_executable_p "$ac_path_EGREP" || continue
# Check for GNU ac_path_EGREP and select it if it is found.
  # Check for GNU $ac_path_EGREP
case `"$ac_path_EGREP" --version 2>&1` in
*GNU*)
  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
*)
  ac_count=0
  $as_echo_n 0123456789 >"conftest.in"
  while :
  do
    cat "conftest.in" "conftest.in" >"conftest.tmp"
    mv "conftest.tmp" "conftest.in"
    cp "conftest.in" "conftest.nl"
    $as_echo 'EGREP' >> "conftest.nl"
    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
    as_fn_arith $ac_count + 1 && ac_count=$as_val
    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
      # Best one so far, save it but keep looking for a better one
      ac_cv_path_EGREP="$ac_path_EGREP"
      ac_path_EGREP_max=$ac_count
    fi
    # 10*(2^10) chars as input seems more than enough
    test $ac_count -gt 10 && break
  done
  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
esac

      $ac_path_EGREP_found && break 3
    done
  done
  done
IFS=$as_save_IFS
  if test -z "$ac_cv_path_EGREP"; then
    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
  fi
else
  ac_cv_path_EGREP=$EGREP
fi

   fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
$as_echo "$ac_cv_path_EGREP" >&6; }
 EGREP="$ac_cv_path_EGREP"


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
$as_echo_n "checking for ANSI C header files... " >&6; }
if ${ac_cv_header_stdc+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <float.h>

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_cv_header_stdc=yes
else
  ac_cv_header_stdc=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

if test $ac_cv_header_stdc = yes; then
  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <string.h>

_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  $EGREP "memchr" >/dev/null 2>&1; then :

else
  ac_cv_header_stdc=no
fi
rm -f conftest*

fi

if test $ac_cv_header_stdc = yes; then
  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <stdlib.h>

_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  $EGREP "free" >/dev/null 2>&1; then :

else
  ac_cv_header_stdc=no
fi
rm -f conftest*

fi

if test $ac_cv_header_stdc = yes; then
  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
  if test "$cross_compiling" = yes; then :
  :
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <ctype.h>
#include <stdlib.h>
#if ((' ' & 0x0FF) == 0x020)
# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
#else
# define ISLOWER(c) \
		   (('a' <= (c) && (c) <= 'i') \
		     || ('j' <= (c) && (c) <= 'r') \
		     || ('s' <= (c) && (c) <= 'z'))
# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
#endif

#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
int
main ()
{
  int i;
  for (i = 0; i < 256; i++)
    if (XOR (islower (i), ISLOWER (i))
	|| toupper (i) != TOUPPER (i))
      return 2;
  return 0;
}
_ACEOF
if ac_fn_c_try_run "$LINENO"; then :

else
  ac_cv_header_stdc=no
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
$as_echo "$ac_cv_header_stdc" >&6; }
if test $ac_cv_header_stdc = yes; then

$as_echo "#define STDC_HEADERS 1" >>confdefs.h

fi

# On IRIX 5.3, sys/types and inttypes.h are conflicting.
for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
		  inttypes.h stdint.h unistd.h
do :
  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
"
if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
  cat >>confdefs.h <<_ACEOF
#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
_ACEOF

fi

done


for ac_header in arpa/inet.h fcntl.h netdb.h netinet/in.h stdlib.h string.h sys/socket.h syslog.h unistd.h
do :
  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
  cat >>confdefs.h <<_ACEOF
#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
_ACEOF

fi

done


# Checks for typedefs, structures, and compiler characteristics.
ac_fn_c_check_type "$LINENO" "pid_t" "ac_cv_type_pid_t" "$ac_includes_default"
if test "x$ac_cv_type_pid_t" = xyes; then :

else

cat >>confdefs.h <<_ACEOF
#define pid_t int
_ACEOF

fi

ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
if test "x$ac_cv_type_size_t" = xyes; then :

else

cat >>confdefs.h <<_ACEOF
#define size_t unsigned int
_ACEOF

fi

ac_fn_c_check_type "$LINENO" "ssize_t" "ac_cv_type_ssize_t" "$ac_includes_default"
if test "x$ac_cv_type_ssize_t" = xyes; then :

else

cat >>confdefs.h <<_ACEOF
#define ssize_t int
_ACEOF

fi


# Checks for library functions.
for ac_header in vfork.h
do :
  ac_fn_c_check_header_mongrel "$LINENO" "vfork.h" "ac_cv_header_vfork_h" "$ac_includes_default"
if test "x$ac_cv_header_vfork_h" = xyes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_VFORK_H 1
_ACEOF

fi

done

for ac_func in fork vfork
do :
  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
  cat >>confdefs.h <<_ACEOF
#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
_ACEOF

fi
done

if test "x$ac_cv_func_fork" = xyes; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working fork" >&5
$as_echo_n "checking for working fork... " >&6; }
if ${ac_cv_func_fork_works+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test "$cross_compiling" = yes; then :
  ac_cv_func_fork_works=cross
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$ac_includes_default
int
main ()
{

	  /* By Ruediger Kuhlmann. */
	  return fork () < 0;

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_run "$LINENO"; then :
  ac_cv_func_fork_works=yes
else
  ac_cv_func_fork_works=no
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_fork_works" >&5
$as_echo "$ac_cv_func_fork_works" >&6; }

else
  ac_cv_func_fork_works=$ac_cv_func_fork
fi
if test "x$ac_cv_func_fork_works" = xcross; then
  case $host in
    *-*-amigaos* | *-*-msdosdjgpp*)
      # Override, as these systems have only a dummy fork() stub
      ac_cv_func_fork_works=no
      ;;
    *)
      ac_cv_func_fork_works=yes
      ;;
  esac
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: result $ac_cv_func_fork_works guessed because of cross compilation" >&5
$as_echo "$as_me: WARNING: result $ac_cv_func_fork_works guessed because of cross compilation" >&2;}
fi
ac_cv_func_vfork_works=$ac_cv_func_vfork
if test "x$ac_cv_func_vfork" = xyes; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working vfork" >&5
$as_echo_n "checking for working vfork... " >&6; }
if ${ac_cv_func_vfork_works+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test "$cross_compiling" = yes; then :
  ac_cv_func_vfork_works=cross
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
/* Thanks to Paul Eggert for this test.  */
$ac_includes_default
#include <sys/wait.h>
#ifdef HAVE_VFORK_H
# include <vfork.h>
#endif
/* On some sparc systems, changes by the child to local and incoming
   argument registers are propagated back to the parent.  The compiler
   is told about this with #include <vfork.h>, but some compilers
   (e.g. gcc -O) don't grok <vfork.h>.  Test for this by using a
   static variable whose address is put into a register that is
   clobbered by the vfork.  */
static void
#ifdef __cplusplus
sparc_address_test (int arg)
# else
sparc_address_test (arg) int arg;
#endif
{
  static pid_t child;
  if (!child) {
    child = vfork ();
    if (child < 0) {
      perror ("vfork");
      _exit(2);
    }
    if (!child) {
      arg = getpid();
      write(-1, "", 0);
      _exit (arg);
    }
  }
}

int
main ()
{
  pid_t parent = getpid ();
  pid_t child;

  sparc_address_test (0);

  child = vfork ();

  if (child == 0) {
    /* Here is another test for sparc vfork register problems.  This
       test uses lots of local variables, at least as many local
       variables as main has allocated so far including compiler
       temporaries.  4 locals are enough for gcc 1.40.3 on a Solaris
       4.1.3 sparc, but we use 8 to be safe.  A buggy compiler should
       reuse the register of parent for one of the local variables,
       since it will think that parent can't possibly be used any more
       in this routine.  Assigning to the local variable will thus
       munge parent in the parent process.  */
    pid_t
      p = getpid(), p1 = getpid(), p2 = getpid(), p3 = getpid(),
      p4 = getpid(), p5 = getpid(), p6 = getpid(), p7 = getpid();
    /* Convince the compiler that p..p7 are live; otherwise, it might
       use the same hardware register for all 8 local variables.  */
    if (p != p1 || p != p2 || p != p3 || p != p4
	|| p != p5 || p != p6 || p != p7)
      _exit(1);

    /* On some systems (e.g. IRIX 3.3), vfork doesn't separate parent
       from child file descriptors.  If the child closes a descriptor
       before it execs or exits, this munges the parent's descriptor
       as well.  Test for this by closing stdout in the child.  */
    _exit(close(fileno(stdout)) != 0);
  } else {
    int status;
    struct stat st;

    while (wait(&status) != child)
      ;
    return (
	 /* Was there some problem with vforking?  */
	 child < 0

	 /* Did the child fail?  (This shouldn't happen.)  */
	 || status

	 /* Did the vfork/compiler bug occur?  */
	 || parent != getpid()

	 /* Did the file descriptor bug occur?  */
	 || fstat(fileno(stdout), &st) != 0
	 );
  }
}
_ACEOF
if ac_fn_c_try_run "$LINENO"; then :
  ac_cv_func_vfork_works=yes
else
  ac_cv_func_vfork_works=no
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_vfork_works" >&5
$as_echo "$ac_cv_func_vfork_works" >&6; }

fi;
if test "x$ac_cv_func_fork_works" = xcross; then
  ac_cv_func_vfork_works=$ac_cv_func_vfork
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: result $ac_cv_func_vfork_works guessed because of cross compilation" >&5
$as_echo "$as_me: WARNING: result $ac_cv_func_vfork_works guessed because of cross compilation" >&2;}
fi

if test "x$ac_cv_func_vfork_works" = xyes; then

$as_echo "#define HAVE_WORKING_VFORK 1" >>confdefs.h

else

$as_echo "#define vfork fork" >>confdefs.h

fi
if test "x$ac_cv_func_fork_works" = xyes; then

$as_echo "#define HAVE_WORKING_FORK 1" >>confdefs.h

fi

for ac_header in stdlib.h
do :
  ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
if test "x$ac_cv_header_stdlib_h" = xyes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_STDLIB_H 1
_ACEOF

fi

done

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible malloc" >&5
$as_echo_n "checking for GNU libc compatible malloc... " >&6; }
if ${ac_cv_func_malloc_0_nonnull+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test "$cross_compiling" = yes; then :
  ac_cv_func_malloc_0_nonnull=no
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#if defined STDC_HEADERS || defined HAVE_STDLIB_H
# include <stdlib.h>
#else
char *malloc ();
#endif

int
main ()
{
return ! malloc (0);
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_run "$LINENO"; then :
  ac_cv_func_malloc_0_nonnull=yes
else
  ac_cv_func_malloc_0_nonnull=no
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_malloc_0_nonnull" >&5
$as_echo "$ac_cv_func_malloc_0_nonnull" >&6; }
if test $ac_cv_func_malloc_0_nonnull = yes; then :

$as_echo "#define HAVE_MALLOC 1" >>confdefs.h

else
  $as_echo "#define HAVE_MALLOC 0" >>confdefs.h

   case " $LIBOBJS " in
  *" malloc.$ac_objext "* ) ;;
  *) LIBOBJS="$LIBOBJS malloc.$ac_objext"
 ;;
esac


$as_echo "#define malloc rpl_malloc" >>confdefs.h

fi


for ac_header in stdlib.h
do :
  ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
if test "x$ac_cv_header_stdlib_h" = xyes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_STDLIB_H 1
_ACEOF

fi

done

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible realloc" >&5
$as_echo_n "checking for GNU libc compatible realloc... " >&6; }
if ${ac_cv_func_realloc_0_nonnull+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test "$cross_compiling" = yes; then :
  ac_cv_func_realloc_0_nonnull=no
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#if defined STDC_HEADERS || defined HAVE_STDLIB_H
# include <stdlib.h>
#else
char *realloc ();
#endif

int
main ()
{
return ! realloc (0, 0);
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_run "$LINENO"; then :
  ac_cv_func_realloc_0_nonnull=yes
else
  ac_cv_func_realloc_0_nonnull=no
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_realloc_0_nonnull" >&5
$as_echo "$ac_cv_func_realloc_0_nonnull" >&6; }
if test $ac_cv_func_realloc_0_nonnull = yes; then :

$as_echo "#define HAVE_REALLOC 1" >>confdefs.h

else
  $as_echo "#define HAVE_REALLOC 0" >>confdefs.h

   case " $LIBOBJS " in
  *" realloc.$ac_objext "* ) ;;
  *) LIBOBJS="$LIBOBJS realloc.$ac_objext"
 ;;
esac


$as_echo "#define realloc rpl_realloc" >>confdefs.h

fi


for ac_func in dup2 memset socket strchr strdup strerror
do :
  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
  cat >>confdefs.h <<_ACEOF
#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
_ACEOF

fi
done


ac_config_files="$ac_config_files Makefile pwol.1 pwol.conf.5 pkgs/Makefile.port"

cat >confcache <<\_ACEOF
# This file is a shell script that caches the results of configure
# tests run on this system so they can be shared between configure
# scripts and configure runs, see configure's option --config-cache.
# It is not useful on other systems.  If it contains results you don't
# want to keep, you may remove or edit it.
#
# config.status only pays attention to the cache file if you give it
# the --recheck option to rerun configure.
#
# `ac_cv_env_foo' variables (set or unset) will be overridden when
# loading this file, other *unset* `ac_cv_foo' will be assigned the
# following values.

_ACEOF

# The following way of writing the cache mishandles newlines in values,
# but we know of no workaround that is simple, portable, and efficient.
# So, we kill variables containing newlines.
# Ultrix sh set writes to stderr and can't be redirected directly,
# and sets the high bit in the cache file unless we assign to the vars.
(
  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
    eval ac_val=\$$ac_var
    case $ac_val in #(
    *${as_nl}*)
      case $ac_var in #(
      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
      esac
      case $ac_var in #(
      _ | IFS | as_nl) ;; #(
      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
      *) { eval $ac_var=; unset $ac_var;} ;;
      esac ;;
    esac
  done

  (set) 2>&1 |
    case $as_nl`(ac_space=' '; set) 2>&1` in #(
    *${as_nl}ac_space=\ *)
      # `set' does not quote correctly, so add quotes: double-quote
      # substitution turns \\\\ into \\, and sed turns \\ into \.
      sed -n \
	"s/'/'\\\\''/g;
	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
      ;; #(
    *)
      # `set' quotes correctly as required by POSIX, so do not add quotes.
      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
      ;;
    esac |
    sort
) |
  sed '
     /^ac_cv_env_/b end
     t clear
     :clear
     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
     t end
     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
     :end' >>confcache
if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
  if test -w "$cache_file"; then
    if test "x$cache_file" != "x/dev/null"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
$as_echo "$as_me: updating cache $cache_file" >&6;}
      if test ! -f "$cache_file" || test -h "$cache_file"; then
	cat confcache >"$cache_file"
      else
        case $cache_file in #(
        */* | ?:*)
	  mv -f confcache "$cache_file"$$ &&
	  mv -f "$cache_file"$$ "$cache_file" ;; #(
        *)
	  mv -f confcache "$cache_file" ;;
	esac
      fi
    fi
  else
    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
  fi
fi
rm -f confcache

test "x$prefix" = xNONE && prefix=$ac_default_prefix
# Let make expand exec_prefix.
test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'

DEFS=-DHAVE_CONFIG_H

ac_libobjs=
ac_ltlibobjs=
U=
for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
  # 1. Remove the extension, and $U if already installed.
  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
  #    will be set to the directory where LIBOBJS objects are built.
  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
done
LIBOBJS=$ac_libobjs

LTLIBOBJS=$ac_ltlibobjs



: "${CONFIG_STATUS=./config.status}"
ac_write_fail=0
ac_clean_files_save=$ac_clean_files
ac_clean_files="$ac_clean_files $CONFIG_STATUS"
{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
as_write_fail=0
cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
#! $SHELL
# Generated by $as_me.
# Run this file to recreate the current configuration.
# Compiler output produced by configure, useful for debugging
# configure, is in config.log if it exists.

debug=false
ac_cs_recheck=false
ac_cs_silent=false

SHELL=\${CONFIG_SHELL-$SHELL}
export SHELL
_ASEOF
cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
## -------------------- ##
## M4sh Initialization. ##
## -------------------- ##

# Be more Bourne compatible
DUALCASE=1; export DUALCASE # for MKS sh
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
  setopt NO_GLOB_SUBST
else
  case `(set -o) 2>/dev/null` in #(
  *posix*) :
    set -o posix ;; #(
  *) :
     ;;
esac
fi


as_nl='
'
export as_nl
# Printing a long string crashes Solaris 7 /usr/bin/printf.
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
# Prefer a ksh shell builtin over an external printf program on Solaris,
# but without wasting forks for bash or zsh.
if test -z "$BASH_VERSION$ZSH_VERSION" \
    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='print -r --'
  as_echo_n='print -rn --'
elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='printf %s\n'
  as_echo_n='printf %s'
else
  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
    as_echo_n='/usr/ucb/echo -n'
  else
    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
    as_echo_n_body='eval
      arg=$1;
      case $arg in #(
      *"$as_nl"*)
	expr "X$arg" : "X\\(.*\\)$as_nl";
	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
      esac;
      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
    '
    export as_echo_n_body
    as_echo_n='sh -c $as_echo_n_body as_echo'
  fi
  export as_echo_body
  as_echo='sh -c $as_echo_body as_echo'
fi

# The user is always right.
if test "${PATH_SEPARATOR+set}" != set; then
  PATH_SEPARATOR=:
  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
      PATH_SEPARATOR=';'
  }
fi


# IFS
# We need space, tab and new line, in precisely that order.  Quoting is
# there to prevent editors from complaining about space-tab.
# (If _AS_PATH_WALK were called with IFS unset, it would disable word
# splitting by setting IFS to empty value.)
IFS=" ""	$as_nl"

# Find who we are.  Look in the path if we contain no directory separator.
as_myself=
case $0 in #((
  *[\\/]* ) as_myself=$0 ;;
  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
  done
IFS=$as_save_IFS

     ;;
esac
# We did not find ourselves, most probably we were run as `sh COMMAND'
# in which case we are not to be found in the path.
if test "x$as_myself" = x; then
  as_myself=$0
fi
if test ! -f "$as_myself"; then
  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
  exit 1
fi

# Unset variables that we do not need and which cause bugs (e.g. in
# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
# suppresses any "Segmentation fault" message there.  '((' could
# trigger a bug in pdksh 5.2.14.
for as_var in BASH_ENV ENV MAIL MAILPATH
do eval test x\${$as_var+set} = xset \
  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
done
PS1='$ '
PS2='> '
PS4='+ '

# NLS nuisances.
LC_ALL=C
export LC_ALL
LANGUAGE=C
export LANGUAGE

# CDPATH.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH


# as_fn_error STATUS ERROR [LINENO LOG_FD]
# ----------------------------------------
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
# script with STATUS, using 1 if that was 0.
as_fn_error ()
{
  as_status=$1; test $as_status -eq 0 && as_status=1
  if test "$4"; then
    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
  fi
  $as_echo "$as_me: error: $2" >&2
  as_fn_exit $as_status
} # as_fn_error


# as_fn_set_status STATUS
# -----------------------
# Set $? to STATUS, without forking.
as_fn_set_status ()
{
  return $1
} # as_fn_set_status

# as_fn_exit STATUS
# -----------------
# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
as_fn_exit ()
{
  set +e
  as_fn_set_status $1
  exit $1
} # as_fn_exit

# as_fn_unset VAR
# ---------------
# Portably unset VAR.
as_fn_unset ()
{
  { eval $1=; unset $1;}
}
as_unset=as_fn_unset
# as_fn_append VAR VALUE
# ----------------------
# Append the text in VALUE to the end of the definition contained in VAR. Take
# advantage of any shell optimizations that allow amortized linear growth over
# repeated appends, instead of the typical quadratic growth present in naive
# implementations.
if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
  eval 'as_fn_append ()
  {
    eval $1+=\$2
  }'
else
  as_fn_append ()
  {
    eval $1=\$$1\$2
  }
fi # as_fn_append

# as_fn_arith ARG...
# ------------------
# Perform arithmetic evaluation on the ARGs, and store the result in the
# global $as_val. Take advantage of shells that can avoid forks. The arguments
# must be portable across $(()) and expr.
if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
  eval 'as_fn_arith ()
  {
    as_val=$(( $* ))
  }'
else
  as_fn_arith ()
  {
    as_val=`expr "$@" || test $? -eq 1`
  }
fi # as_fn_arith


if expr a : '\(a\)' >/dev/null 2>&1 &&
   test "X`expr 00001 : '.*\(...\)'`" = X001; then
  as_expr=expr
else
  as_expr=false
fi

if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
  as_basename=basename
else
  as_basename=false
fi

if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
  as_dirname=dirname
else
  as_dirname=false
fi

as_me=`$as_basename -- "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
	 X"$0" : 'X\(//\)$' \| \
	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X/"$0" |
    sed '/^.*\/\([^/][^/]*\)\/*$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`

# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits

ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in #(((((
-n*)
  case `echo 'xy\c'` in
  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
  xy)  ECHO_C='\c';;
  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
       ECHO_T='	';;
  esac;;
*)
  ECHO_N='-n';;
esac

rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
  rm -f conf$$.dir/conf$$.file
else
  rm -f conf$$.dir
  mkdir conf$$.dir 2>/dev/null
fi
if (echo >conf$$.file) 2>/dev/null; then
  if ln -s conf$$.file conf$$ 2>/dev/null; then
    as_ln_s='ln -s'
    # ... but there are two gotchas:
    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
    # In both cases, we have to default to `cp -pR'.
    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
      as_ln_s='cp -pR'
  elif ln conf$$.file conf$$ 2>/dev/null; then
    as_ln_s=ln
  else
    as_ln_s='cp -pR'
  fi
else
  as_ln_s='cp -pR'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null


# as_fn_mkdir_p
# -------------
# Create "$as_dir" as a directory, including parents if necessary.
as_fn_mkdir_p ()
{

  case $as_dir in #(
  -*) as_dir=./$as_dir;;
  esac
  test -d "$as_dir" || eval $as_mkdir_p || {
    as_dirs=
    while :; do
      case $as_dir in #(
      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
      *) as_qdir=$as_dir;;
      esac
      as_dirs="'$as_qdir' $as_dirs"
      as_dir=`$as_dirname -- "$as_dir" ||
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$as_dir" : 'X\(//\)[^/]' \| \
	 X"$as_dir" : 'X\(//\)$' \| \
	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_dir" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
      test -d "$as_dir" && break
    done
    test -z "$as_dirs" || eval "mkdir $as_dirs"
  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"


} # as_fn_mkdir_p
if mkdir -p . 2>/dev/null; then
  as_mkdir_p='mkdir -p "$as_dir"'
else
  test -d ./-p && rmdir ./-p
  as_mkdir_p=false
fi


# as_fn_executable_p FILE
# -----------------------
# Test if FILE is an executable regular file.
as_fn_executable_p ()
{
  test -f "$1" && test -x "$1"
} # as_fn_executable_p
as_test_x='test -x'
as_executable_p=as_fn_executable_p

# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"

# Sed expression to map a string onto a valid variable name.
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"


exec 6>&1
## ----------------------------------- ##
## Main body of $CONFIG_STATUS script. ##
## ----------------------------------- ##
_ASEOF
test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# Save the log message, to keep $0 and so on meaningful, and to
# report actual input values of CONFIG_FILES etc. instead of their
# values after options handling.
ac_log="
This file was extended by pwol $as_me 1.5, which was
generated by GNU Autoconf 2.69.  Invocation command line was

  CONFIG_FILES    = $CONFIG_FILES
  CONFIG_HEADERS  = $CONFIG_HEADERS
  CONFIG_LINKS    = $CONFIG_LINKS
  CONFIG_COMMANDS = $CONFIG_COMMANDS
  $ $0 $@

on `(hostname || uname -n) 2>/dev/null | sed 1q`
"

_ACEOF

case $ac_config_files in *"
"*) set x $ac_config_files; shift; ac_config_files=$*;;
esac

case $ac_config_headers in *"
"*) set x $ac_config_headers; shift; ac_config_headers=$*;;
esac


cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
# Files that config.status was made for.
config_files="$ac_config_files"
config_headers="$ac_config_headers"

_ACEOF

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
ac_cs_usage="\
\`$as_me' instantiates files and other configuration actions
from templates according to the current configuration.  Unless the files
and actions are specified as TAGs, all are instantiated by default.

Usage: $0 [OPTION]... [TAG]...

  -h, --help       print this help, then exit
  -V, --version    print version number and configuration settings, then exit
      --config     print configuration, then exit
  -q, --quiet, --silent
                   do not print progress messages
  -d, --debug      don't remove temporary files
      --recheck    update $as_me by reconfiguring in the same conditions
      --file=FILE[:TEMPLATE]
                   instantiate the configuration file FILE
      --header=FILE[:TEMPLATE]
                   instantiate the configuration header FILE

Configuration files:
$config_files

Configuration headers:
$config_headers

Report bugs to <pen@lysator.liu.se>.
pwol home page: <https://github.com/ptrrkssn/pwol>."

_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
ac_cs_version="\\
pwol config.status 1.5
configured by $0, generated by GNU Autoconf 2.69,
  with options \\"\$ac_cs_config\\"

Copyright (C) 2012 Free Software Foundation, Inc.
This config.status script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it."

ac_pwd='$ac_pwd'
srcdir='$srcdir'
INSTALL='$INSTALL'
test -n "\$AWK" || AWK=awk
_ACEOF

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# The default lists apply if the user does not specify any file.
ac_need_defaults=:
while test $# != 0
do
  case $1 in
  --*=?*)
    ac_option=`expr "X$1" : 'X\([^=]*\)='`
    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
    ac_shift=:
    ;;
  --*=)
    ac_option=`expr "X$1" : 'X\([^=]*\)='`
    ac_optarg=
    ac_shift=:
    ;;
  *)
    ac_option=$1
    ac_optarg=$2
    ac_shift=shift
    ;;
  esac

  case $ac_option in
  # Handling of the options.
  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
    ac_cs_recheck=: ;;
  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
    $as_echo "$ac_cs_version"; exit ;;
  --config | --confi | --conf | --con | --co | --c )
    $as_echo "$ac_cs_config"; exit ;;
  --debug | --debu | --deb | --de | --d | -d )
    debug=: ;;
  --file | --fil | --fi | --f )
    $ac_shift
    case $ac_optarg in
    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
    '') as_fn_error $? "missing file argument" ;;
    esac
    as_fn_append CONFIG_FILES " '$ac_optarg'"
    ac_need_defaults=false;;
  --header | --heade | --head | --hea )
    $ac_shift
    case $ac_optarg in
    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
    esac
    as_fn_append CONFIG_HEADERS " '$ac_optarg'"
    ac_need_defaults=false;;
  --he | --h)
    # Conflict between --help and --header
    as_fn_error $? "ambiguous option: \`$1'
Try \`$0 --help' for more information.";;
  --help | --hel | -h )
    $as_echo "$ac_cs_usage"; exit ;;
  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
  | -silent | --silent | --silen | --sile | --sil | --si | --s)
    ac_cs_silent=: ;;

  # This is an error.
  -*) as_fn_error $? "unrecognized option: \`$1'
Try \`$0 --help' for more information." ;;

  *) as_fn_append ac_config_targets " $1"
     ac_need_defaults=false ;;

  esac
  shift
done

ac_configure_extra_args=

if $ac_cs_silent; then
  exec 6>/dev/null
  ac_configure_extra_args="$ac_configure_extra_args --silent"
fi

_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
if \$ac_cs_recheck; then
  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
  shift
  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
  CONFIG_SHELL='$SHELL'
  export CONFIG_SHELL
  exec "\$@"
fi

_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
exec 5>>config.log
{
  echo
  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## Running $as_me. ##
_ASBOX
  $as_echo "$ac_log"
} >&5

_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
_ACEOF

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1

# Handling of arguments.
for ac_config_target in $ac_config_targets
do
  case $ac_config_target in
    "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
    "pwol.1") CONFIG_FILES="$CONFIG_FILES pwol.1" ;;
    "pwol.conf.5") CONFIG_FILES="$CONFIG_FILES pwol.conf.5" ;;
    "pkgs/Makefile.port") CONFIG_FILES="$CONFIG_FILES pkgs/Makefile.port" ;;

  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
  esac
done


# If the user did not use the arguments to specify the items to instantiate,
# then the envvar interface is used.  Set only those that are not.
# We use the long form for the default assignment because of an extremely
# bizarre bug on SunOS 4.1.3.
if $ac_need_defaults; then
  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
fi

# Have a temporary directory for convenience.  Make it in the build tree
# simply because there is no reason against having it here, and in addition,
# creating and moving files from /tmp can sometimes cause problems.
# Hook for its removal unless debugging.
# Note that there is a small window in which the directory will not be cleaned:
# after its creation but before its name has been assigned to `$tmp'.
$debug ||
{
  tmp= ac_tmp=
  trap 'exit_status=$?
  : "${ac_tmp:=$tmp}"
  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
' 0
  trap 'as_fn_exit 1' 1 2 13 15
}
# Create a (secure) tmp directory for tmp files.

{
  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
  test -d "$tmp"
}  ||
{
  tmp=./conf$$-$RANDOM
  (umask 077 && mkdir "$tmp")
} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
ac_tmp=$tmp

# Set up the scripts for CONFIG_FILES section.
# No need to generate them if there are no CONFIG_FILES.
# This happens for instance with `./config.status config.h'.
if test -n "$CONFIG_FILES"; then


ac_cr=`echo X | tr X '\015'`
# On cygwin, bash can eat \r inside `` if the user requested igncr.
# But we know of no other shell where ac_cr would be empty at this
# point, so we can use a bashism as a fallback.
if test "x$ac_cr" = x; then
  eval ac_cr=\$\'\\r\'
fi
ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
  ac_cs_awk_cr='\\r'
else
  ac_cs_awk_cr=$ac_cr
fi

echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
_ACEOF


{
  echo "cat >conf$$subs.awk <<_ACEOF" &&
  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
  echo "_ACEOF"
} >conf$$subs.sh ||
  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
ac_delim='%!_!# '
for ac_last_try in false false false false false :; do
  . ./conf$$subs.sh ||
    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5

  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
  if test $ac_delim_n = $ac_delim_num; then
    break
  elif $ac_last_try; then
    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
  else
    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
  fi
done
rm -f conf$$subs.sh

cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
_ACEOF
sed -n '
h
s/^/S["/; s/!.*/"]=/
p
g
s/^[^!]*!//
:repl
t repl
s/'"$ac_delim"'$//
t delim
:nl
h
s/\(.\{148\}\)..*/\1/
t more1
s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
p
n
b repl
:more1
s/["\\]/\\&/g; s/^/"/; s/$/"\\/
p
g
s/.\{148\}//
t nl
:delim
h
s/\(.\{148\}\)..*/\1/
t more2
s/["\\]/\\&/g; s/^/"/; s/$/"/
p
b
:more2
s/["\\]/\\&/g; s/^/"/; s/$/"\\/
p
g
s/.\{148\}//
t delim
' <conf$$subs.awk | sed '
/^[^""]/{
  N
  s/\n//
}
' >>$CONFIG_STATUS || ac_write_fail=1
rm -f conf$$subs.awk
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
_ACAWK
cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
  for (key in S) S_is_set[key] = 1
  FS = ""

}
{
  line = $ 0
  nfields = split(line, field, "@")
  substed = 0
  len = length(field[1])
  for (i = 2; i < nfields; i++) {
    key = field[i]
    keylen = length(key)
    if (S_is_set[key]) {
      value = S[key]
      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
      len += length(value) + length(field[++i])
      substed = 1
    } else
      len += 1 + keylen
  }

  print line
}

_ACAWK
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
else
  cat
fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
_ACEOF

# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
# trailing colons and then remove the whole line if VPATH becomes empty
# (actually we leave an empty line to preserve line numbers).
if test "x$srcdir" = x.; then
  ac_vpsub='/^[	 ]*VPATH[	 ]*=[	 ]*/{
h
s///
s/^/:/
s/[	 ]*$/:/
s/:\$(srcdir):/:/g
s/:\${srcdir}:/:/g
s/:@srcdir@:/:/g
s/^:*//
s/:*$//
x
s/\(=[	 ]*\).*/\1/
G
s/\n//
s/^[^=]*=[	 ]*$//
}'
fi

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
fi # test -n "$CONFIG_FILES"

# Set up the scripts for CONFIG_HEADERS section.
# No need to generate them if there are no CONFIG_HEADERS.
# This happens for instance with `./config.status Makefile'.
if test -n "$CONFIG_HEADERS"; then
cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
BEGIN {
_ACEOF

# Transform confdefs.h into an awk script `defines.awk', embedded as
# here-document in config.status, that substitutes the proper values into
# config.h.in to produce config.h.

# Create a delimiter string that does not exist in confdefs.h, to ease
# handling of long lines.
ac_delim='%!_!# '
for ac_last_try in false false :; do
  ac_tt=`sed -n "/$ac_delim/p" confdefs.h`
  if test -z "$ac_tt"; then
    break
  elif $ac_last_try; then
    as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5
  else
    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
  fi
done

# For the awk script, D is an array of macro values keyed by name,
# likewise P contains macro parameters if any.  Preserve backslash
# newline sequences.

ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
sed -n '
s/.\{148\}/&'"$ac_delim"'/g
t rset
:rset
s/^[	 ]*#[	 ]*define[	 ][	 ]*/ /
t def
d
:def
s/\\$//
t bsnl
s/["\\]/\\&/g
s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
D["\1"]=" \3"/p
s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2"/p
d
:bsnl
s/["\\]/\\&/g
s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
D["\1"]=" \3\\\\\\n"\\/p
t cont
s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p
t cont
d
:cont
n
s/.\{148\}/&'"$ac_delim"'/g
t clear
:clear
s/\\$//
t bsnlc
s/["\\]/\\&/g; s/^/"/; s/$/"/p
d
:bsnlc
s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p
b cont
' <confdefs.h | sed '
s/'"$ac_delim"'/"\\\
"/g' >>$CONFIG_STATUS || ac_write_fail=1

cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
  for (key in D) D_is_set[key] = 1
  FS = ""
}
/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ {
  line = \$ 0
  split(line, arg, " ")
  if (arg[1] == "#") {
    defundef = arg[2]
    mac1 = arg[3]
  } else {
    defundef = substr(arg[1], 2)
    mac1 = arg[2]
  }
  split(mac1, mac2, "(") #)
  macro = mac2[1]
  prefix = substr(line, 1, index(line, defundef) - 1)
  if (D_is_set[macro]) {
    # Preserve the white space surrounding the "#".
    print prefix "define", macro P[macro] D[macro]
    next
  } else {
    # Replace #undef with comments.  This is necessary, for example,
    # in the case of _POSIX_SOURCE, which is predefined and required
    # on some systems where configure will not decide to define it.
    if (defundef == "undef") {
      print "/*", prefix defundef, macro, "*/"
      next
    }
  }
}
{ print }
_ACAWK
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
  as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
fi # test -n "$CONFIG_HEADERS"


eval set X "  :F $CONFIG_FILES  :H $CONFIG_HEADERS    "
shift
for ac_tag
do
  case $ac_tag in
  :[FHLC]) ac_mode=$ac_tag; continue;;
  esac
  case $ac_mode$ac_tag in
  :[FHL]*:*);;
  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
  :[FH]-) ac_tag=-:-;;
  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
  esac
  ac_save_IFS=$IFS
  IFS=:
  set x $ac_tag
  IFS=$ac_save_IFS
  shift
  ac_file=$1
  shift

  case $ac_mode in
  :L) ac_source=$1;;
  :[FH])
    ac_file_inputs=
    for ac_f
    do
      case $ac_f in
      -) ac_f="$ac_tmp/stdin";;
      *) # Look for the file first in the build tree, then in the source tree
	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
	 # because $ac_f cannot contain `:'.
	 test -f "$ac_f" ||
	   case $ac_f in
	   [\\/$]*) false;;
	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
	   esac ||
	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
      esac
      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
      as_fn_append ac_file_inputs " '$ac_f'"
    done

    # Let's still pretend it is `configure' which instantiates (i.e., don't
    # use $as_me), people would be surprised to read:
    #    /* config.h.  Generated by config.status.  */
    configure_input='Generated from '`
	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
	`' by configure.'
    if test x"$ac_file" != x-; then
      configure_input="$ac_file.  $configure_input"
      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
$as_echo "$as_me: creating $ac_file" >&6;}
    fi
    # Neutralize special characters interpreted by sed in replacement strings.
    case $configure_input in #(
    *\&* | *\|* | *\\* )
       ac_sed_conf_input=`$as_echo "$configure_input" |
       sed 's/[\\\\&|]/\\\\&/g'`;; #(
    *) ac_sed_conf_input=$configure_input;;
    esac

    case $ac_tag in
    *:-:* | *:-) cat >"$ac_tmp/stdin" \
      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
    esac
    ;;
  esac

  ac_dir=`$as_dirname -- "$ac_file" ||
$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$ac_file" : 'X\(//\)[^/]' \| \
	 X"$ac_file" : 'X\(//\)$' \| \
	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$ac_file" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
  as_dir="$ac_dir"; as_fn_mkdir_p
  ac_builddir=.

case "$ac_dir" in
.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
*)
  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
  # A ".." for each directory in $ac_dir_suffix.
  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
  case $ac_top_builddir_sub in
  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
  esac ;;
esac
ac_abs_top_builddir=$ac_pwd
ac_abs_builddir=$ac_pwd$ac_dir_suffix
# for backward compatibility:
ac_top_builddir=$ac_top_build_prefix

case $srcdir in
  .)  # We are building in place.
    ac_srcdir=.
    ac_top_srcdir=$ac_top_builddir_sub
    ac_abs_top_srcdir=$ac_pwd ;;
  [\\/]* | ?:[\\/]* )  # Absolute name.
    ac_srcdir=$srcdir$ac_dir_suffix;
    ac_top_srcdir=$srcdir
    ac_abs_top_srcdir=$srcdir ;;
  *) # Relative name.
    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
    ac_top_srcdir=$ac_top_build_prefix$srcdir
    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
esac
ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix


  case $ac_mode in
  :F)
  #
  # CONFIG_FILE
  #

  case $INSTALL in
  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
  esac
_ACEOF

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# If the template does not know about datarootdir, expand it.
# FIXME: This hack should be removed a few years after 2.60.
ac_datarootdir_hack=; ac_datarootdir_seen=
ac_sed_dataroot='
/datarootdir/ {
  p
  q
}
/@datadir@/p
/@docdir@/p
/@infodir@/p
/@localedir@/p
/@mandir@/p'
case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
*datarootdir*) ac_datarootdir_seen=yes;;
*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
  ac_datarootdir_hack='
  s&@datadir@&$datadir&g
  s&@docdir@&$docdir&g
  s&@infodir@&$infodir&g
  s&@localedir@&$localedir&g
  s&@mandir@&$mandir&g
  s&\\\${datarootdir}&$datarootdir&g' ;;
esac
_ACEOF

# Neutralize VPATH when `$srcdir' = `.'.
# Shell code in configure.ac might set extrasub.
# FIXME: do we really want to maintain this feature?
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_sed_extra="$ac_vpsub
$extrasub
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
:t
/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
s|@configure_input@|$ac_sed_conf_input|;t t
s&@top_builddir@&$ac_top_builddir_sub&;t t
s&@top_build_prefix@&$ac_top_build_prefix&;t t
s&@srcdir@&$ac_srcdir&;t t
s&@abs_srcdir@&$ac_abs_srcdir&;t t
s&@top_srcdir@&$ac_top_srcdir&;t t
s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
s&@builddir@&$ac_builddir&;t t
s&@abs_builddir@&$ac_abs_builddir&;t t
s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
s&@INSTALL@&$ac_INSTALL&;t t
$ac_datarootdir_hack
"
eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5

test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
      "$ac_tmp/out"`; test -z "$ac_out"; } &&
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
which seems to be undefined.  Please make sure it is defined" >&5
$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
which seems to be undefined.  Please make sure it is defined" >&2;}

  rm -f "$ac_tmp/stdin"
  case $ac_file in
  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
  esac \
  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
 ;;
  :H)
  #
  # CONFIG_HEADER
  #
  if test x"$ac_file" != x-; then
    {
      $as_echo "/* $configure_input  */" \
      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
    } >"$ac_tmp/config.h" \
      || as_fn_error $? "could not create $ac_file" "$LINENO" 5
    if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
$as_echo "$as_me: $ac_file is unchanged" >&6;}
    else
      rm -f "$ac_file"
      mv "$ac_tmp/config.h" "$ac_file" \
	|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
    fi
  else
    $as_echo "/* $configure_input  */" \
      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
      || as_fn_error $? "could not create -" "$LINENO" 5
  fi
 ;;


  esac

done # for ac_tag


as_fn_exit 0
_ACEOF
ac_clean_files=$ac_clean_files_save

test $ac_write_fail = 0 ||
  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5


# configure is writing to config.log, and then calls config.status.
# config.status does its own redirection, appending to config.log.
# Unfortunately, on DOS this fails, as config.log is still kept open
# by configure, so config.status won't be able to write to it; its
# output is simply discarded.  So we exec the FD to /dev/null,
# effectively closing config.log, so it can be properly (re)opened and
# appended to by config.status.  When coming back to configure, we
# need to make the FD available again.
if test "$no_create" != yes; then
  ac_cs_success=:
  ac_config_status_args=
  test "$silent" = yes &&
    ac_config_status_args="$ac_config_status_args --quiet"
  exec 5>/dev/null
  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
  exec 5>>config.log
  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
  # would make configure fail if this is the last instruction.
  $ac_cs_success || as_fn_exit 1
fi
if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
fi





#                                               -*- Autoconf -*-
# Process this file with autoconf to produce a configure script.

AC_PREREQ([2.69])
AC_INIT([pwol], [1.5], [pen@lysator.liu.se], [pwol], [https://github.com/ptrrkssn/pwol])

AC_CONFIG_SRCDIR([pwol.c])
AC_CONFIG_HEADERS([config.h])

AC_CONFIG_AUX_DIR([aux])

# Checks for programs.
AC_PROG_CC
AC_PROG_INSTALL
AC_PROG_MAKE_SET

# Checks for libraries.
AC_CHECK_LIB([pthread], [pthread_create])
AC_CHECK_LIB([socket], [connect])
AC_CHECK_LIB([nsl], [gethostbyname])

# Checks for header files.
AC_CHECK_HEADERS([arpa/inet.h fcntl.h netdb.h netinet/in.h stdlib.h string.h sys/socket.h syslog.h unistd.h])

# Checks for typedefs, structures, and compiler characteristics.
AC_TYPE_PID_T
AC_TYPE_SIZE_T
AC_TYPE_SSIZE_T

# Checks for library functions.
AC_FUNC_FORK
AC_FUNC_MALLOC
AC_FUNC_REALLOC
AC_CHECK_FUNCS([dup2 memset socket strchr strdup strerror])

AC_CONFIG_FILES([Makefile pwol.1 pwol.conf.5 pkgs/Makefile.port])
AC_OUTPUT




BSD 3-Clause License

Copyright (c) 2017, Peter Eriksson <pen@lysator.liu.se>
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.

* 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.

* Neither the name of the copyright holder 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 COPYRIGHT HOLDER 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.




# Makefile.in for pwol
#
# Makefile.  Generated from Makefile.in by configure.


# Some 'make' variants does not include CPPFLAGS when compiling, some do
.c.o:
	$(CC) $(CPPFLAGS) $(CFLAGS) -c -o $@ $<



srcdir =	.


DESTDIR =

prefix =	/usr/local
exec_prefix =	${prefix}
datarootdir =	${prefix}/share
sysconfdir =    ${prefix}/etc

bindir =	${exec_prefix}/bin
mandir =	/usr/local/man
man1dir =	${mandir}/man1
man5dir =	${mandir}/man5
man8dir =	${mandir}/man8

CC =		cc
INSTALL =	/usr/bin/install -c
TAR = 		tar

PACKAGE =	pwol
VERSION =	1.5

CPPFLAGS =	 -I. -I${srcdir} -DPATH_CONFIG="\"$(sysconfdir)/pwol.conf\""
CFLAGS =	-O2 -pipe  -fstack-protector-strong -fno-strict-aliasing  -Wall
LDFLAGS =	 -fstack-protector-strong 
LIBS =		-lpthread 

VALGRIND =	valgrind
VALGRINDFLAGS =	--leak-check=full --track-origins=yes --error-exitcode=1 # --show-leak-kinds=all 

BINS =		pwol
OBJS =		pwol.o

all: $(BINS) Makefile

Makefile: Makefile.in config.status
	./config.status

config.h: config.h.in config.status
	./config.status

pwol.o: 	pwol.c

pwol: $(OBJS)
	$(CC) $(LDFLAGS) -o pwol $(OBJS) $(LIBS)

# Clean targets
maintainer-clean:	distclean
	rm -f configure config.h.in

distclean:		clean
	rm -fr config.status config.log stamp-h1 .deps autom4te.cache Makefile config.h *.tar.gz

clean mostlyclean:
	-rm -f *~ \#* *.o $(BINS) core *.core vgcore.*


# Git targets
push: 	distclean
	git add -A && git commit -a && git push

pull:
	git pull


# Install targets
install-all install:  install-bin install-man install-conf

install-bin: $(BINS)
	$(INSTALL) -d $(DESTDIR)$(bindir)
	$(INSTALL) -c $(BINS) $(DESTDIR)$(bindir)

install-man:  pwol.1 pwol.conf.5
	$(INSTALL) -d "$(DESTDIR)$(man1dir)"
	$(INSTALL) -c -m 644 pwol.1 "$(DESTDIR)$(man1dir)" && \
	  gzip -f "$(DESTDIR)$(man1dir)/pwol.1"
	$(INSTALL) -d "$(DESTDIR)$(man5dir)"
	$(INSTALL) -c -m 644 pwol.conf.5 "$(DESTDIR)$(man5dir)" && \
	  gzip -f "$(DESTDIR)$(man5dir)/pwol.conf.5"

install-conf: pwol.conf
	$(INSTALL) -c -m 644 pwol.conf "$(DESTDIR)$(sysconfdir)/pwol.conf.sample"


uninstall-all uninstall: uninstall-bin uninstall-man

uninstall-bin:
	rm -f "$(DESTDIR)$(bindir)/pwol"

uninstall-man:
	rm -f "$(DESTDIR)$(man1dir)/pwol.1.gz" "$(DESTDIR)$(man1dir)/pwol.1"
	rm -f "$(DESTDIR)$(man5dir)/pwol.conf.5.gz" "$(DESTDIR)$(man5dir)/pwol.conf.5"
	rm -f "$(DESTDIR)$(sysconfdir)/pwol.conf.sample"


# Check targets
check:
	@echo "Nothing to check for now."


DISTCHECKDIR=/tmp/distcheck-$(PACKAGE)-$(VERSION)

distcheck: $(PACKAGE)-$(VERSION).tar.gz
	@if test -d "$(DISTCHECKDIR)"; then \
	  chmod -R +w "$(DISTCHECKDIR)" && rm -fr "$(DISTCHECKDIR)"; \
	fi;
	mkdir -p "$(DISTCHECKDIR)" && \
	  gunzip <"$(PACKAGE)-$(VERSION).tar.gz" | \
	    (cd "$(DISTCHECKDIR)" && $(TAR) xf - && \
	     chmod -R -w "$(PACKAGE)-$(VERSION)" && \
	     mkdir b && cd b && ../$(PACKAGE)-$(VERSION)/configure && \
	     $(MAKE) && $(MAKE) -s check) && echo "*** distcheck: OK"
	@chmod -R +w "$(DISTCHECKDIR)" && rm -fr "$(DISTCHECKDIR)";


DISTDIR=/tmp/build-$(PACKAGE)-$(VERSION)

dist:	$(PACKAGE)-$(VERSION).tar.gz

$(PACKAGE)-$(VERSION).tar.gz: Makefile
	rm -fr "$(DISTDIR)" && mkdir -p "$(DISTDIR)/$(PACKAGE)-$(VERSION)" && \
	  cp -r * "$(DISTDIR)/$(PACKAGE)-$(VERSION)" && \
	  (cd "$(DISTDIR)/$(PACKAGE)-$(VERSION)" && $(MAKE) distclean)
	(cd "$(DISTDIR)" && $(TAR) cvf - "$(PACKAGE)-$(VERSION)") | gzip >"$(PACKAGE)-$(VERSION)".tar.gz
	echo rm -fr "$(DISTDIR)"
	@echo ""
	@echo "*** $(PACKAGE)-$(VERSION).tar.gz created"





# Makefile.in for pwol
#
# @configure_input@


# Some 'make' variants does not include CPPFLAGS when compiling, some do
.c.o:
	$(CC) $(CPPFLAGS) $(CFLAGS) -c -o $@ $<

@SET_MAKE@

srcdir =	@srcdir@
VPATH =		@srcdir@

DESTDIR =

prefix =	@prefix@
exec_prefix =	@exec_prefix@
datarootdir =	@datarootdir@
sysconfdir =    @sysconfdir@

bindir =	@bindir@
mandir =	@mandir@
man1dir =	${mandir}/man1
man5dir =	${mandir}/man5
man8dir =	${mandir}/man8

CC =		@CC@
INSTALL =	@INSTALL@
TAR = 		tar

PACKAGE =	@PACKAGE_TARNAME@
VERSION =	@PACKAGE_VERSION@

CPPFLAGS =	@CPPFLAGS@ -I. -I${srcdir} -DPATH_CONFIG="\"$(sysconfdir)/pwol.conf\""
CFLAGS =	@CFLAGS@ -Wall
LDFLAGS =	@LDFLAGS@
LIBS =		@LIBS@

VALGRIND =	valgrind
VALGRINDFLAGS =	--leak-check=full --track-origins=yes --error-exitcode=1 # --show-leak-kinds=all 

BINS =		pwol
OBJS =		pwol.o

all: $(BINS) Makefile

Makefile: Makefile.in config.status
	./config.status

config.h: config.h.in config.status
	./config.status

pwol.o: 	pwol.c

pwol: $(OBJS)
	$(CC) $(LDFLAGS) -o pwol $(OBJS) $(LIBS)

# Clean targets
maintainer-clean:	distclean
	rm -f configure config.h.in

distclean:		clean
	rm -fr config.status config.log stamp-h1 .deps autom4te.cache Makefile config.h *.tar.gz

clean mostlyclean:
	-rm -f *~ \#* *.o $(BINS) core *.core vgcore.*


# Git targets
push: 	distclean
	git add -A && git commit -a && git push

pull:
	git pull


# Install targets
install-all install:  install-bin install-man install-conf

install-bin: $(BINS)
	$(INSTALL) -d $(DESTDIR)$(bindir)
	$(INSTALL) -c $(BINS) $(DESTDIR)$(bindir)

install-man:  pwol.1 pwol.conf.5
	$(INSTALL) -d "$(DESTDIR)$(man1dir)"
	$(INSTALL) -c -m 644 pwol.1 "$(DESTDIR)$(man1dir)" && \
	  gzip -f "$(DESTDIR)$(man1dir)/pwol.1"
	$(INSTALL) -d "$(DESTDIR)$(man5dir)"
	$(INSTALL) -c -m 644 pwol.conf.5 "$(DESTDIR)$(man5dir)" && \
	  gzip -f "$(DESTDIR)$(man5dir)/pwol.conf.5"

install-conf: pwol.conf
	$(INSTALL) -c -m 644 pwol.conf "$(DESTDIR)$(sysconfdir)/pwol.conf.sample"


uninstall-all uninstall: uninstall-bin uninstall-man

uninstall-bin:
	rm -f "$(DESTDIR)$(bindir)/pwol"

uninstall-man:
	rm -f "$(DESTDIR)$(man1dir)/pwol.1.gz" "$(DESTDIR)$(man1dir)/pwol.1"
	rm -f "$(DESTDIR)$(man5dir)/pwol.conf.5.gz" "$(DESTDIR)$(man5dir)/pwol.conf.5"
	rm -f "$(DESTDIR)$(sysconfdir)/pwol.conf.sample"


# Check targets
check:
	@echo "Nothing to check for now."


DISTCHECKDIR=/tmp/distcheck-$(PACKAGE)-$(VERSION)

distcheck: $(PACKAGE)-$(VERSION).tar.gz
	@if test -d "$(DISTCHECKDIR)"; then \
	  chmod -R +w "$(DISTCHECKDIR)" && rm -fr "$(DISTCHECKDIR)"; \
	fi;
	mkdir -p "$(DISTCHECKDIR)" && \
	  gunzip <"$(PACKAGE)-$(VERSION).tar.gz" | \
	    (cd "$(DISTCHECKDIR)" && $(TAR) xf - && \
	     chmod -R -w "$(PACKAGE)-$(VERSION)" && \
	     mkdir b && cd b && ../$(PACKAGE)-$(VERSION)/configure && \
	     $(MAKE) && $(MAKE) -s check) && echo "*** distcheck: OK"
	@chmod -R +w "$(DISTCHECKDIR)" && rm -fr "$(DISTCHECKDIR)";


DISTDIR=/tmp/build-$(PACKAGE)-$(VERSION)

dist:	$(PACKAGE)-$(VERSION).tar.gz

$(PACKAGE)-$(VERSION).tar.gz: Makefile
	rm -fr "$(DISTDIR)" && mkdir -p "$(DISTDIR)/$(PACKAGE)-$(VERSION)" && \
	  cp -r * "$(DISTDIR)/$(PACKAGE)-$(VERSION)" && \
	  (cd "$(DISTDIR)/$(PACKAGE)-$(VERSION)" && $(MAKE) distclean)
	(cd "$(DISTDIR)" && $(TAR) cvf - "$(PACKAGE)-$(VERSION)") | gzip >"$(PACKAGE)-$(VERSION)".tar.gz
	echo rm -fr "$(DISTDIR)"
	@echo ""
	@echo "*** $(PACKAGE)-$(VERSION).tar.gz created"





# Makefile for pwol

DEST=
CC=gcc -Wall
CFLAGS=-g -DVERSION="\"$(VERSION)\""

PACKAGE=pwol
VERSION=1.4.2

ETCDIR=$(DEST)/etc
BINDIR=$(DEST)/bin
MANDIR=$(DEST)/share/man

BINOBJS=pwol.o

LIBS=

# Needed for Solaris:
#LIBS=-lnsl -lsocket -lrt


all: pwol

pwol: $(BINOBJS)
	$(CC) -g -o pwol $(BINOBJS) $(LIBS)

clean:
	-rm -f *~ core *.core *.o \#* pwol

distclean: clean
	-rm -f pwol

install: pwol
	$(INSTALL) -o root -g wheel -m 0444 pwol $(BINDIR)
	$(INSTALL) -o root -g wheel -m 0444 pwol.1 $(MANDIR)/man1

pull:	distclean
	git pull

push:	distclean
	git add -A && git commit -a && git push

dist:	distclean
	(mkdir -p ../dist && cd ../dist && ln -sf ../$(PACKAGE) $(PACKAGE)-$(VERSION) && tar zcf $(PACKAGE)-$(VERSION).tar.gz $(PACKAGE)-$(VERSION)/* && rm $(PACKAGE)-$(VERSION))





# Makefile for pkgs

PORTSDIR=/usr/ports
PORTSNAME=sysutils/pwol

all:
	@echo "Use 'make port'"
	@exit 1

port:	Makefile.port pkg-descr
	mkdir -p "$(PORTSDIR)/$(PORTSNAME)"
	cp Makefile.port "$(PORTSDIR)/$(PORTSNAME)/Makefile"
	cp pkg-descr "$(PORTSDIR)/$(PORTSNAME)"
	(cd "$(PORTSDIR)/$(PORTSNAME)" && make distclean && make makesum && portlint -AC)


# Clean targets
maintainer-clean:	distclean

distclean:		clean
	rm -fr Makefile.port

clean mostlyclean:
	-rm -f *~ \#*




# $FreeBSD$

PORTNAME=		pwol
DISTVERSIONPREFIX=	v
DISTVERSION=		1.5
CATEGORIES=		sysutils

MAINTAINER=		pen@lysator.liu.se
COMMENT=		Peter's Wake-on-LAN Tool

LICENSE=		BSD3CLAUSE
LICENSE_FILE=		${WRKSRC}/LICENSE

USE_GITHUB=		yes
GH_ACCOUNT=		ptrrkssn

GNU_CONFIGURE=		yes

PLIST_FILES=		bin/pwol \
			man/man1/pwol.1.gz \
			man/man5/pwol.conf.5.gz \
			etc/pwol.conf.sample

.include <bsd.port.mk>




# $FreeBSD$

PORTNAME=		@PACKAGE_TARNAME@
DISTVERSIONPREFIX=	v
DISTVERSION=		@PACKAGE_VERSION@
CATEGORIES=		sysutils

MAINTAINER=		@PACKAGE_BUGREPORT@
COMMENT=		Peter's Wake-on-LAN Tool

LICENSE=		BSD3CLAUSE
LICENSE_FILE=		${WRKSRC}/LICENSE

USE_GITHUB=		yes
GH_ACCOUNT=		ptrrkssn

GNU_CONFIGURE=		yes

PLIST_FILES=		bin/pwol \
			man/man1/pwol.1.gz \
			man/man5/pwol.conf.5.gz \
			etc/pwol.conf.sample

.include <bsd.port.mk>

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/pkgs/pkg-descr (+9 lines)
	1	This is a port of pwol, Peter's Wake-on-Lan tool
	2
	3	This is a simple tool to send WoL packets to wake up
	4	hosts. No more, no less.
	5
	6	WWW: https://github.com/ptrrkssn/pwol
	7
	8	- Peter Eriksson
	9	pen@lysator.liu.se




.TH "PWOL" "1" "14 Jun 2020" "1.5" "pwol man page"

.SH "NAME"
pwol \- Send Wake-On-LAN (WoL) packets to wake-up hosts over the network

.SH "SYNOPSIS"
.B pwol
.RI "[" "options" "]"
.RI "[" "<hosts|groups>" "]"

.SH "DESCRIPTION"
.B pwol
is a tool that can be used to send WoL (Wake-On-LAN) network packets
in order to wake-up sleeping hosts, either directly or via routers.
.PP
It can also be used as a WoL proxy daemon listening to incoming WoL
packets (possibly authenticated) and then forwarding requests to one
or many other targets.
.PP
If no hosts or groups are specified on the command line then
.B pwol
will read them from the command line.

.SH "OPTIONS"
.TP
.B \-h
Show summary of options.
.TP
.B \-V
Print build version.
.TP
.B \-v
Increase verbosity level.
.TP
.B \-i
Ignore errors.
.TP
.B \-d
Increase internal debugging level.
.TP
.B \-n
No-send mode (dry run).
.TP
.B \-e
Export configuration.
.TP
.BI \-f " path"
Load additional configuration files.
.PP
.TP
.BI \-g " name"
Force (override) gateway.
.TP
.BI \-a " address"
Force (override) destination address (DNS name).
.TP
.BI \-p " service"
Force (override) gateway port (service name).
.TP
.BI \-t " delay"
Force (override) inter-packet delay.
.TP
.BI \-T " delay"
Force (override) inter-host delay.
.TP
.BI \-c " count"
Force (override) packet copies for hosts/groups.
.TP
.BI \-s " secret"
Force (override) WoL secret.
.PP
.TP
.B \-D
Enable proxy daemon mode
.TP
.B \-F
Run proxy in the foreground
.TP
.BI \-A " address"
Force (override) proxy address (DNS name).
.TP
.BI \-P " service"
Force (override) proxy port.
.TP
.BI \-S " secret"
Force (override) proxy secret.

.SH "SEE ALSO"
.BR pwol.conf (5),
.BR ping (8),
.B "https://github.com/ptrrkssn/pwol"

.SH "AUTHOR"
pwol was written by Peter Eriksson <pen@lysator.liu.se>.




.TH "PWOL" "1" "14 Jun 2020" "@PACKAGE_VERSION@" "pwol man page"

.SH "NAME"
pwol \- Send Wake-On-LAN (WoL) packets to wake-up hosts over the network

.SH "SYNOPSIS"
.B pwol
.RI "[" "options" "]"
.RI "[" "<hosts|groups>" "]"

.SH "DESCRIPTION"
.B pwol
is a tool that can be used to send WoL (Wake-On-LAN) network packets
in order to wake-up sleeping hosts, either directly or via routers.
.PP
It can also be used as a WoL proxy daemon listening to incoming WoL
packets (possibly authenticated) and then forwarding requests to one
or many other targets.
.PP
If no hosts or groups are specified on the command line then
.B pwol
will read them from the command line.

.SH "OPTIONS"
.TP
.B \-h
Show summary of options.
.TP
.B \-V
Print build version.
.TP
.B \-v
Increase verbosity level.
.TP
.B \-i
Ignore errors.
.TP
.B \-d
Increase internal debugging level.
.TP
.B \-n
No-send mode (dry run).
.TP
.B \-e
Export configuration.
.TP
.BI \-f " path"
Load additional configuration files.
.PP
.TP
.BI \-g " name"
Force (override) gateway.
.TP
.BI \-a " address"
Force (override) destination address (DNS name).
.TP
.BI \-p " service"
Force (override) gateway port (service name).
.TP
.BI \-t " delay"
Force (override) inter-packet delay.
.TP
.BI \-T " delay"
Force (override) inter-host delay.
.TP
.BI \-c " count"
Force (override) packet copies for hosts/groups.
.TP
.BI \-s " secret"
Force (override) WoL secret.
.PP
.TP
.B \-D
Enable proxy daemon mode
.TP
.B \-F
Run proxy in the foreground
.TP
.BI \-A " address"
Force (override) proxy address (DNS name).
.TP
.BI \-P " service"
Force (override) proxy port.
.TP
.BI \-S " secret"
Force (override) proxy secret.

.SH "SEE ALSO"
.BR pwol.conf (5),
.BR ping (8),
.B "https://github.com/ptrrkssn/pwol"

.SH "AUTHOR"
pwol was written by Peter Eriksson <pen@lysator.liu.se>.




/*
** pwol.c - Send Wake-On-LAN packets
**
** Copyright (c) 2017-2020 Peter Eriksson <pen@lysator.liu.se>
** All rights reserved.
** 
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are met:
** 
** * Redistributions of source code must retain the above copyright notice, this
**   list of conditions and the following disclaimer.
** 
** * 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.
** 
** * Neither the name of the copyright holder 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 COPYRIGHT HOLDER 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 "config.h"

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <stdlib.h>
#include <time.h>
#include <stdarg.h>
#include <syslog.h>
#include <signal.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <poll.h>

#ifdef __linux__
#include <netinet/ether.h>
#elif __FreeBSD__
#include <net/ethernet.h>
#define ether_addr_octet octet
#else
#include <sys/ethernet.h>
#endif


#ifndef PATH_CONFIG
#define PATH_CONFIG "/etc/pwol.conf"
#endif

#define DEFAULT_GLOBAL_CONFIG   PATH_CONFIG
#define DEFAULT_USER_CONFIG     ".pwolrc"

#define DEFAULT_HOSTGROUP_HOSTS 64

#define DEFAULT_ADDRESS         "255.255.255.255"
#define DEFAULT_PORT            "7"
#define DEFAULT_COPIES          "1"
#define DEFAULT_SECRET          NULL
#define DEFAULT_DELAY           NULL

#define DEFAULT_PROXY_ADDRESS   "0.0.0.0"
#define DEFAULT_PROXY_PORT      "10007"

#define HEADER_SIZE             6
#define MAC_SIZE                6
#define MAC_COPIES              16
#define WOL_BODY_SIZE           (HEADER_SIZE+MAC_COPIES*MAC_SIZE)

#define SECRET_MAX_SIZE         64


#ifndef PACKAGE_VERSION
#define PACKAGE_VERSION __DATE__ __TIME__
#endif

char *argv0 = "pwol";
char *version = PACKAGE_VERSION;





typedef struct secret {
  unsigned char buf[SECRET_MAX_SIZE];
  size_t size;
} SECRET;



typedef struct target {
  struct addrinfo *aip;
  int fd;

  struct target *next;
} TARGET;


typedef struct gateway {
  char *name;

  char *address;
  char *port;
  TARGET *targets;

  unsigned int copies;
  struct timespec delay;
  SECRET secret;

  int fd;

  struct gateway *next;
} GATEWAY;

GATEWAY *gateways = NULL;
GATEWAY *default_gw = NULL;


typedef struct host {
  char *name;

  struct ether_addr mac;
  GATEWAY *via;
  
  unsigned int copies;
  struct timespec delay;
  SECRET secret;
  
  struct host *next;
} HOST;

HOST *hosts = NULL;


typedef struct hostgroup {
  char *name;

  struct timespec delay;

  HOST **hv;
  size_t hs;
  size_t hc;
  
  struct hostgroup *next;
} HOSTGROUP;

HOSTGROUP *hostgroups = NULL;
HOSTGROUP *all_group = NULL;

int f_verbose = 0;
int f_ignore = 0;
int f_debug = 0;
int f_no = 0;
int f_export = 0;
int f_daemon = 0;
int f_foreground = 0;


char *f_copies  = NULL;
char *f_delay   = NULL;
char *f_secret  = NULL;

char *f_address = NULL;
char *f_port    = NULL;
char *f_gateway = NULL;

char *f_host_delay    = NULL;

char *f_proxy_address = NULL;
char *f_proxy_port    = NULL;
char *f_proxy_secret  = NULL;

char *
strdupcat(const char *str,
	  ...) {
  va_list ap;
  char *res, *cp;
  int len;


  if (!str)
    return NULL;

  len = strlen(str);
  
  va_start(ap, str);
  while ((cp = va_arg(ap, char *)) != NULL)
    len += strlen(cp);
  va_end(ap);
  
  res = malloc(len+1);
  if (!res)
    return NULL;

  strcpy(res, str);
  
  va_start(ap, str);
  while ((cp = va_arg(ap, char *)) != NULL)
    strcat(res, cp);
  va_end(ap);

  return res;
}


TARGET *
target_add(TARGET **targets, 
	   struct addrinfo *aip) {
  TARGET *tp = malloc(sizeof(*tp));
  
  if (!tp)
    return NULL;

  tp->aip = aip;
  tp->fd = -1;

  tp->next = *targets;
  *targets = tp;

  return tp;
}

void
target_free(TARGET *tp) {
  if (!tp)
    return;

  if (tp->next) {
    target_free(tp->next);
    tp->next = NULL;
  }

  if (tp->aip) {
    freeaddrinfo(tp->aip);
    tp->aip = NULL;
  }

  free(tp);
}


char *
sockaddr2str(struct sockaddr *sp,
	     size_t len) {
  char addr[2048];
  char port[256];


  if (!sp)
    return NULL;

  if (getnameinfo(sp, len, addr, sizeof(addr), port, sizeof(port), NI_DGRAM|NI_NUMERICHOST|NI_NUMERICSERV) != 0)
    return NULL;

  if (sp->sa_family == AF_INET6)
    return strdupcat("[", addr, "]:", port, NULL);

  return strdupcat(addr, ":", port, NULL);
}


char *
addrinfo2str(struct addrinfo *aip) {
  char addr[2048];
  char port[256];


  if (!aip)
    return NULL;

  if (getnameinfo(aip->ai_addr, aip->ai_addrlen, addr, sizeof(addr), port, sizeof(port), NI_DGRAM|NI_NUMERICHOST|NI_NUMERICSERV) != 0)
    return NULL;

  if (aip->ai_family == AF_INET6)
    return strdupcat("[", addr, "]:", port, NULL);

  return strdupcat(addr, ":", port, NULL);
}


char *
target2str(TARGET *tp) {
  return addrinfo2str(tp->aip);
}


int
str2secret(const char *secret,
	   SECRET *sp) {
  unsigned int v1, v2, v3, v4, val, i;
  char *ptr, *cp, *tbuf;


  if (sscanf(secret, "%u.%u.%u.%u", &v1, &v2, &v3, &v4) == 4) {
    /* IPv4 address */
    sp->buf[0] = v1;
    sp->buf[1] = v2;
    sp->buf[2] = v3;
    sp->buf[3] = v4;
    sp->size  = 4;
    return sp->size;
  }


  /* List of hexadecimal bytes separated by : or - */
  ptr = strdup(secret);
  if (!ptr)
    return -1;

  tbuf = ptr;
  for (i = 0; i < SECRET_MAX_SIZE && (cp = strtok_r(tbuf, ":-", &ptr)) != NULL; i++) {
    tbuf = NULL;
    
    if (strlen(cp) > 2 || sscanf(cp, "%x", &val) != 1) {
      i = 0;
      break;
    }
    sp->buf[i] = val;
  }

  if (i > 1) {
    sp->size = i;
    return sp->size;
  }

  i = strlen(secret);
  if (i > SECRET_MAX_SIZE) {
    errno = EINVAL;
    return -1;
  }

  if (i > 0)
    memcpy(sp->buf, secret, i);

  sp->size = i;
  return sp->size;
}


int
secret_compare(SECRET *s1, 
	       SECRET *s2) {
  int rc;


  if (!s1 && s2)
    return 1;
  if (s1 && !s2)
    return -1;

  rc = s1->size - s2->size;
  if (rc)
    return rc;

  return memcmp(&s1->buf, &s2->buf, s1->size);
}

char *
secret2str(SECRET *sp) {
  char *buf;
  int i;


  if (!sp || sp->size == 0)
    return NULL;

  /* IPv4 */
  if (sp->size == 4) {
    buf = malloc(16);
    if (!buf)
      return NULL;
    snprintf(buf, 16, "%u.%u.%u.%u", sp->buf[0], sp->buf[1], sp->buf[2], sp->buf[3]);
    goto End;
  }
  
  buf = malloc(sp->size*3);
  if (!buf)
    return NULL;
  for (i = 0; i < sp->size; i++) {
    snprintf(buf+i*3, 3, "%02x", sp->buf[i]);
    if (i+1 < sp->size) {
      buf[i*3+2] = ':';
    }
  }

 End:
  for (i = 0; i < sp->size && isprint(sp->buf[i]); i++)
    ;
  
  if (i >= sp->size) {
    buf = realloc(buf, sp->size*3+3+sp->size);
    if (!buf)
      return NULL;

    memcpy(buf+sp->size*3-1, " (", 2);
    memcpy(buf+sp->size*3-1+2, sp->buf, sp->size);
    strcpy(buf+sp->size*3-1+2+sp->size, ")");
  }
    
  return buf;
}

char *
timespec2str(struct timespec *tsp) {
  char buf[2048];
  unsigned int h, m, s, ms, us, ns;
  float fs, fms, fus;


  h = tsp->tv_sec / 3600;
  m = (tsp->tv_sec - h*3600) / 60;
  s = tsp->tv_sec - h*3600 - m*60;

  ms = tsp->tv_nsec / 1000000;
  us = (tsp->tv_nsec - ms * 1000000) / 1000;
  ns = tsp->tv_nsec - ms * 1000000 - us * 1000;

  fs  = (float) s +  (float) ms / 1000.0;
  fms = (float) ms + (float) us / 1000.0;
  fus = (float) us + (float) ns / 1000.0;

  if (h)
    sprintf(buf, "%02u:%02u:%02u", h, m, s);
  else if (m)
    sprintf(buf, "%um+%gs", m, fs);
  else if (s)
    sprintf(buf, "%gs", fs);
  else if (ms)
    sprintf(buf, "%gms", fms);
  else if (us)
    sprintf(buf, "%gµs", fus);
  else
    sprintf(buf, "%uns", ns);

  return strdup(buf);
}

int
str2timespec(const char *time,
	     struct timespec *tsp) {
  float ft;
  char buf[3];


  memset(buf, 0, 3);
  if (sscanf(time, "%f%c%c", &ft, buf+0, buf+1) < 1)
    return -1;
  
  if (strcmp(buf, "s") == 0 || !*buf) {
    tsp->tv_sec  = ft;
    tsp->tv_nsec = (ft-tsp->tv_sec)*1000000000.0;
  } else if (strcmp(buf, "m") == 0) {
    tsp->tv_sec  = ft*60;
    tsp->tv_nsec = (ft-tsp->tv_sec*60)/6.0*100000000.0;;
  } else if (strcmp(buf, "h") == 0) {
    tsp->tv_sec  = ft*60*60;
    tsp->tv_nsec = 0;
  } else if (strcmp(buf, "d") == 0) {
    tsp->tv_sec  = ft*60*60*24;
    tsp->tv_nsec = 0;
  } else if (strcmp(buf, "ms") == 0) {
    tsp->tv_sec  = ft/1000.0;
    tsp->tv_nsec = ft*1000000.0;
  } else if (strcmp(buf, "us") == 0 || strcmp(buf, "µs") == 0) {
    tsp->tv_sec  = ft/1000000.0;
    tsp->tv_nsec = ft*1000.0;
  } else if (strcmp(buf, "ns") == 0) {
    tsp->tv_sec  = ft/1000000000.0;
    tsp->tv_nsec = ft;
  } else 
    return -1;

  return tsp->tv_sec;
}



GATEWAY *
gw_lookup(const char *name) {
  GATEWAY *gp;

  if (!name)
    return NULL;

  for (gp = gateways; gp && (!gp->name || strcmp(gp->name, name) != 0); gp = gp->next)
    ;

  if (!gp)
    errno = ENXIO;

  return gp;
}


int
gw_add_name(GATEWAY *gp,
	    const char *name) {
  if (!name)
    return -1;
 
  if (gp->name)
    free(gp->name);

  gp->name = strdup(name);
  return 0;
}

int
gw_add_address(GATEWAY *gp,
	       const char *address) {
  if (!address)
    return -1;

  if (gp->address)
    free(gp->address);

  gp->address = strdup(address);
  return 0;
}


HOSTGROUP *
group_lookup(const char *name) {
  HOSTGROUP *hgp;


  if (!name)
    return NULL;

  for (hgp = hostgroups; hgp && strcmp(hgp->name, name) != 0; hgp = hgp->next)
    ;

  if (!hgp)
    errno = ENXIO;

  return hgp;
}

HOSTGROUP *
group_create(const char *name) {
  HOSTGROUP *hgp, **thgp;


  if (!name)
    return NULL;

  hgp = group_lookup(name);
  if (hgp)
    return hgp;

  hgp = malloc(sizeof(*hgp));
  if (!hgp)
    return NULL;

  memset(hgp, 0, sizeof(*hgp));
  hgp->name = strdup(name);

  hgp->hs = DEFAULT_HOSTGROUP_HOSTS;
  hgp->hc = 0;
  hgp->hv = malloc(hgp->hs * sizeof(HOST *));
  if (!hgp->hv)
    return NULL;

  for (thgp = &hostgroups; *thgp; thgp = &((*thgp)->next))
    ;

  *thgp = hgp;
  return hgp;
}


GATEWAY *
gw_create(const char *name) {
  GATEWAY *gp, **tgp;


  if (name) {
    gp = gw_lookup(name);
    if (gp)
      return gp;
  }

  gp = malloc(sizeof(*gp));
  if (!gp)
    return NULL;

  memset(gp, 0, sizeof(*gp));


  if (name) {
    gp->name = strdup(name);
  
    /* Try to use gateway name as address */
    (void) gw_add_address(gp, name);
    
    /* Autocreate group name */
    (void) group_create(name);
  }

  for (tgp = &gateways; *tgp; tgp = &((*tgp)->next))
    ;
  
  *tgp = gp;
  return gp;
}

int
gw_add_port(GATEWAY *gp,
	    const char *port) {
  if (!port)
    return -1;

  if (gp->port)
    free(gp->port);
  
  gp->port = strdup(port);
  return 0;
}

int
gw_add_delay(GATEWAY *gp,
	       const char *delay) {
  if (!delay)
    return -1;

  return str2timespec(delay, &gp->delay);
}

int
gw_add_copies(GATEWAY *gp,
	      const char *copies) {
  if (copies && sscanf(copies, "%u", &gp->copies) == 1)
    return 0;

  return -1;
}

int
gw_add_secret(GATEWAY *gp,
	      const char *secret) {
  if (!secret)
    return -1;
  
  return str2secret(secret, &gp->secret);
}



HOST *
host_lookup(const char *name) {
  HOST *hp;

  if (!name)
    return NULL;
  
  for (hp = hosts; hp && strcmp(hp->name, name) != 0; hp = hp->next)
    ;

  if (!hp)
    errno = ENXIO;

  return hp;
}

int
host_add_mac(HOST *hp,
	     const char *mac) {
  struct ether_addr *ep;


  if (!mac)
    return -1;

  if (ether_hostton(mac, &hp->mac) == 0)
    return 0;

  ep = ether_aton(mac);
  if (!ep) {
    errno = EINVAL;
    return -1;
  }

  hp->mac = *ep;
  return 0;
}


HOST *
host_create(const char *name) {
  HOST *hp, **thp;


  if (!name)
    return NULL;

  hp = host_lookup(name);
  if (hp)
    return hp;

  hp = malloc(sizeof(*hp));
  if (!hp)
    return NULL;

  memset(hp, 0, sizeof(*hp));
  hp->name = strdup(name);

  /* Try to lookup mac via name in ethers file */
  (void) host_add_mac(hp, name);

#if 0
  if (gp) {
    hp->via    = gp;

    hp->copies = gp->copies;
    hp->delay  = gp->delay;
    hp->secret = gp->secret;
  }
#endif

  for (thp = &hosts; *thp; thp = &((*thp)->next))
    ;

  *thp = hp;
  return hp;
}


int
group_add_delay(HOSTGROUP *hgp,
		const char *delay) {
  if (!delay)
    return -1;
  
  return str2timespec(delay, &hgp->delay);
}



int
group_add_host(HOSTGROUP *hgp, 
	       HOST *hp) {
  int i;


  if (!hgp)
    return -1;

  if (!hp)
    return -1;

  for (i = 0; i < hgp->hc && hp != hgp->hv[i]; i++)
    ;

  if (i < hgp->hc)
    return hgp->hc;

  if (hgp->hc >= hgp->hs) {
    hgp->hs += DEFAULT_HOSTGROUP_HOSTS;
    hgp->hv = realloc(hgp->hv, hgp->hs * sizeof(HOST *));
    if (!hgp->hv)
      return -1;
  }

  hgp->hv[hgp->hc++] = hp;
  return hgp->hc;
}



int
host_add_via(HOST *hp,
	     const char *via) {
  HOSTGROUP *hgp;

  if (!via)
    return -1;

  hp->via = gw_lookup(via);
  if (!hp->via)
    return -1;

  hgp = group_lookup(hp->via->name);
  group_add_host(hgp, hp);

  return 0;
}

int
host_add_name(HOST *hp,
	      const char *name) {
  if (!name)
    return -1;
 
  if (hp->name)
    free(hp->name);

  hp->name = strdup(name);
  return 0;
}

int
host_add_delay(HOST *hp,
	       const char *delay) {
  if (!delay)
    return -1;

  return str2timespec(delay, &hp->delay);
}

int
host_add_copies(HOST *hp,
		const char *copies) {
  if (!copies || sscanf(copies, "%u", &hp->copies) != 1)
    return -1;

  return 0;
}

int
host_add_secret(HOST *hp,
		const char *secret) {
  if (!secret)
    return -1;

  return str2secret(secret, &hp->secret);
}




void
gw_print(GATEWAY *gp) {
  TARGET *tp;
  unsigned int i;


  if (f_verbose) {
    printf("Gateway %s:\n", gp->name);
    
    if (gp->copies)
      printf("  %-10s  %u\n", "Copies", gp->copies);
    if (gp->delay.tv_sec || gp->delay.tv_nsec)
      printf("  %-10s  %s\n", "Delay",  timespec2str(&gp->delay));
    if (gp->secret.size > 0)
      printf("  %-10s  %s\n", "Secret", secret2str(&gp->secret));
    printf("  Targets:\n");
    i = 0;
    for (tp = gp->targets; tp; tp = tp->next) {
      char *dest = target2str(tp);
      
      printf("    %-2u        %s\n", i+1, dest ? dest : "???");
      if (dest)
	free(dest);
      ++i;
    }

  } else {

    printf("gateway %s", gp->name);
    if (gp->address && strcmp(gp->address, gp->name) != 0)
      printf(" address %s", gp->address);
    if (gp->port && strcmp(gp->port, default_gw->port) != 0)
      printf(" port %s", gp->port);
    if (gp->copies && gp->copies != default_gw->copies)
      printf(" copies %u", gp->copies);
    if ((gp->delay.tv_sec || gp->delay.tv_nsec) && 
	!(gp->delay.tv_sec == default_gw->delay.tv_sec && gp->delay.tv_nsec == default_gw->delay.tv_nsec))
      printf(" delay %s", timespec2str(&gp->delay));
    if (gp->secret.size > 0 && (gp->secret.size != default_gw->secret.size || memcmp(gp->secret.buf, default_gw->secret.buf, gp->secret.size) != 0))
      printf(" secret %s", secret2str(&gp->secret));
    putchar('\n');
  }
}


void
host_print(HOST *hp) {
  if (f_verbose) {
    printf("Host %s:\n", hp->name);
    
    printf("  %-10s  %s\n", "MAC", ether_ntoa(&hp->mac));
    if (hp->via)
      printf("  %-10s  %s\n", "Gateway", hp->via->name);
    if (hp->copies)
      printf("  %-10s  %u\n", "Copies", hp->copies);
    if (hp->delay.tv_sec || hp->delay.tv_nsec)
      printf("  %-10s  %s\n", "Delay",  timespec2str(&hp->delay));
    if (hp->secret.size > 0)
      printf("  %-10s  %s\n", "Secret", secret2str(&hp->secret));
  } else {
    printf("host %s", hp->name);
    printf(" mac %s", ether_ntoa(&hp->mac));
    if (hp->via && group_lookup(hp->via->name) == NULL)
      printf(" via %s", hp->via->name);
    if (hp->copies)
      printf(" copies %u", hp->copies);
    if (hp->delay.tv_sec || hp->delay.tv_nsec)
      printf(" delay %s", timespec2str(&hp->delay));
    if (hp->secret.size > 0)
      printf(" secret %s", secret2str(&hp->secret));
    putchar('\n');
  }
}

void
group_print(HOSTGROUP *hgp) {
  int i;

  if (f_verbose) {
    printf("Hostgroup %s:\n", hgp->name);
    if (hgp->delay.tv_sec || hgp->delay.tv_nsec)
      printf("  %-10s  %s\n", "Delay",  timespec2str(&hgp->delay));
    if (hgp->hc > 0)
      printf("  Hosts:\n");
    for (i = 0; i < hgp->hc; i++)
      printf("    %2d        %s\n", i+1, hgp->hv[i]->name);
  } else {
    printf("[%s]\n", hgp->name);
    if (hgp->delay.tv_sec || hgp->delay.tv_nsec)
      printf("delay %s\n", timespec2str(&hgp->delay));
    for (i = 0; i < hgp->hc; i++) {
      HOST *hp = hgp->hv[i];

      printf("host %s", hp->name);

#if 0
      if (!hp->via || (hp->via && strcmp(hp->via->name, hgp->name) == 0)) {
	if (hp->copies)
	  printf(" copies %u", hp->copies);
	if (hp->delay.tv_sec || hp->delay.tv_nsec)
	  printf(" delay %s", timespec2str(&hp->delay));
	if (hp->secret.size > 0)
	  printf(" secret %s", secret2str(&hp->secret));
      }
#endif
      
      putchar('\n');
    }
  }
}
 
 void
   buf_print(FILE *fp,
	  void *buf, 
	  size_t size) {
  unsigned char *bp = (unsigned char *) buf;
  int i;

  putc('\t', fp);
  for (i = 0; i < size; i++) {
    if (i > 0) {
      if ((i & 15) == 0) {
	putc('\n', fp);
	putc('\t', fp);
      } else
	putc(':', fp);
    }
    fprintf(fp, "%02X", (unsigned int) bp[i]);
  }
  putc('\n', fp);
}


int
mac_invalid(struct ether_addr *mac) {
  int i;


  for (i = 0; i < 6 && mac->ether_addr_octet[i] == 0; i++)
    ;

  /* All 0x00 bytes - no MAC set */
  if (i == 6) {
    errno = EFAULT;
    return -1;
  }

  return 0;
}


int
send_wol_host(HOST *hp) {
  int i, j;
  int rc;
  char *msg;
  size_t msg_size;
  GATEWAY *gp = NULL;
  SECRET *sp = NULL;
  TARGET *tp = NULL;
  struct timespec delay;
  int copies;


  if (!hp)
    return -1;

  if (mac_invalid(&hp->mac)) {
    errno = EINVAL;
    return -1;
  }

  if (f_gateway) {
    gp = gw_lookup(f_gateway);
    if (!gp) {
      errno = EINVAL;
      return -1;
    }
  } else {
      gp = hp->via;
  }
  if (!gp)
    gp = default_gw;
  hp->via = gp;


  if (f_copies) {
    if (host_add_copies(hp, f_copies) < 0) {
      errno = EINVAL;
      return -1;
    }
  }
  copies = hp->copies;
  if (!copies && hp->via)
    copies = hp->via->copies;
  if (!copies)
    copies = 1;

  if (f_delay) {
    if (host_add_delay(hp, f_delay) < 0) {
      errno = EINVAL;
      return -1;
    }
  }
  delay = hp->delay;
  if (delay.tv_sec == 0 && delay.tv_nsec == 0 && hp->via)
    delay = hp->via->delay;

  if (f_secret) {
    if (host_add_secret(hp, f_secret) < 0) {
      errno = EINVAL;
      return -1;
    }
  }
  sp = &hp->secret;
  if (sp->size == 0 && hp->via)
    sp = &hp->via->secret;
  
  msg_size = WOL_BODY_SIZE;
  if (sp)
    msg_size += sp->size;

  msg = malloc(msg_size);
  if (!msg)
    return -3;
    
  memset(msg, 0xFF, MAC_SIZE);

  for (i = 0; i < MAC_COPIES; i++)
    memcpy(msg+HEADER_SIZE+i*MAC_SIZE, &hp->mac, MAC_SIZE);

  if (sp)
    memcpy(msg+HEADER_SIZE+i*MAC_SIZE, sp->buf, sp->size);

  if (f_debug) {
    fprintf(stderr, "[%s (%s)", hp->name, ether_ntoa(&hp->mac));
    if (sp && sp->size)
      fprintf(stderr, " with secret %s", secret2str(sp));
    fprintf(stderr, "]\n");
  }

  if (f_debug > 2) {
    fprintf(stderr, "UDP Packet:\n");
    buf_print(stderr, msg, msg_size);
  }

  if (f_verbose && !f_debug) {
    printf("%s (%s)", hp->name, ether_ntoa(&hp->mac));
    fflush(stdout);
  }

  for (tp = gp->targets; tp; tp = tp->next) {
    struct addrinfo *aip = tp->aip;

    if (!aip)
      continue;

    for (j = 0; j < copies; j++) {
      if (j > 0 && (delay.tv_sec || delay.tv_nsec)) {
	/* Inter-packet delay */
	struct timespec t_delay = delay;
	
	if (f_debug)
	  fprintf(stderr, "(Sleeping %s)\n", timespec2str(&delay));
	
	while ((rc = nanosleep(&t_delay, &t_delay)) < 0 && errno == EINTR) {
	  if (f_debug)
	    fprintf(stderr, "(Sleeping %s more)\n", timespec2str(&delay));
	}

	if (rc < 0) {
	  free(msg);
	  return -1;
	}
      }
      
      if (f_debug) {
	char *dest = target2str(tp);

	fprintf(stderr, "Sending packet %u/%u via %s\n", j+1, copies, dest ? dest : "???");
	if (dest)
	  free(dest);
      }

      if (!f_no) {
	while ((rc = sendto(tp->fd, msg, msg_size, 0, aip->ai_addr, aip->ai_addrlen)) < 0 && errno == EINTR)
	  ;
	
	if (rc < 0) {
	  free(msg);
	  return -1;
	}
      }

      if (f_verbose && !f_debug) {
	putc('.', stdout);
	fflush(stdout);
      }
    }

    if (f_verbose && !f_debug)
      puts(" Done");
  }
  
  free(msg);
  return 0;
}


int
send_wol(const char *name) {
  HOSTGROUP *hgp;
  HOST *hp;
  int rc, i;

  
  if ((hgp = group_lookup(name)) != NULL) {
    for (i = 0; i < hgp->hc; i++) {
      if (i > 0 && (hgp->delay.tv_sec || hgp->delay.tv_nsec)) {
	/* Inter-host delay */
	struct timespec delay = hgp->delay;
	
	if (f_debug)
	  fprintf(stderr, "(Sleeping %s)\n", timespec2str(&delay));
	
	while ((rc = nanosleep(&delay, &delay)) < 0 && errno == EINTR) {
	  if (f_debug)
	    fprintf(stderr, "(Sleeping %s more)\n", timespec2str(&delay));
	}
	
	if (rc < 0)
	  return -1;
      }

      rc = send_wol_host(hgp->hv[i]);
      if (rc) 
	return rc;
    }
    return 0;
  }
  
  hp = host_lookup(name);
  if (!hp) {
    hp = host_create(name);
    if (!hp)
      return -1;
    
    if (host_add_mac(hp, name) < 0)
      return -1;
  }

  return send_wol_host(hp);
}

void
header(FILE *fp) {
  fprintf(fp, "[pwol %s (%s %s) - (c) Peter Eriksson <pen@lysator.liu.se>]\n",
	  version, __DATE__, __TIME__);
}


void
trim(char *buf) {
  char *cp;


  /* Remove comments */
  cp = strchr(buf, ';');
  if (cp)
    *cp = '\0';
  cp = strchr(buf, '#');
  if (cp)
    *cp = '\0';

  for (cp = buf; *cp && isspace(*cp); ++cp)
    ;

  if (cp > buf)
    strcpy(buf, cp);

  for (cp = buf+strlen(buf); cp > buf && isspace(cp[-1]); --cp)
    ;
  *cp = '\0';
}


int
parse_config(const char *path) {
  char buf[2048], *bptr, *cptr;
  FILE *fp;
  int line = 0;
  int len, rc = -1;

  GATEWAY *gp = NULL;
  GATEWAY *group_gp = NULL;
  HOST *hp = NULL;
  HOSTGROUP *hgp = NULL;


  gp = gw_lookup("default");
  gw_add_address(gp, DEFAULT_ADDRESS);
  gw_add_port(gp, DEFAULT_PORT);

  if (f_debug > 1)
    fprintf(stderr, "[Parsing config: %s]\n", path);

  fp = fopen(path, "r");
  if (!fp)
    return -1;

  while (fgets(buf, sizeof(buf), fp)) {
    char *key, *val;

    ++line;

    trim(buf);

    if (!*buf)
      continue;

    bptr = buf;
    hp = NULL;

    while ((key = strtok_r(bptr, " \t", &cptr)) != NULL) {
      bptr = NULL;
      val = strtok_r(bptr, " \t", &cptr);

      if (f_debug > 1) 
	fprintf(stderr, "Got: %s %s\n", key, val ? val : "");

      if (key[0] == '[' && key[len = strlen(key)-1] == ']') {
	key[len] = '\0';
	
	if (f_debug > 2)
	  fprintf(stderr, "[Switching hostgroup to %s]\n", key+1);
	
	hgp = group_create(key+1);
	if (!hgp) {
	  fprintf(stderr, "%s: %s#%u: %s: Invalid hostgroup\n", argv0, path, line, key+1);
	  exit(1);
	}
	
	/* Try to lookup gateway with same name as hostgroup */
	group_gp = gw_lookup(key+1);
	continue;
      }

      rc = 0;
      if (strcmp(key, "host") == 0) {
	hp = host_create(val);
	if (!hp) {
	  fprintf(stderr, "%s: %s#%u: %s: Invalid host name\n",
		  argv0, path, line, val);
	  exit(1);
	}

	if (hp->via == NULL && group_gp)
	  hp->via = group_gp;

	if (hgp)
	  group_add_host(hgp, hp);

	if (all_group)
	  group_add_host(all_group, hp);

      } else if (strcmp(key, "gateway") == 0) {
	if (hgp) {
	  fprintf(stderr, "%s: %s#%u: Can not define gateways in groups\n",
		  argv0, path, line);
	  exit(1);
	}
	gp = gw_create(val);
	if (!gp) {
	  fprintf(stderr, "%s: %s#%u: %s: Invalid gateway name\n",
		  argv0, path, line, val);
	  exit(1);
	}
	hp = NULL;

      } else if (strcmp(key, "name") == 0) {
	if (hgp && !hp)
	  goto InvalidOpt;
	if (hp)
	  rc = host_add_name(hp, val);
	else
	  rc = gw_add_name(gp, val);
      } else if (strcmp(key, "mac") == 0) {
	if (hp)
	  rc = host_add_mac(hp, val);
	else
	  goto InvalidOpt;
      } else if (strcmp(key, "via") == 0) {
	if (hp) {
	  rc = host_add_via(hp, val);
	}
	else
	  goto InvalidOpt;
      }	else if (strcmp(key, "copies") == 0) {
	if (hgp && !hp)
	  goto InvalidOpt;
	if (hp)
	  rc = host_add_copies(hp, val);
	else
	  rc = gw_add_copies(gp, val);
      } else if (strcmp(key, "secret") == 0) {
	if (hgp && !hp)
	  goto InvalidOpt;
	if (hp)
	  rc = host_add_secret(hp, val);
	else
	  rc = gw_add_secret(gp, val);
      } else if (strcmp(key, "delay") == 0) {
	if (hgp && !hp)
	  rc = group_add_delay(hgp, val);
	else if (hp)
	  rc = host_add_delay(hp, val);
	else
	  rc = gw_add_delay(gp, val);
      } else if (strcmp(key, "address") == 0) {
	if (hp)
	  goto InvalidOpt;
	rc = gw_add_address(gp, val);
      } else if (strcmp(key, "port") == 0) {
	if (hp)
	  goto InvalidOpt;
	rc = gw_add_port(gp, val);
      } else {
      InvalidOpt:
	fprintf(stderr, "%s: %s#%u: %s: Invalid option\n", argv0, path, line, key);
	exit(1);
      }

      if (rc < 0) {
	fprintf(stderr, "%s: %s#%u: %s: Invalid value for %s (rc=%d)\n", argv0, path, line, val, key, rc);
	exit(1);
      }
    }
  }
  
  fclose(fp);
  return 0;
}


void
export_all(void) {
  GATEWAY *gp;
  HOST *hp;
  HOSTGROUP *hgp;
  int n;


  if (!f_verbose) {
    puts("; pwol configuration");
    putchar('\n');
    puts("; Gateways:");
  }
  for (gp = gateways; gp; gp = gp->next) {

    if (!gp->name)
      continue; /* Skip over anonymous gateways */

    gw_print(gp);
  }

  putchar('\n');
  if (!f_verbose) {
    puts("; Hosts:");
  }
  for (hp = hosts; hp; hp = hp->next) {
    host_print(hp);
  }

  putchar('\n');
  if (!f_verbose) {
    puts("; Groups:");
  }
  n = 0;
  for (hgp = hostgroups; hgp; hgp = hgp->next) {
    if (!f_verbose && strcmp(hgp->name, "all") == 0)
      continue;
    
    if (hgp->hc == 0)
      continue;

    if (n++ > 0 && !f_verbose)
      putchar('\n');
    group_print(hgp);
  }
}


int daemon_run(GATEWAY *gp) {
  TARGET *tp;
  struct addrinfo *aip;
  int n, i;
  struct pollfd *pfdv;
  struct ether_addr *ep;
  HOST *hp;


  n = 0;
  for (tp = gp->targets; tp; tp = tp->next)
    ++n;

  if (n == 0) {
    errno = ENOENT;
    if (f_debug)
      fprintf(stderr, "*** daemon_run: No listening ports\n");
    return -1;
  }

  pfdv = malloc(n * sizeof(struct pollfd *));
  if (!pfdv)
    return -1;

  if (f_debug)
    fprintf(stderr, "[Creating and binding daemon sockets]\n");

  i = 0;
  for (tp = gp->targets; tp; tp = tp->next) {
    aip = tp->aip;
    tp->fd = socket((aip->ai_family == AF_INET ? PF_INET : PF_INET6), SOCK_DGRAM, IPPROTO_UDP);
    if (tp->fd < 0)
      return -1;

    if (bind(tp->fd, aip->ai_addr, aip->ai_addrlen) < 0)
      return -2;

    pfdv[i++].fd = tp->fd;
  }

  if (f_debug)
    fprintf(stderr, "[Entering daemon main loop]\n");
  
  while (1) {
    int i, rc;


    for (i = 0; i < n; i++) {
      pfdv[i].events = POLLIN;
      pfdv[i].revents = 0;
    }

    do {
      if (f_debug)
	fprintf(stderr, "(Waiting for messages on %u FDs)\n", n);
      rc = poll(&pfdv[0], n, -1);
    } while (rc < 0 && errno == EINTR);

    if (rc < 0)
      return -1;

    for (i = 0; i < n; i++) {
      ssize_t rlen;
      struct sockaddr_storage peer;
      socklen_t peer_len;
      unsigned char buf[2048];
      size_t secret_size;


      if (pfdv[i].revents & POLLIN) {
	if (f_debug)
	  fprintf(stderr, "[Data available on FD #%u]\n", pfdv[i].fd);

	peer_len = sizeof(peer);
	while ((rlen = recvfrom(pfdv[i].fd, buf, sizeof(buf), 0, (struct sockaddr *) &peer, &peer_len)) < 0 && errno == EINTR)
	  ;
	
	if (rlen < 0)
	  return -1;

	if (f_debug)
	  fprintf(stderr, "[Message on FD #%u received from %s]\n", pfdv[i].fd, sockaddr2str((struct sockaddr *) &peer, peer_len));

	if (f_debug)
	  buf_print(stderr, buf, rlen);

	if (rlen < WOL_BODY_SIZE) {
	  if (f_debug)
	    fprintf(stderr, "*** Invalid WoL message (too short: %d bytes)\n", (int) rlen);
	  continue;
	}

	for (i = 0; i < HEADER_SIZE && buf[i] == 0xFF; i++)
	  ;
	if (i < HEADER_SIZE) {
	  if (f_debug)
	    fprintf(stderr, "*** Invalid WoL message (invalid header)\n");
	  continue;
	}

	for (i = 1; i < MAC_COPIES && memcmp(buf+HEADER_SIZE, buf+HEADER_SIZE+i*MAC_SIZE, MAC_SIZE) == 0; i++)
	  ;
	if (i < MAC_COPIES) {
	  if (f_debug)
	    fprintf(stderr, "*** Invalid WoL message (invalid MAC content copies)\n");
	  continue;
	}

	secret_size = rlen-WOL_BODY_SIZE;
	if (secret_size > 0) {
	  SECRET secret;

	  secret.size = secret_size;
	  memcpy(secret.buf, buf+WOL_BODY_SIZE, secret_size);
	  
	  if (f_debug)
	    fprintf(stderr, "*** Received secret: %s\n", secret2str(&secret));
	  
	  if (secret_compare(&gp->secret, &secret) != 0) {
	    if (f_debug)
	      fprintf(stderr, "*** Invalid received secret: %s\n", secret2str(&secret));
	    continue;
	  }
	}

	ep = (struct ether_addr *) (buf+HEADER_SIZE);
	for (hp = hosts; hp && memcmp(ep, &hp->mac, MAC_SIZE) != 0; hp = hp->next)
	  ;

	if (!hp) {
	  if (f_debug)
	    fprintf(stderr, "*** Unknown MAC (no such host): %s\n", ether_ntoa(ep));
	  continue;
	}

	printf("Got WoL for host: %s (%s)\n", hp->name, ether_ntoa(ep));
	if (send_wol_host(hp) < 0) {
	  if (f_debug)
	    fprintf(stderr, "*** Error send WoL message to %s (%s)\n", hp->name, ether_ntoa(ep));
	}
      }
    }
  }
}


void
become_daemon(void) {
 
  pid_t pid;
  int i, fd;


  pid = fork();
  if (pid < 0) {
    syslog(LOG_ERR, "fork() failed: %m");
    exit(EXIT_FAILURE);
  }
  else if (pid > 0)
    exit(EXIT_SUCCESS);

  signal(SIGTTOU, SIG_IGN);
  signal(SIGTTIN, SIG_IGN);
#ifdef SIGTTSP
  signal(SIGTTSP, SIG_IGN);
#endif

#ifdef HAVE_SETSID
  setsid();
#endif

  if (chdir("/") < 0)
    exit(EXIT_FAILURE);
  
  umask(0);

  fd = open("/dev/null", O_RDWR);
  if (fd < 0)
    exit(EXIT_FAILURE);
  
  for (i = 0; i < 3; i++)
    close(i);

  dup2(fd, 0);
  dup2(fd, 1);
  dup2(fd, 2);
}


int
main(int argc,
     char *argv[])
{
  char *home = getenv("HOME");
  char *home_config = strdupcat(home, "/", DEFAULT_USER_CONFIG, NULL);
  char *cp;
  int i, j;
  GATEWAY *gp, *proxy_gp = NULL;
  TARGET *tp;
  HOSTGROUP *hgp;


  argv0 = argv[0];

  /* Create default */
  
  default_gw = gw_create("default");
  if (!default_gw) {
    fprintf(stderr, "%s: Internal error #1458934\n", argv0);
    exit(1);
  }
  gw_add_address(default_gw, DEFAULT_ADDRESS);
  gw_add_port(default_gw, DEFAULT_PORT);
  gw_add_copies(default_gw, DEFAULT_COPIES);
  gw_add_delay(default_gw, DEFAULT_DELAY);
  gw_add_secret(default_gw, DEFAULT_SECRET);

  all_group = group_create("all");

  parse_config(DEFAULT_GLOBAL_CONFIG);
  if (home_config) {
    parse_config(home_config);
    free(home_config);
  }
  
  for (i = 1; i < argc && argv[i][0] == '-'; i++) {
    for (j = 1; argv[i][j]; j++)
      switch (argv[i][j]) {
      case 'V':
	header(stdout);
	exit(0);

      case 'v':
	++f_verbose;
	break;
		
      case 'd':
	++f_debug;
	break;
		
      case 'n':
	f_no = !f_no;
	break;
		
      case 'e':
	++f_export;
	break;
		
      case 'i':
	++f_ignore;
	break;
		
      case 'D':
	++f_daemon;
	break;

      case 'F':
	++f_foreground;
	break;

      case 'a':
	cp = argv[i]+j+1;
	if (!*cp && i+1 < argc) {
	  cp = argv[++i];
	}
	if (cp)
	  f_address = strdup(cp);
	goto NextArg;

      case 'g':
	cp = argv[i]+j+1;
	if (!*cp && i+1 < argc) {
	  cp = argv[++i];
	}
	if (cp)
	  f_gateway = strdup(cp);
	goto NextArg;

      case 'p':
	cp = argv[i]+j+1;
	if (!*cp && i+1 < argc) {
	  cp = argv[++i];
	}
	if (cp)
	  f_port = strdup(cp);
	goto NextArg;

      case 't':
	cp = argv[i]+j+1;
	if (!*cp && i+1 < argc) {
	  cp = argv[++i];
	}
	if (cp)
	  f_delay = strdup(cp);
	goto NextArg;

      case 'T':
	cp = argv[i]+j+1;
	if (!*cp && i+1 < argc) {
	  cp = argv[++i];
	}
	if (cp)
	  f_host_delay = strdup(cp);
	goto NextArg;

      case 'c':
	cp = argv[i]+j+1;
	if (!*cp && i+1 < argc) {
	  cp = argv[++i];
	}
	if (cp)
	  f_copies = strdup(cp);
	goto NextArg;
		
      case 's':
	cp = argv[i]+j+1;
	if (!*cp && i+1 < argc) {
	  cp = argv[++i];
	}
	if (cp)
	  f_secret = strdup(cp);
	goto NextArg;

      case 'f':
	cp = argv[i]+j+1;
	if (!*cp && i+1 < argc) {
	  cp = argv[++i];
	}
	if (cp)
	  parse_config(cp);
	goto NextArg;

      case 'A':
	cp = argv[i]+j+1;
	if (!*cp && i+1 < argc) {
	  cp = argv[++i];
	}
	if (cp) {
	  f_proxy_address = strdup(cp);
	}
	goto NextArg;

      case 'P':
	cp = argv[i]+j+1;
	if (!*cp && i+1 < argc) {
	  cp = argv[++i];
	}
	if (cp) {
	  if (!proxy_gp)
	    proxy_gp = gw_create(NULL);
	  gw_add_port(proxy_gp, cp);
	  f_proxy_port = strdup(cp);
	}
	goto NextArg;

      case 'S':
	cp = argv[i]+j+1;
	if (!*cp && i+1 < argc) {
	  cp = argv[++i];
	}
	if (cp)
	  f_proxy_secret = strdup(cp);
	goto NextArg;


      case 'h':
	printf("Usage: %s [<options>] [<host|group> [.. <host|group>]]\n",
	       argv[0]);
	puts("\nOptions:");
	puts("  -h           Display this information");
	puts("  -v           Increase verbosity");
	puts("  -d           Increase debug level");
	puts("  -i           Ignore errors");
	puts("  -n           Toggle \"no\" send mode");
	puts("  -e           Export configuration");
	puts("  -f <path>    Configuration file");
	puts("");
	puts("  -g <name>    Destination gateway");
	puts("  -a <addr>    Destination address");
	puts("  -p <port>    Destination port");
	puts("  -t <time>    Inter-packet delay");
	puts("  -T <time>    Inter-host delay");
	puts("  -c <count>   Packet copies to send");
	puts("  -s <secret>  Force WoL secret");
	puts("");
	puts("  -D           Run as proxy daemon");
	puts("  -F           Run proxy daemon in foreground");
	puts("  -A <addr>    Proxy daemon listen address");
	puts("  -P <port>    Proxy daemon listen port");
	puts("  -S <secret>  Proxy daemon secret");
	puts("");
	puts("If no hosts/groups specified on the command line pwol will read them from stdin");
	exit(0);

      case '-':
	++i;
	goto EndArg;

      default:
	fprintf(stderr, "%s: -%c: Invalid switch\n",
		argv[0], argv[i][j]);
	exit(1);
      }
  NextArg:;
  }
 EndArg:

  if (f_verbose)
    header(stdout);

  if (f_daemon) {
    proxy_gp = gw_create(NULL);
    gw_add_address(proxy_gp, f_proxy_address ? f_proxy_address : DEFAULT_PROXY_ADDRESS);
    gw_add_port(proxy_gp, f_proxy_port ? f_proxy_port : DEFAULT_PROXY_PORT);
    if (f_proxy_secret)
      gw_add_secret(proxy_gp, f_proxy_secret);
  }

  /* Open sockets for sending packets via the gateway targets */
  for (gp = gateways; gp; gp = gp->next) {
    struct addrinfo hints, *aip;
    int rc;
    char *addr, *port;

    memset(&hints, 0, sizeof(hints));
    hints.ai_socktype = SOCK_DGRAM;
    
    aip = NULL;

    addr = f_address;
    if (!addr)
      addr = gp->address;
    if (!addr)
      addr = DEFAULT_ADDRESS;

    port = f_port;
    if (!port)
      port = gp->port;
    if (!port)
      port = DEFAULT_PORT;

    if ((rc = getaddrinfo(addr, port, &hints, &aip)) != 0) {
      fprintf(stderr, "%s: %s port %s: Invalid target\n", argv[0], addr, port);
      exit(1);
    }

    for (; aip; aip = aip->ai_next) {
      int one = 1;

      tp = target_add(&gp->targets, aip);
      if (!tp) {
	fprintf(stderr, "%s: %s port %s: Internal Error #3345921\n", argv[0], gp->address, gp->port);
	exit(1);
      }

      tp->fd = socket((aip->ai_family == AF_INET ? PF_INET : PF_INET6), SOCK_DGRAM, IPPROTO_UDP);
      if (tp->fd < 0) {
	fprintf(stderr, "%s: %s port %s: socket: %s\n", argv[0], gp->address, gp->port, strerror(errno));
	exit(1);
      }
#ifdef SO_BROADCAST
      (void) setsockopt(tp->fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one));
#endif
    }
  }
  
  if (f_host_delay) {
    for (hgp = hostgroups; hgp; hgp = hgp->next)
      group_add_delay(hgp, f_host_delay);
  }

  if (f_export) {
    export_all();
    exit(0);
  }

  if (f_daemon) {
    if (!f_foreground)
      become_daemon();

    if (daemon_run(proxy_gp) < 0) {
      fprintf(stderr, "%s: daemon_run: %s\n", argv[0], strerror(errno));
      exit(1);
    }
      
    exit(0);
  }

  if (i < argc) {
    for (;i < argc; i++) {
      if (send_wol(argv[i]) < 0 && !f_ignore) {
	fprintf(stderr, "%s: %s: Sending WoL packet failed: %s\n",
		argv[0], argv[i], strerror(errno));
	exit(1);
      }
    }
  } else {
    char lbuf[80], *lp, *lptr, *cp;

	
    if (isatty(fileno(stdin))) {
      fputs("[Enter hosts or groups to send WoL packet to, end with EOF]\n", stderr);
      fflush(stderr);
    }

    while (fgets(lbuf, sizeof(lbuf), stdin)) {
      trim(lbuf);
      if (!*lbuf)
	continue;

      lp = lbuf;
      while ((cp = strtok_r(lp, " \t", &lptr)) != NULL) {
	lp = NULL;

	if (send_wol(cp) < 0) {
	  fprintf(stderr, "%s: %s: Sending WoL packet failed: %s\n",
		  argv[0], cp, strerror(errno));
	  
	  if (!f_ignore)
	    exit(1);
	}
      }
    }
  }

  exit(0);
}




; pwol.conf

;;; Default settings:
; copies 1
; delay 0.0s
; port 7

;;; Sample configuration:
; gateway A 
;  address 10.0.0.255
;  port 1

; gateway B address b.wol.example.com
; gateway c.wol.example.com secret 1.2.3.4
; gateway D address 2001:0:1::1

; host test-1 mac fc:3f:db:04:1e:01 via A secret 1:2:3:4:5:6
; host test-2 
;   mac fc:3f:db:04:1e:02 
;   secret hello7

; [B]

;:; Inter-host delay
; delay 1s 

; host test-3 mac b8:ac:6f:1f:68:03 delay 100ns
; host test-4    mac 00:1b:78:9b:c6:04 secret 1.2.3.4
; host 00:11:22:33:44:55
; host 00:11:22:33:44:ff name test-6

;;; Only works if hosts are defined in /etc/ethers
; host test-7   mac test-7.example.com  copies 2 delay 1s
; host test-8.example.com

; [MyGroup]
; host test-3
; host test-6




.TH "PWOL.CONF" "5" "14 Jun 2020" "1.5" "pwol.conf man page"

.SH "NAME"
.TP
.BR pwol.conf "\- Global configuration file for pwol"
.TP
.BR ~/.pwolrc "\- Per-user configuration file for pwol"

.SH "DESCRIPTION"
.B pwol is a command line utility to send Wake-On-LAN (WoL) packets to one or many hosts, either 
locally or via routers, in order to wake them up from sleep mode. 
.PP
It can also be used as a WoL proxy daemon listening to incoming WoL packets (possibly authenticated) 
and then forwarding requests to one or many other targets.
.PP
The configuration file(s) for
.B pwol
define global options, gateways (that forwards WoL packets), hosts (destinations
for WoL packets) and host groups (preferably in that order).
.PP
For gateways and hosts can override the global options plus use a few local ones
defined below. The gateway and host options may be specified on the same line or
on following lines (until the next gateway/host or host group definitions are
started).
.PP
Lines starting with ";" or "#" and empty lines are ignored.

.SH "GLOBAL OPTIONS"
.TP
.BI copies " number"
Set the number of WoL packets to send per host
.TP
.BI delay " time"
Set the inter-packet delay.
.TP
.BI port " number"
Set the destination UDP port to send WoL packets to.
.TP
.BI secret " ipv4|mac|text"
Set the secret code to include in WoL packets

.TP
.BI gateway " name [sub-options]"
Start a gateway definition
.TP
.BI host " name|mac [sub-options]"
Start a host definition.
.TP
.BI "[" name "]"
Start a host group section.

.SH "GATEWAY OPTIONS"
.TP
.BI address " ipv4|ipv6|hostname"
Set the ip address of the gateway. If not specified will try to use the gateway name
as a host name to lookup up the address.

.SH "HOST OPTIONS"
.TP
.BI mac " mac-address|hostname"
Set the mac address of the host. If not specified will try to use the host name 
to look up the mac address from /etc/ethers (if the system supports such lookups).
.TP
.BI name " text"
Override the name of the host (if mac is specified as
.BR name ")."
.TP
.BI via " gateway-name"
Send packets to this host via the specified gateway.

.SH "HOST GROUPS"
Host groups are specified by a group name enclosed in "[" and "]" and then
followed by a list of normal host declarations. As a short cut if a host is to
be defined in multiple host groups then you do not need to re-specify all host
sub-options and can just reference it via
.BI host " name."
Another shortcut is that if a group name equals the name of a gateway then that
is used for each host in the group. 

.SH "EXAMPLE"
.nf
; pwol.conf

;; Global settings:
copies 1
delay 0.0s
port 7


;; Some gateways:
gateway A 
 address 10.0.0.255
 port 1

gateway B address b.wol.example.com
gateway c.wol.example.com secret 1.2.3.4
gateway D address 2001:0:1::1


;; Some hosts:
host test-1 mac fc:3f:db:04:1e:01 via A secret 1:2:3:4:5:6
host test-2 
  mac fc:3f:db:04:1e:02 
   secret hello7


;; Host group using gateway "B"
[B]
:; These hosts need a longer inter-host delay
delay 1s 

host test-3 mac b8:ac:6f:1f:68:03 delay 100ns
host test-4    mac 00:1b:78:9b:c6:04 secret 1.2.3.4
host 00:11:22:33:44:55
host 00:11:22:33:44:ff name test-6

;; Only works if hosts are defined in /etc/ethers
host test-7   mac test-7.example.com  copies 2 delay 1s
host test-8.example.com


;; Standalone host group:
[MyGroup]
host test-3
host test-6
.fi

.SH "SEE ALSO"
.BR pwol (1),
.BR ping (8),
.B "https://github.com/ptrrkssn/pwol"

.SH "AUTHOR"
pwol was written by Peter Eriksson <pen@lysator.liu.se>.




.TH "PWOL.CONF" "5" "14 Jun 2020" "@PACKAGE_VERSION@" "pwol.conf man page"

.SH "NAME"
.TP
.BR pwol.conf "\- Global configuration file for pwol"
.TP
.BR ~/.pwolrc "\- Per-user configuration file for pwol"

.SH "DESCRIPTION"
.B pwol is a command line utility to send Wake-On-LAN (WoL) packets to one or many hosts, either 
locally or via routers, in order to wake them up from sleep mode. 
.PP
It can also be used as a WoL proxy daemon listening to incoming WoL packets (possibly authenticated) 
and then forwarding requests to one or many other targets.
.PP
The configuration file(s) for
.B pwol
define global options, gateways (that forwards WoL packets), hosts (destinations
for WoL packets) and host groups (preferably in that order).
.PP
For gateways and hosts can override the global options plus use a few local ones
defined below. The gateway and host options may be specified on the same line or
on following lines (until the next gateway/host or host group definitions are
started).
.PP
Lines starting with ";" or "#" and empty lines are ignored.

.SH "GLOBAL OPTIONS"
.TP
.BI copies " number"
Set the number of WoL packets to send per host
.TP
.BI delay " time"
Set the inter-packet delay.
.TP
.BI port " number"
Set the destination UDP port to send WoL packets to.
.TP
.BI secret " ipv4|mac|text"
Set the secret code to include in WoL packets

.TP
.BI gateway " name [sub-options]"
Start a gateway definition
.TP
.BI host " name|mac [sub-options]"
Start a host definition.
.TP
.BI "[" name "]"
Start a host group section.

.SH "GATEWAY OPTIONS"
.TP
.BI address " ipv4|ipv6|hostname"
Set the ip address of the gateway. If not specified will try to use the gateway name
as a host name to lookup up the address.

.SH "HOST OPTIONS"
.TP
.BI mac " mac-address|hostname"
Set the mac address of the host. If not specified will try to use the host name 
to look up the mac address from /etc/ethers (if the system supports such lookups).
.TP
.BI name " text"
Override the name of the host (if mac is specified as
.BR name ")."
.TP
.BI via " gateway-name"
Send packets to this host via the specified gateway.

.SH "HOST GROUPS"
Host groups are specified by a group name enclosed in "[" and "]" and then
followed by a list of normal host declarations. As a short cut if a host is to
be defined in multiple host groups then you do not need to re-specify all host
sub-options and can just reference it via
.BI host " name."
Another shortcut is that if a group name equals the name of a gateway then that
is used for each host in the group. 

.SH "EXAMPLE"
.nf
; pwol.conf

;; Global settings:
copies 1
delay 0.0s
port 7


;; Some gateways:
gateway A 
 address 10.0.0.255
 port 1

gateway B address b.wol.example.com
gateway c.wol.example.com secret 1.2.3.4
gateway D address 2001:0:1::1


;; Some hosts:
host test-1 mac fc:3f:db:04:1e:01 via A secret 1:2:3:4:5:6
host test-2 
  mac fc:3f:db:04:1e:02 
   secret hello7


;; Host group using gateway "B"
[B]
:; These hosts need a longer inter-host delay
delay 1s 

host test-3 mac b8:ac:6f:1f:68:03 delay 100ns
host test-4    mac 00:1b:78:9b:c6:04 secret 1.2.3.4
host 00:11:22:33:44:55
host 00:11:22:33:44:ff name test-6

;; Only works if hosts are defined in /etc/ethers
host test-7   mac test-7.example.com  copies 2 delay 1s
host test-8.example.com


;; Standalone host group:
[MyGroup]
host test-3
host test-6
.fi

.SH "SEE ALSO"
.BR pwol (1),
.BR ping (8),
.B "https://github.com/ptrrkssn/pwol"

.SH "AUTHOR"
pwol was written by Peter Eriksson <pen@lysator.liu.se>.




Peter's Wake-On-LAN utility

Author:   Peter Eriksson <pen@lysator.liu.se>
Website:  https://github.com/ptrrkssn/pwol

pwol is a command line utility to send Wake-On-LAN (WoL) packets to one or many hosts, either 
locally or via routers, in order to wake them up from sleep mode. 

It can also be used as a WoL proxy daemon listening to incoming WoL packets (possibly authenticated) 
and then forwarding requests to one or many other targets.


LICENSE 

BSD standard license. See the file LICENSE for details.


BUILD INSTRUCTIONS

Edit 'Makefile' and run 'make'. Build has been tested on Solaris 10, OmniOS, Linux (CentOS 6) and FreeBSD 11.


USAGE

pwol looks for a configuration file in two places by default, /etc/pwol.conf and 
$HOME/.pwolrc. Additional configuration files may be specified via the "-f" command 
line switch.

See the "pwol.conf" file for details.




; pwol.conf

;;; Default settings:
; copies 1
; delay 0.0s
; port 7

;;; Sample configuration:
; gateway A 
;  address 10.0.0.255
;  port 1

; gateway B address b.wol.example.com
; gateway c.wol.example.com secret 1.2.3.4
; gateway D address 2001:0:1::1

; host test-1 mac fc:3f:db:04:1e:01 via A secret 1:2:3:4:5:6
; host test-2 
;   mac fc:3f:db:04:1e:02 
;   secret hello7

; [B]

;:; Inter-host delay
; delay 1s 

; host test-3 mac b8:ac:6f:1f:68:03 delay 100ns
; host test-4    mac 00:1b:78:9b:c6:04 secret 1.2.3.4
; host 00:11:22:33:44:55
; host 00:11:22:33:44:ff name test-6

;;; Only works if hosts are defined in /etc/ethers
; host test-7   mac test-7.example.com  copies 2 delay 1s
; host test-8.example.com

; [MyGroup]
; host test-3
; host test-6




BSD 3-Clause License

Copyright (c) 2017, Peter Eriksson <pen@lysator.liu.se>
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.

* 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.

* Neither the name of the copyright holder 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 COPYRIGHT HOLDER 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.

Line 0 Link Here

(-)sysutils/pwol/work/stage/usr/local/share/licenses/pwol-1.5/catalog.mk (+5 lines)
	1	_LICENSE=BSD3CLAUSE
	2	_LICENSE_NAME=BSD 3-clause New or Revised License
	3	_LICENSE_PERMS=dist-mirror dist-sell pkg-mirror pkg-sell auto-accept
	4	_LICENSE_GROUPS=FSF OSI COPYFREE
	5	_LICENSE_DISTFILES=ptrrkssn-pwol-v1.5_GH0.tar.gz

Line 0 Link Here

(-)sysutils/pwol/work/stage/usr/local/share/licenses/pwol-1.5/LICENSE (+1 lines)
	1	This package has a single license: BSD3CLAUSE (BSD 3-clause New or Revised License).

Return to bug 247251

Line 0 Link Here

(-)sysutils/pwol/Makefile (+24 lines)
	1	# $FreeBSD$
	2
	3	PORTNAME= pwol
	4	DISTVERSIONPREFIX= v
	5	DISTVERSION= 1.5
	6	CATEGORIES= sysutils
	7
	8	MAINTAINER= pen@lysator.liu.se
	9	COMMENT= Peter's Wake-on-LAN Tool
	10
	11	LICENSE= BSD3CLAUSE
	12	LICENSE_FILE= ${WRKSRC}/LICENSE
	13
	14	USE_GITHUB= yes
	15	GH_ACCOUNT= ptrrkssn
	16
	17	GNU_CONFIGURE= yes
	18
	19	PLIST_FILES= bin/pwol \
	20	man/man1/pwol.1.gz \
	21	man/man5/pwol.conf.5.gz \
	22	etc/pwol.conf.sample
	23
	24	.include <bsd.port.mk>

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/.github/workflows/ccpp.yml (+21 lines)
	1	name: C/C++ CI
	2
	3	on: [push]
	4
	5	jobs:
	6	build:
	7
	8	runs-on: ubuntu-latest
	9
	10	steps:
	11	- uses: actions/checkout@v2
	12	# - name: install dependencies
	13	# run: test -f /usr/include/readline/readline.h \|\| sudo apt install libreadline-dev
	14	# - name: configure
	15	# run: ./configure
	16	- name: make
	17	run: make
	18	# - name: make check
	19	# run: make check
	20	# - name: make distcheck
	21	# run: make distcheck

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/aux/compile (+348 lines)
		1	#! /bin/sh
		2	# Wrapper for compilers which do not understand '-c -o'.
		3
		4	scriptversion=2018-03-07.03; # UTC
		5
		6	# Copyright (C) 1999-2018 Free Software Foundation, Inc.
		7	# Written by Tom Tromey <tromey@cygnus.com>.
		8	#
		9	# This program is free software; you can redistribute it and/or modify
		10	# it under the terms of the GNU General Public License as published by
		11	# the Free Software Foundation; either version 2, or (at your option)
		12	# any later version.
		13	#
		14	# This program is distributed in the hope that it will be useful,
		15	# but WITHOUT ANY WARRANTY; without even the implied warranty of
		16	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		17	# GNU General Public License for more details.
		18	#
		19	# You should have received a copy of the GNU General Public License
		20	# along with this program. If not, see <https://www.gnu.org/licenses/>.
		21
		22	# As a special exception to the GNU General Public License, if you
		23	# distribute this file as part of a program that contains a
		24	# configuration script generated by Autoconf, you may include it under
		25	# the same distribution terms that you use for the rest of that program.
		26
		27	# This file is maintained in Automake, please report
		28	# bugs to <bug-automake@gnu.org> or send patches to
		29	# <automake-patches@gnu.org>.
		30
		31	nl='
		32	'
		33
		34	# We need space, tab and new line, in precisely that order. Quoting is
		35	# there to prevent tools from complaining about whitespace usage.
		36	IFS=" "" $nl"
		37
		38	file_conv=
		39
		40	# func_file_conv build_file lazy
		41	# Convert a $build file to $host form and store it in $file
		42	# Currently only supports Windows hosts. If the determined conversion
		43	# type is listed in (the comma separated) LAZY, no conversion will
		44	# take place.
		45	func_file_conv ()
		46	{
		47	file=$1
		48	case $file in
		49	/ \| /[!/]*) # absolute file, and not a UNC file
		50	if test -z "$file_conv"; then
		51	# lazily determine how to convert abs files
		52	case `uname -s` in
		53	MINGW*)
		54	file_conv=mingw
		55	;;
		56	CYGWIN*)
		57	file_conv=cygwin
		58	;;
		59	*)
		60	file_conv=wine
		61	;;
		62	esac
		63	fi
		64	case $file_conv/,$2, in
65	,$file_conv,)
66	;;
67	mingw/*)
68	file=`cmd //C echo "$file " \| sed -e 's/"\(.\) " $/\1/'`
69	;;
70	cygwin/*)
71	file=`cygpath -m "$file" \|\| echo "$file"`
72	;;
73	wine/*)
74	file=`winepath -w "$file" \|\| echo "$file"`
75	;;
76	esac
77	;;
78	esac
79	}
80
81	# func_cl_dashL linkdir
82	# Make cl look for libraries in LINKDIR
83	func_cl_dashL ()
84	{
85	func_file_conv "$1"
86	if test -z "$lib_path"; then
87	lib_path=$file
88	else
89	lib_path="$lib_path;$file"
90	fi
91	linker_opts="$linker_opts -LIBPATH:$file"
92	}
93
94	# func_cl_dashl library
95	# Do a library search-path lookup for cl
96	func_cl_dashl ()
97	{
98	lib=$1
99	found=no
100	save_IFS=$IFS
101	IFS=';'
102	for dir in $lib_path $LIB
103	do
104	IFS=$save_IFS
105	if $shared && test -f "$dir/$lib.dll.lib"; then
106	found=yes
107	lib=$dir/$lib.dll.lib
108	break
109	fi
110	if test -f "$dir/$lib.lib"; then
111	found=yes
112	lib=$dir/$lib.lib
113	break
114	fi
115	if test -f "$dir/lib$lib.a"; then
116	found=yes
117	lib=$dir/lib$lib.a
118	break
119	fi
120	done
121	IFS=$save_IFS
122
123	if test "$found" != yes; then
124	lib=$lib.lib
125	fi
126	}
127
128	# func_cl_wrapper cl arg...
129	# Adjust compile command to suit cl
130	func_cl_wrapper ()
131	{
132	# Assume a capable shell
133	lib_path=
134	shared=:
135	linker_opts=
136	for arg
137	do
138	if test -n "$eat"; then
139	eat=
140	else
141	case $1 in
142	-o)
143	# configure might choose to run compile as 'compile cc -o foo foo.c'.
144	eat=1
145	case $2 in
146	.o \| .[oO][bB][jJ])
147	func_file_conv "$2"
148	set x "$@" -Fo"$file"
149	shift
150	;;
151	*)
152	func_file_conv "$2"
153	set x "$@" -Fe"$file"
154	shift
155	;;
156	esac
157	;;
158	-I)
159	eat=1
160	func_file_conv "$2" mingw
161	set x "$@" -I"$file"
162	shift
163	;;
164	-I*)
165	func_file_conv "${1#-I}" mingw
166	set x "$@" -I"$file"
167	shift
168	;;
169	-l)
170	eat=1
171	func_cl_dashl "$2"
172	set x "$@" "$lib"
173	shift
174	;;
175	-l*)
176	func_cl_dashl "${1#-l}"
177	set x "$@" "$lib"
178	shift
179	;;
180	-L)
181	eat=1
182	func_cl_dashL "$2"
183	;;
184	-L*)
185	func_cl_dashL "${1#-L}"
186	;;
187	-static)
188	shared=false
189	;;
190	-Wl,*)
191	arg=${1#-Wl,}
192	save_ifs="$IFS"; IFS=','
193	for flag in $arg; do
194	IFS="$save_ifs"
195	linker_opts="$linker_opts $flag"
196	done
197	IFS="$save_ifs"
198	;;
199	-Xlinker)
200	eat=1
201	linker_opts="$linker_opts $2"
202	;;
203	-*)
204	set x "$@" "$1"
205	shift
206	;;
207	.cc \| .CC \| .cxx \| .CXX \| *.[cC]++)
208	func_file_conv "$1"
209	set x "$@" -Tp"$file"
210	shift
211	;;
212	.c \| .cpp \| .CPP \| .lib \| .LIB \| .Lib \| .OBJ \| .obj \| *.[oO])
213	func_file_conv "$1" mingw
214	set x "$@" "$file"
215	shift
216	;;
217	*)
218	set x "$@" "$1"
219	shift
220	;;
221	esac
222	fi
223	shift
224	done
225	if test -n "$linker_opts"; then
226	linker_opts="-link$linker_opts"
227	fi
228	exec "$@" $linker_opts
229	exit 1
230	}
231
232	eat=
233
234	case $1 in
235	'')
236	echo "$0: No command. Try '$0 --help' for more information." 1>&2
237	exit 1;
238	;;
239	-h \| --h*)
240	cat <<\EOF
241	Usage: compile [--help] [--version] PROGRAM [ARGS]
242
243	Wrapper for compilers which do not understand '-c -o'.
244	Remove '-o dest.o' from ARGS, run PROGRAM with the remaining
245	arguments, and rename the output as expected.
246
247	If you are trying to build a whole package this is not the
248	right script to run: please start by reading the file 'INSTALL'.
249
250	Report bugs to <bug-automake@gnu.org>.
251	EOF
252	exit $?
253	;;
254	-v \| --v*)
255	echo "compile $scriptversion"
256	exit $?
257	;;
258	cl \| [/\\]cl \| cl.exe \| [/\\]cl.exe \| \
259	icl \| [/\\]icl \| icl.exe \| [/\\]icl.exe )
260	func_cl_wrapper "$@" # Doesn't return...
261	;;
262	esac
263
264	ofile=
265	cfile=
266
267	for arg
268	do
269	if test -n "$eat"; then
270	eat=
271	else
272	case $1 in
273	-o)
274	# configure might choose to run compile as 'compile cc -o foo foo.c'.
275	# So we strip '-o arg' only if arg is an object.
276	eat=1
277	case $2 in
278	.o \| .obj)
279	ofile=$2
280	;;
281	*)
282	set x "$@" -o "$2"
283	shift
284	;;
285	esac
286	;;
287	*.c)
288	cfile=$1
289	set x "$@" "$1"
290	shift
291	;;
292	*)
293	set x "$@" "$1"
294	shift
295	;;
296	esac
297	fi
298	shift
299	done
300
301	if test -z "$ofile" \|\| test -z "$cfile"; then
302	# If no '-o' option was seen then we might have been invoked from a
303	# pattern rule where we don't need one. That is ok -- this is a
304	# normal compilation that the losing compiler can handle. If no
305	# '.c' file was seen then we are probably linking. That is also
306	# ok.
307	exec "$@"
308	fi
309
310	# Name of file we expect compiler to create.
311	cofile=`echo "$cfile" \| sed 's\|^.*[\\/]\|\|; s\|^[a-zA-Z]:\|\|; s/\.c$/.o/'`
312
313	# Create the lock directory.
314	# Note: use '[/\\:.-]' here to ensure that we don't use the same name
315	# that we are using for the .o file. Also, base the name on the expected
316	# object file name, since that is what matters with a parallel build.
317	lockdir=`echo "$cofile" \| sed -e 's\|[/\\:.-]\|_\|g'`.d
318	while true; do
319	if mkdir "$lockdir" >/dev/null 2>&1; then
320	break
321	fi
322	sleep 1
323	done
324	# FIXME: race condition here if user kills between mkdir and trap.
325	trap "rmdir '$lockdir'; exit 1" 1 2 15
326
327	# Run the compile.
328	"$@"
329	ret=$?
330
331	if test -f "$cofile"; then
332	test "$cofile" = "$ofile" \|\| mv "$cofile" "$ofile"
333	elif test -f "${cofile}bj"; then
334	test "${cofile}bj" = "$ofile" \|\| mv "${cofile}bj" "$ofile"
335	fi
336
337	rmdir "$lockdir"
338	exit $ret
339
340	# Local Variables:
341	# mode: shell-script
342	# sh-indentation: 2
343	# eval: (add-hook 'before-save-hook 'time-stamp)
344	# time-stamp-start: "scriptversion="
345	# time-stamp-format: "%:y-%02m-%02d.%02H"
346	# time-stamp-time-zone: "UTC0"
347	# time-stamp-end: "; # UTC"
348	# End:

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/aux/install-sh (+518 lines)
		1	#!/bin/sh
		2	# install - install a program, script, or datafile
		3
		4	scriptversion=2018-03-11.20; # UTC
		5
		6	# This originates from X11R5 (mit/util/scripts/install.sh), which was
		7	# later released in X11R6 (xc/config/util/install.sh) with the
		8	# following copyright and license.
		9	#
		10	# Copyright (C) 1994 X Consortium
		11	#
		12	# Permission is hereby granted, free of charge, to any person obtaining a copy
		13	# of this software and associated documentation files (the "Software"), to
		14	# deal in the Software without restriction, including without limitation the
		15	# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
		16	# sell copies of the Software, and to permit persons to whom the Software is
		17	# furnished to do so, subject to the following conditions:
		18	#
		19	# The above copyright notice and this permission notice shall be included in
		20	# all copies or substantial portions of the Software.
		21	#
		22	# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		23	# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		24	# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
		25	# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
		26	# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
		27	# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
		28	#
		29	# Except as contained in this notice, the name of the X Consortium shall not
		30	# be used in advertising or otherwise to promote the sale, use or other deal-
		31	# ings in this Software without prior written authorization from the X Consor-
		32	# tium.
		33	#
		34	#
		35	# FSF changes to this file are in the public domain.
		36	#
		37	# Calling this script install-sh is preferred over install.sh, to prevent
		38	# 'make' implicit rules from creating a file called install from it
		39	# when there is no Makefile.
		40	#
		41	# This script is compatible with the BSD install script, but was written
		42	# from scratch.
		43
		44	tab=' '
		45	nl='
		46	'
		47	IFS=" $tab$nl"
		48
		49	# Set DOITPROG to "echo" to test this script.
		50
		51	doit=${DOITPROG-}
		52	doit_exec=${doit:-exec}
		53
		54	# Put in absolute file names if you don't have them in your path;
		55	# or use environment vars.
		56
		57	chgrpprog=${CHGRPPROG-chgrp}
		58	chmodprog=${CHMODPROG-chmod}
		59	chownprog=${CHOWNPROG-chown}
		60	cmpprog=${CMPPROG-cmp}
		61	cpprog=${CPPROG-cp}
		62	mkdirprog=${MKDIRPROG-mkdir}
		63	mvprog=${MVPROG-mv}
		64	rmprog=${RMPROG-rm}
65	stripprog=${STRIPPROG-strip}
66
67	posix_mkdir=
68
69	# Desired mode of installed file.
70	mode=0755
71
72	chgrpcmd=
73	chmodcmd=$chmodprog
74	chowncmd=
75	mvcmd=$mvprog
76	rmcmd="$rmprog -f"
77	stripcmd=
78
79	src=
80	dst=
81	dir_arg=
82	dst_arg=
83
84	copy_on_change=false
85	is_target_a_directory=possibly
86
87	usage="\
88	Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
89	or: $0 [OPTION]... SRCFILES... DIRECTORY
90	or: $0 [OPTION]... -t DIRECTORY SRCFILES...
91	or: $0 [OPTION]... -d DIRECTORIES...
92
93	In the 1st form, copy SRCFILE to DSTFILE.
94	In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
95	In the 4th, create DIRECTORIES.
96
97	Options:
98	--help display this help and exit.
99	--version display version info and exit.
100
101	-c (ignored)
102	-C install only if different (preserve the last data modification time)
103	-d create directories instead of installing files.
104	-g GROUP $chgrpprog installed files to GROUP.
105	-m MODE $chmodprog installed files to MODE.
106	-o USER $chownprog installed files to USER.
107	-s $stripprog installed files.
108	-t DIRECTORY install into DIRECTORY.
109	-T report an error if DSTFILE is a directory.
110
111	Environment variables override the default commands:
112	CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
113	RMPROG STRIPPROG
114	"
115
116	while test $# -ne 0; do
117	case $1 in
118	-c) ;;
119
120	-C) copy_on_change=true;;
121
122	-d) dir_arg=true;;
123
124	-g) chgrpcmd="$chgrpprog $2"
125	shift;;
126
127	--help) echo "$usage"; exit $?;;
128
129	-m) mode=$2
130	case $mode in
131	' ' \| "$tab" \| "$nl" \| ''* \| '?' \| '[')
132	echo "$0: invalid mode: $mode" >&2
133	exit 1;;
134	esac
135	shift;;
136
137	-o) chowncmd="$chownprog $2"
138	shift;;
139
140	-s) stripcmd=$stripprog;;
141
142	-t)
143	is_target_a_directory=always
144	dst_arg=$2
145	# Protect names problematic for 'test' and other utilities.
146	case $dst_arg in
147	-* \| [=\(\)!]) dst_arg=./$dst_arg;;
148	esac
149	shift;;
150
151	-T) is_target_a_directory=never;;
152
153	--version) echo "$0 $scriptversion"; exit $?;;
154
155	--) shift
156	break;;
157
158	-*) echo "$0: invalid option: $1" >&2
159	exit 1;;
160
161	*) break;;
162	esac
163	shift
164	done
165
166	# We allow the use of options -d and -T together, by making -d
167	# take the precedence; this is for compatibility with GNU install.
168
169	if test -n "$dir_arg"; then
170	if test -n "$dst_arg"; then
171	echo "$0: target directory not allowed when installing a directory." >&2
172	exit 1
173	fi
174	fi
175
176	if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
177	# When -d is used, all remaining arguments are directories to create.
178	# When -t is used, the destination is already specified.
179	# Otherwise, the last argument is the destination. Remove it from $@.
180	for arg
181	do
182	if test -n "$dst_arg"; then
183	# $@ is not empty: it contains at least $arg.
184	set fnord "$@" "$dst_arg"
185	shift # fnord
186	fi
187	shift # arg
188	dst_arg=$arg
189	# Protect names problematic for 'test' and other utilities.
190	case $dst_arg in
191	-* \| [=\(\)!]) dst_arg=./$dst_arg;;
192	esac
193	done
194	fi
195
196	if test $# -eq 0; then
197	if test -z "$dir_arg"; then
198	echo "$0: no input file specified." >&2
199	exit 1
200	fi
201	# It's OK to call 'install-sh -d' without argument.
202	# This can happen when creating conditional directories.
203	exit 0
204	fi
205
206	if test -z "$dir_arg"; then
207	if test $# -gt 1 \|\| test "$is_target_a_directory" = always; then
208	if test ! -d "$dst_arg"; then
209	echo "$0: $dst_arg: Is not a directory." >&2
210	exit 1
211	fi
212	fi
213	fi
214
215	if test -z "$dir_arg"; then
216	do_exit='(exit $ret); exit $ret'
217	trap "ret=129; $do_exit" 1
218	trap "ret=130; $do_exit" 2
219	trap "ret=141; $do_exit" 13
220	trap "ret=143; $do_exit" 15
221
222	# Set umask so as not to create temps with too-generous modes.
223	# However, 'strip' requires both read and write access to temps.
224	case $mode in
225	# Optimize common cases.
226	*644) cp_umask=133;;
227	*755) cp_umask=22;;
228
229	*[0-7])
230	if test -z "$stripcmd"; then
231	u_plus_rw=
232	else
233	u_plus_rw='% 200'
234	fi
235	cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
236	*)
237	if test -z "$stripcmd"; then
238	u_plus_rw=
239	else
240	u_plus_rw=,u+rw
241	fi
242	cp_umask=$mode$u_plus_rw;;
243	esac
244	fi
245
246	for src
247	do
248	# Protect names problematic for 'test' and other utilities.
249	case $src in
250	-* \| [=\(\)!]) src=./$src;;
251	esac
252
253	if test -n "$dir_arg"; then
254	dst=$src
255	dstdir=$dst
256	test -d "$dstdir"
257	dstdir_status=$?
258	else
259
260	# Waiting for this to be detected by the "$cpprog $src $dsttmp" command
261	# might cause directories to be created, which would be especially bad
262	# if $src (and thus $dsttmp) contains '*'.
263	if test ! -f "$src" && test ! -d "$src"; then
264	echo "$0: $src does not exist." >&2
265	exit 1
266	fi
267
268	if test -z "$dst_arg"; then
269	echo "$0: no destination specified." >&2
270	exit 1
271	fi
272	dst=$dst_arg
273
274	# If destination is a directory, append the input filename.
275	if test -d "$dst"; then
276	if test "$is_target_a_directory" = never; then
277	echo "$0: $dst_arg: Is a directory" >&2
278	exit 1
279	fi
280	dstdir=$dst
281	dstbase=`basename "$src"`
282	case $dst in
283	*/) dst=$dst$dstbase;;
284	*) dst=$dst/$dstbase;;
285	esac
286	dstdir_status=0
287	else
288	dstdir=`dirname "$dst"`
289	test -d "$dstdir"
290	dstdir_status=$?
291	fi
292	fi
293
294	case $dstdir in
295	*/) dstdirslash=$dstdir;;
296	*) dstdirslash=$dstdir/;;
297	esac
298
299	obsolete_mkdir_used=false
300
301	if test $dstdir_status != 0; then
302	case $posix_mkdir in
303	'')
304	# Create intermediate dirs using mode 755 as modified by the umask.
305	# This is like FreeBSD 'install' as of 1997-10-28.
306	umask=`umask`
307	case $stripcmd.$umask in
308	# Optimize common cases.
309	*[2367][2367]) mkdir_umask=$umask;;
310	.*0[02][02] \| .[02][02] \| .[02]) mkdir_umask=22;;
311
312	*[0-7])
313	mkdir_umask=`expr $umask + 22 \
314	- $umask % 100 % 40 + $umask % 20 \
315	- $umask % 10 % 4 + $umask % 2
316	`;;
317	*) mkdir_umask=$umask,go-w;;
318	esac
319
320	# With -d, create the new directory with the user-specified mode.
321	# Otherwise, rely on $mkdir_umask.
322	if test -n "$dir_arg"; then
323	mkdir_mode=-m$mode
324	else
325	mkdir_mode=
326	fi
327
328	posix_mkdir=false
329	case $umask in
330	*[123567][0-7][0-7])
331	# POSIX mkdir -p sets u+wx bits regardless of umask, which
332	# is incompatible with FreeBSD 'install' when (umask & 300) != 0.
333	;;
334	*)
335	# Note that $RANDOM variable is not portable (e.g. dash); Use it
336	# here however when possible just to lower collision chance.
337	tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
338
339	trap 'ret=$?; rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null; exit $ret' 0
340
341	# Because "mkdir -p" follows existing symlinks and we likely work
342	# directly in world-writeable /tmp, make sure that the '$tmpdir'
343	# directory is successfully created first before we actually test
344	# 'mkdir -p' feature.
345	if (umask $mkdir_umask &&
346	$mkdirprog $mkdir_mode "$tmpdir" &&
347	exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1
348	then
349	if test -z "$dir_arg" \|\| {
350	# Check for POSIX incompatibilities with -m.
351	# HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
352	# other-writable bit of parent directory when it shouldn't.
353	# FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
354	test_tmpdir="$tmpdir/a"
355	ls_ld_tmpdir=`ls -ld "$test_tmpdir"`
356	case $ls_ld_tmpdir in
357	d????-?r-*) different_mode=700;;
358	d????-?--*) different_mode=755;;
359	*) false;;
360	esac &&
361	$mkdirprog -m$different_mode -p -- "$test_tmpdir" && {
362	ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"`
363	test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
364	}
365	}
366	then posix_mkdir=:
367	fi
368	rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir"
369	else
370	# Remove any dirs left behind by ancient mkdir implementations.
371	rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null
372	fi
373	trap '' 0;;
374	esac;;
375	esac
376
377	if
378	$posix_mkdir && (
379	umask $mkdir_umask &&
380	$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
381	)
382	then :
383	else
384
385	# The umask is ridiculous, or mkdir does not conform to POSIX,
386	# or it failed possibly due to a race condition. Create the
387	# directory the slow way, step by step, checking for races as we go.
388
389	case $dstdir in
390	/*) prefix='/';;
391	[-=\(\)!]*) prefix='./';;
392	*) prefix='';;
393	esac
394
395	oIFS=$IFS
396	IFS=/
397	set -f
398	set fnord $dstdir
399	shift
400	set +f
401	IFS=$oIFS
402
403	prefixes=
404
405	for d
406	do
407	test X"$d" = X && continue
408
409	prefix=$prefix$d
410	if test -d "$prefix"; then
411	prefixes=
412	else
413	if $posix_mkdir; then
414	(umask=$mkdir_umask &&
415	$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
416	# Don't fail if two instances are running concurrently.
417	test -d "$prefix" \|\| exit 1
418	else
419	case $prefix in
420	\') qprefix=`echo "$prefix" \| sed "s/'/'\\\\\\\\''/g"`;;
421	*) qprefix=$prefix;;
422	esac
423	prefixes="$prefixes '$qprefix'"
424	fi
425	fi
426	prefix=$prefix/
427	done
428
429	if test -n "$prefixes"; then
430	# Don't fail if two instances are running concurrently.
431	(umask $mkdir_umask &&
432	eval "\$doit_exec \$mkdirprog $prefixes") \|\|
433	test -d "$dstdir" \|\| exit 1
434	obsolete_mkdir_used=true
435	fi
436	fi
437	fi
438
439	if test -n "$dir_arg"; then
440	{ test -z "$chowncmd" \|\| $doit $chowncmd "$dst"; } &&
441	{ test -z "$chgrpcmd" \|\| $doit $chgrpcmd "$dst"; } &&
442	{ test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false \|\|
443	test -z "$chmodcmd" \|\| $doit $chmodcmd $mode "$dst"; } \|\| exit 1
444	else
445
446	# Make a couple of temp file names in the proper directory.
447	dsttmp=${dstdirslash}_inst.$$_
448	rmtmp=${dstdirslash}_rm.$$_
449
450	# Trap to clean up those temp files at exit.
451	trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
452
453	# Copy the file name to the temp name.
454	(umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
455
456	# and set any options; do chmod last to preserve setuid bits.
457	#
458	# If any of these fail, we abort the whole thing. If we want to
459	# ignore errors from any of these, just make sure not to ignore
460	# errors from the above "$doit $cpprog $src $dsttmp" command.
461	#
462	{ test -z "$chowncmd" \|\| $doit $chowncmd "$dsttmp"; } &&
463	{ test -z "$chgrpcmd" \|\| $doit $chgrpcmd "$dsttmp"; } &&
464	{ test -z "$stripcmd" \|\| $doit $stripcmd "$dsttmp"; } &&
465	{ test -z "$chmodcmd" \|\| $doit $chmodcmd $mode "$dsttmp"; } &&
466
467	# If -C, don't bother to copy if it wouldn't change the file.
468	if $copy_on_change &&
469	old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` &&
470	new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` &&
471	set -f &&
472	set X $old && old=:$2:$4:$5:$6 &&
473	set X $new && new=:$2:$4:$5:$6 &&
474	set +f &&
475	test "$old" = "$new" &&
476	$cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
477	then
478	rm -f "$dsttmp"
479	else
480	# Rename the file to the real destination.
481	$doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null \|\|
482
483	# The rename failed, perhaps because mv can't rename something else
484	# to itself, or perhaps because mv is so ancient that it does not
485	# support -f.
486	{
487	# Now remove or move aside any old file at destination location.
488	# We try this two ways since rm can't unlink itself on some
489	# systems and the destination file might be busy for other
490	# reasons. In this case, the final cleanup might fail but the new
491	# file should still install successfully.
492	{
493	test ! -f "$dst" \|\|
494	$doit $rmcmd -f "$dst" 2>/dev/null \|\|
495	{ $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
496	{ $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
497	} \|\|
498	{ echo "$0: cannot unlink or rename $dst" >&2
499	(exit 1); exit 1
500	}
501	} &&
502
503	# Now rename the file to the real destination.
504	$doit $mvcmd "$dsttmp" "$dst"
505	}
506	fi \|\| exit 1
507
508	trap '' 0
509	fi
510	done
511
512	# Local variables:
513	# eval: (add-hook 'before-save-hook 'time-stamp)
514	# time-stamp-start: "scriptversion="
515	# time-stamp-format: "%:y-%02m-%02d.%02H"
516	# time-stamp-time-zone: "UTC0"
517	# time-stamp-end: "; # UTC"
518	# End:

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/aux/missing (+215 lines)
		1	#! /bin/sh
		2	# Common wrapper for a few potentially missing GNU programs.
		3
		4	scriptversion=2018-03-07.03; # UTC
		5
		6	# Copyright (C) 1996-2018 Free Software Foundation, Inc.
		7	# Originally written by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
		8
		9	# This program is free software; you can redistribute it and/or modify
		10	# it under the terms of the GNU General Public License as published by
		11	# the Free Software Foundation; either version 2, or (at your option)
		12	# any later version.
		13
		14	# This program is distributed in the hope that it will be useful,
		15	# but WITHOUT ANY WARRANTY; without even the implied warranty of
		16	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		17	# GNU General Public License for more details.
		18
		19	# You should have received a copy of the GNU General Public License
		20	# along with this program. If not, see <https://www.gnu.org/licenses/>.
		21
		22	# As a special exception to the GNU General Public License, if you
		23	# distribute this file as part of a program that contains a
		24	# configuration script generated by Autoconf, you may include it under
		25	# the same distribution terms that you use for the rest of that program.
		26
		27	if test $# -eq 0; then
		28	echo 1>&2 "Try '$0 --help' for more information"
		29	exit 1
		30	fi
		31
		32	case $1 in
		33
		34	--is-lightweight)
		35	# Used by our autoconf macros to check whether the available missing
		36	# script is modern enough.
		37	exit 0
		38	;;
		39
		40	--run)
		41	# Back-compat with the calling convention used by older automake.
		42	shift
		43	;;
		44
		45	-h\|--h\|--he\|--hel\|--help)
		46	echo "\
		47	$0 [OPTION]... PROGRAM [ARGUMENT]...
		48
		49	Run 'PROGRAM [ARGUMENT]...', returning a proper advice when this fails due
		50	to PROGRAM being missing or too old.
		51
		52	Options:
		53	-h, --help display this help and exit
		54	-v, --version output version information and exit
		55
		56	Supported PROGRAM values:
		57	aclocal autoconf autoheader autom4te automake makeinfo
		58	bison yacc flex lex help2man
		59
		60	Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and
		61	'g' are ignored when checking the name.
		62
		63	Send bug reports to <bug-automake@gnu.org>."
		64	exit $?
65	;;
66
67	-v\|--v\|--ve\|--ver\|--vers\|--versi\|--versio\|--version)
68	echo "missing $scriptversion (GNU Automake)"
69	exit $?
70	;;
71
72	-*)
73	echo 1>&2 "$0: unknown '$1' option"
74	echo 1>&2 "Try '$0 --help' for more information"
75	exit 1
76	;;
77
78	esac
79
80	# Run the given program, remember its exit status.
81	"$@"; st=$?
82
83	# If it succeeded, we are done.
84	test $st -eq 0 && exit 0
85
86	# Also exit now if we it failed (or wasn't found), and '--version' was
87	# passed; such an option is passed most likely to detect whether the
88	# program is present and works.
89	case $2 in --version\|--help) exit $st;; esac
90
91	# Exit code 63 means version mismatch. This often happens when the user
92	# tries to use an ancient version of a tool on a file that requires a
93	# minimum version.
94	if test $st -eq 63; then
95	msg="probably too old"
96	elif test $st -eq 127; then
97	# Program was missing.
98	msg="missing on your system"
99	else
100	# Program was found and executed, but failed. Give up.
101	exit $st
102	fi
103
104	perl_URL=https://www.perl.org/
105	flex_URL=https://github.com/westes/flex
106	gnu_software_URL=https://www.gnu.org/software
107
108	program_details ()
109	{
110	case $1 in
111	aclocal\|automake)
112	echo "The '$1' program is part of the GNU Automake package:"
113	echo "<$gnu_software_URL/automake>"
114	echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:"
115	echo "<$gnu_software_URL/autoconf>"
116	echo "<$gnu_software_URL/m4/>"
117	echo "<$perl_URL>"
118	;;
119	autoconf\|autom4te\|autoheader)
120	echo "The '$1' program is part of the GNU Autoconf package:"
121	echo "<$gnu_software_URL/autoconf/>"
122	echo "It also requires GNU m4 and Perl in order to run:"
123	echo "<$gnu_software_URL/m4/>"
124	echo "<$perl_URL>"
125	;;
126	esac
127	}
128
129	give_advice ()
130	{
131	# Normalize program name to check for.
132	normalized_program=`echo "$1" \| sed '
133	s/^gnu-//; t
134	s/^gnu//; t
135	s/^g//; t'`
136
137	printf '%s\n' "'$1' is $msg."
138
139	configure_deps="'configure.ac' or m4 files included by 'configure.ac'"
140	case $normalized_program in
141	autoconf*)
142	echo "You should only need it if you modified 'configure.ac',"
143	echo "or m4 files included by it."
144	program_details 'autoconf'
145	;;
146	autoheader*)
147	echo "You should only need it if you modified 'acconfig.h' or"
148	echo "$configure_deps."
149	program_details 'autoheader'
150	;;
151	automake*)
152	echo "You should only need it if you modified 'Makefile.am' or"
153	echo "$configure_deps."
154	program_details 'automake'
155	;;
156	aclocal*)
157	echo "You should only need it if you modified 'acinclude.m4' or"
158	echo "$configure_deps."
159	program_details 'aclocal'
160	;;
161	autom4te*)
162	echo "You might have modified some maintainer files that require"
163	echo "the 'autom4te' program to be rebuilt."
164	program_details 'autom4te'
165	;;
166	bison\|yacc)
167	echo "You should only need it if you modified a '.y' file."
168	echo "You may want to install the GNU Bison package:"
169	echo "<$gnu_software_URL/bison/>"
170	;;
171	lex\|flex)
172	echo "You should only need it if you modified a '.l' file."
173	echo "You may want to install the Fast Lexical Analyzer package:"
174	echo "<$flex_URL>"
175	;;
176	help2man*)
177	echo "You should only need it if you modified a dependency" \
178	"of a man page."
179	echo "You may want to install the GNU Help2man package:"
180	echo "<$gnu_software_URL/help2man/>"
181	;;
182	makeinfo*)
183	echo "You should only need it if you modified a '.texi' file, or"
184	echo "any other file indirectly affecting the aspect of the manual."
185	echo "You might want to install the Texinfo package:"
186	echo "<$gnu_software_URL/texinfo/>"
187	echo "The spurious makeinfo call might also be the consequence of"
188	echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might"
189	echo "want to install GNU make:"
190	echo "<$gnu_software_URL/make/>"
191	;;
192	*)
193	echo "You might have modified some files without having the proper"
194	echo "tools for further handling them. Check the 'README' file, it"
195	echo "often tells you about the needed prerequisites for installing"
196	echo "this package. You may also peek at any GNU archive site, in"
197	echo "case some other package contains this missing '$1' program."
198	;;
199	esac
200	}
201
202	give_advice "$1" \| sed -e '1s/^/WARNING: /' \
203	-e '2,$s/^/ /' >&2
204
205	# Propagate the correct exit status (expected to be 127 for a program
206	# not found, 63 for a program that failed due to version mismatch).
207	exit $st
208
209	# Local variables:
210	# eval: (add-hook 'before-save-hook 'time-stamp)
211	# time-stamp-start: "scriptversion="
212	# time-stamp-format: "%:y-%02m-%02d.%02H"
213	# time-stamp-time-zone: "UTC0"
214	# time-stamp-end: "; # UTC"
215	# End:

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/config.h (+136 lines)
		1	/* config.h. Generated from config.h.in by configure. */
		2	/* config.h.in. Generated from configure.ac by autoheader. */
		3
		4	/* Define to 1 if you have the <arpa/inet.h> header file. */
		5	#define HAVE_ARPA_INET_H 1
		6
		7	/* Define to 1 if you have the `dup2' function. */
		8	#define HAVE_DUP2 1
		9
		10	/* Define to 1 if you have the <fcntl.h> header file. */
		11	#define HAVE_FCNTL_H 1
		12
		13	/* Define to 1 if you have the `fork' function. */
		14	#define HAVE_FORK 1
		15
		16	/* Define to 1 if you have the <inttypes.h> header file. */
		17	#define HAVE_INTTYPES_H 1
		18
		19	/* Define to 1 if you have the `nsl' library (-lnsl). */
		20	/* #undef HAVE_LIBNSL */
		21
		22	/* Define to 1 if you have the `pthread' library (-lpthread). */
		23	#define HAVE_LIBPTHREAD 1
		24
		25	/* Define to 1 if you have the `socket' library (-lsocket). */
		26	/* #undef HAVE_LIBSOCKET */
		27
		28	/* Define to 1 if your system has a GNU libc compatible `malloc' function, and
		29	to 0 otherwise. */
		30	#define HAVE_MALLOC 1
		31
		32	/* Define to 1 if you have the <memory.h> header file. */
		33	#define HAVE_MEMORY_H 1
		34
		35	/* Define to 1 if you have the `memset' function. */
		36	#define HAVE_MEMSET 1
		37
		38	/* Define to 1 if you have the <netdb.h> header file. */
		39	#define HAVE_NETDB_H 1
		40
		41	/* Define to 1 if you have the <netinet/in.h> header file. */
		42	#define HAVE_NETINET_IN_H 1
		43
		44	/* Define to 1 if your system has a GNU libc compatible `realloc' function,
		45	and to 0 otherwise. */
		46	#define HAVE_REALLOC 1
		47
		48	/* Define to 1 if you have the `socket' function. */
		49	#define HAVE_SOCKET 1
		50
		51	/* Define to 1 if you have the <stdint.h> header file. */
		52	#define HAVE_STDINT_H 1
		53
		54	/* Define to 1 if you have the <stdlib.h> header file. */
		55	#define HAVE_STDLIB_H 1
		56
		57	/* Define to 1 if you have the `strchr' function. */
		58	#define HAVE_STRCHR 1
		59
		60	/* Define to 1 if you have the `strdup' function. */
		61	#define HAVE_STRDUP 1
		62
		63	/* Define to 1 if you have the `strerror' function. */
		64	#define HAVE_STRERROR 1
65
66	/* Define to 1 if you have the <strings.h> header file. */
67	#define HAVE_STRINGS_H 1
68
69	/* Define to 1 if you have the <string.h> header file. */
70	#define HAVE_STRING_H 1
71
72	/* Define to 1 if you have the <syslog.h> header file. */
73	#define HAVE_SYSLOG_H 1
74
75	/* Define to 1 if you have the <sys/socket.h> header file. */
76	#define HAVE_SYS_SOCKET_H 1
77
78	/* Define to 1 if you have the <sys/stat.h> header file. */
79	#define HAVE_SYS_STAT_H 1
80
81	/* Define to 1 if you have the <sys/types.h> header file. */
82	#define HAVE_SYS_TYPES_H 1
83
84	/* Define to 1 if you have the <unistd.h> header file. */
85	#define HAVE_UNISTD_H 1
86
87	/* Define to 1 if you have the `vfork' function. */
88	#define HAVE_VFORK 1
89
90	/* Define to 1 if you have the <vfork.h> header file. */
91	/* #undef HAVE_VFORK_H */
92
93	/* Define to 1 if `fork' works. */
94	#define HAVE_WORKING_FORK 1
95
96	/* Define to 1 if `vfork' works. */
97	#define HAVE_WORKING_VFORK 1
98
99	/* Define to the address where bug reports for this package should be sent. */
100	#define PACKAGE_BUGREPORT "pen@lysator.liu.se"
101
102	/* Define to the full name of this package. */
103	#define PACKAGE_NAME "pwol"
104
105	/* Define to the full name and version of this package. */
106	#define PACKAGE_STRING "pwol 1.5"
107
108	/* Define to the one symbol short name of this package. */
109	#define PACKAGE_TARNAME "pwol"
110
111	/* Define to the home page for this package. */
112	#define PACKAGE_URL "https://github.com/ptrrkssn/pwol"
113
114	/* Define to the version of this package. */
115	#define PACKAGE_VERSION "1.5"
116
117	/* Define to 1 if you have the ANSI C header files. */
118	#define STDC_HEADERS 1
119
120	/* Define to rpl_malloc if the replacement function should be used. */
121	/* #undef malloc */
122
123	/* Define to `int' if <sys/types.h> does not define. */
124	/* #undef pid_t */
125
126	/* Define to rpl_realloc if the replacement function should be used. */
127	/* #undef realloc */
128
129	/* Define to `unsigned int' if <sys/types.h> does not define. */
130	/* #undef size_t */
131
132	/* Define to `int' if <sys/types.h> does not define. */
133	/* #undef ssize_t */
134
135	/* Define as `fork' if `vfork' does not work. */
136	/* #undef vfork */

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/config.h.in (+135 lines)
		1	/* config.h.in. Generated from configure.ac by autoheader. */
		2
		3	/* Define to 1 if you have the <arpa/inet.h> header file. */
		4	#undef HAVE_ARPA_INET_H
		5
		6	/* Define to 1 if you have the `dup2' function. */
		7	#undef HAVE_DUP2
		8
		9	/* Define to 1 if you have the <fcntl.h> header file. */
		10	#undef HAVE_FCNTL_H
		11
		12	/* Define to 1 if you have the `fork' function. */
		13	#undef HAVE_FORK
		14
		15	/* Define to 1 if you have the <inttypes.h> header file. */
		16	#undef HAVE_INTTYPES_H
		17
		18	/* Define to 1 if you have the `nsl' library (-lnsl). */
		19	#undef HAVE_LIBNSL
		20
		21	/* Define to 1 if you have the `pthread' library (-lpthread). */
		22	#undef HAVE_LIBPTHREAD
		23
		24	/* Define to 1 if you have the `socket' library (-lsocket). */
		25	#undef HAVE_LIBSOCKET
		26
		27	/* Define to 1 if your system has a GNU libc compatible `malloc' function, and
		28	to 0 otherwise. */
		29	#undef HAVE_MALLOC
		30
		31	/* Define to 1 if you have the <memory.h> header file. */
		32	#undef HAVE_MEMORY_H
		33
		34	/* Define to 1 if you have the `memset' function. */
		35	#undef HAVE_MEMSET
		36
		37	/* Define to 1 if you have the <netdb.h> header file. */
		38	#undef HAVE_NETDB_H
		39
		40	/* Define to 1 if you have the <netinet/in.h> header file. */
		41	#undef HAVE_NETINET_IN_H
		42
		43	/* Define to 1 if your system has a GNU libc compatible `realloc' function,
		44	and to 0 otherwise. */
		45	#undef HAVE_REALLOC
		46
		47	/* Define to 1 if you have the `socket' function. */
		48	#undef HAVE_SOCKET
		49
		50	/* Define to 1 if you have the <stdint.h> header file. */
		51	#undef HAVE_STDINT_H
		52
		53	/* Define to 1 if you have the <stdlib.h> header file. */
		54	#undef HAVE_STDLIB_H
		55
		56	/* Define to 1 if you have the `strchr' function. */
		57	#undef HAVE_STRCHR
		58
		59	/* Define to 1 if you have the `strdup' function. */
		60	#undef HAVE_STRDUP
		61
		62	/* Define to 1 if you have the `strerror' function. */
		63	#undef HAVE_STRERROR
		64
65	/* Define to 1 if you have the <strings.h> header file. */
66	#undef HAVE_STRINGS_H
67
68	/* Define to 1 if you have the <string.h> header file. */
69	#undef HAVE_STRING_H
70
71	/* Define to 1 if you have the <syslog.h> header file. */
72	#undef HAVE_SYSLOG_H
73
74	/* Define to 1 if you have the <sys/socket.h> header file. */
75	#undef HAVE_SYS_SOCKET_H
76
77	/* Define to 1 if you have the <sys/stat.h> header file. */
78	#undef HAVE_SYS_STAT_H
79
80	/* Define to 1 if you have the <sys/types.h> header file. */
81	#undef HAVE_SYS_TYPES_H
82
83	/* Define to 1 if you have the <unistd.h> header file. */
84	#undef HAVE_UNISTD_H
85
86	/* Define to 1 if you have the `vfork' function. */
87	#undef HAVE_VFORK
88
89	/* Define to 1 if you have the <vfork.h> header file. */
90	#undef HAVE_VFORK_H
91
92	/* Define to 1 if `fork' works. */
93	#undef HAVE_WORKING_FORK
94
95	/* Define to 1 if `vfork' works. */
96	#undef HAVE_WORKING_VFORK
97
98	/* Define to the address where bug reports for this package should be sent. */
99	#undef PACKAGE_BUGREPORT
100
101	/* Define to the full name of this package. */
102	#undef PACKAGE_NAME
103
104	/* Define to the full name and version of this package. */
105	#undef PACKAGE_STRING
106
107	/* Define to the one symbol short name of this package. */
108	#undef PACKAGE_TARNAME
109
110	/* Define to the home page for this package. */
111	#undef PACKAGE_URL
112
113	/* Define to the version of this package. */
114	#undef PACKAGE_VERSION
115
116	/* Define to 1 if you have the ANSI C header files. */
117	#undef STDC_HEADERS
118
119	/* Define to rpl_malloc if the replacement function should be used. */
120	#undef malloc
121
122	/* Define to `int' if <sys/types.h> does not define. */
123	#undef pid_t
124
125	/* Define to rpl_realloc if the replacement function should be used. */
126	#undef realloc
127
128	/* Define to `unsigned int' if <sys/types.h> does not define. */
129	#undef size_t
130
131	/* Define to `int' if <sys/types.h> does not define. */
132	#undef ssize_t
133
134	/* Define as `fork' if `vfork' does not work. */
135	#undef vfork

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/configure.ac (+37 lines)
	1	# -- Autoconf --
	2	# Process this file with autoconf to produce a configure script.
	3
	4	AC_PREREQ([2.69])
	5	AC_INIT([pwol], [1.5], [pen@lysator.liu.se], [pwol], [https://github.com/ptrrkssn/pwol])
	6
	7	AC_CONFIG_SRCDIR([pwol.c])
	8	AC_CONFIG_HEADERS([config.h])
	9
	10	AC_CONFIG_AUX_DIR([aux])
	11
	12	# Checks for programs.
	13	AC_PROG_CC
	14	AC_PROG_INSTALL
	15	AC_PROG_MAKE_SET
	16
	17	# Checks for libraries.
	18	AC_CHECK_LIB([pthread], [pthread_create])
	19	AC_CHECK_LIB([socket], [connect])
	20	AC_CHECK_LIB([nsl], [gethostbyname])
	21
	22	# Checks for header files.
	23	AC_CHECK_HEADERS([arpa/inet.h fcntl.h netdb.h netinet/in.h stdlib.h string.h sys/socket.h syslog.h unistd.h])
	24
	25	# Checks for typedefs, structures, and compiler characteristics.
	26	AC_TYPE_PID_T
	27	AC_TYPE_SIZE_T
	28	AC_TYPE_SSIZE_T
	29
	30	# Checks for library functions.
	31	AC_FUNC_FORK
	32	AC_FUNC_MALLOC
	33	AC_FUNC_REALLOC
	34	AC_CHECK_FUNCS([dup2 memset socket strchr strdup strerror])
	35
	36	AC_CONFIG_FILES([Makefile pwol.1 pwol.conf.5 pkgs/Makefile.port])
	37	AC_OUTPUT

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/LICENSE (+29 lines)
	1	BSD 3-Clause License
	2
	3	Copyright (c) 2017, Peter Eriksson <pen@lysator.liu.se>
	4	All rights reserved.
	5
	6	Redistribution and use in source and binary forms, with or without
	7	modification, are permitted provided that the following conditions are met:
	8
	9	* Redistributions of source code must retain the above copyright notice, this
	10	list of conditions and the following disclaimer.
	11
	12	* Redistributions in binary form must reproduce the above copyright notice,
	13	this list of conditions and the following disclaimer in the documentation
	14	and/or other materials provided with the distribution.
	15
	16	* Neither the name of the copyright holder nor the names of its
	17	contributors may be used to endorse or promote products derived from
	18	this software without specific prior written permission.
	19
	20	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	21	AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	22	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	23	DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	24	FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	25	DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	26	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	27	CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	28	OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	29	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/Makefile (+140 lines)
		1	# Makefile.in for pwol
		2	#
		3	# Makefile. Generated from Makefile.in by configure.
		4
		5
		6	# Some 'make' variants does not include CPPFLAGS when compiling, some do
		7	.c.o:
		8	$(CC) $(CPPFLAGS) $(CFLAGS) -c -o $@ $<
		9
		10
		11
		12	srcdir = .
		13
		14
		15	DESTDIR =
		16
		17	prefix = /usr/local
		18	exec_prefix = ${prefix}
		19	datarootdir = ${prefix}/share
		20	sysconfdir = ${prefix}/etc
		21
		22	bindir = ${exec_prefix}/bin
		23	mandir = /usr/local/man
		24	man1dir = ${mandir}/man1
		25	man5dir = ${mandir}/man5
		26	man8dir = ${mandir}/man8
		27
		28	CC = cc
		29	INSTALL = /usr/bin/install -c
		30	TAR = tar
		31
		32	PACKAGE = pwol
		33	VERSION = 1.5
		34
		35	CPPFLAGS = -I. -I${srcdir} -DPATH_CONFIG="\"$(sysconfdir)/pwol.conf\""
		36	CFLAGS = -O2 -pipe -fstack-protector-strong -fno-strict-aliasing -Wall
		37	LDFLAGS = -fstack-protector-strong
		38	LIBS = -lpthread
		39
		40	VALGRIND = valgrind
		41	VALGRINDFLAGS = --leak-check=full --track-origins=yes --error-exitcode=1 # --show-leak-kinds=all
		42
		43	BINS = pwol
		44	OBJS = pwol.o
		45
		46	all: $(BINS) Makefile
		47
		48	Makefile: Makefile.in config.status
		49	./config.status
		50
		51	config.h: config.h.in config.status
		52	./config.status
		53
		54	pwol.o: pwol.c
		55
		56	pwol: $(OBJS)
		57	$(CC) $(LDFLAGS) -o pwol $(OBJS) $(LIBS)
		58
		59	# Clean targets
		60	maintainer-clean: distclean
		61	rm -f configure config.h.in
		62
		63	distclean: clean
		64	rm -fr config.status config.log stamp-h1 .deps autom4te.cache Makefile config.h *.tar.gz
65
66	clean mostlyclean:
67	-rm -f ~ \# .o $(BINS) core .core vgcore.*
68
69
70	# Git targets
71	push: distclean
72	git add -A && git commit -a && git push
73
74	pull:
75	git pull
76
77
78	# Install targets
79	install-all install: install-bin install-man install-conf
80
81	install-bin: $(BINS)
82	$(INSTALL) -d $(DESTDIR)$(bindir)
83	$(INSTALL) -c $(BINS) $(DESTDIR)$(bindir)
84
85	install-man: pwol.1 pwol.conf.5
86	$(INSTALL) -d "$(DESTDIR)$(man1dir)"
87	$(INSTALL) -c -m 644 pwol.1 "$(DESTDIR)$(man1dir)" && \
88	gzip -f "$(DESTDIR)$(man1dir)/pwol.1"
89	$(INSTALL) -d "$(DESTDIR)$(man5dir)"
90	$(INSTALL) -c -m 644 pwol.conf.5 "$(DESTDIR)$(man5dir)" && \
91	gzip -f "$(DESTDIR)$(man5dir)/pwol.conf.5"
92
93	install-conf: pwol.conf
94	$(INSTALL) -c -m 644 pwol.conf "$(DESTDIR)$(sysconfdir)/pwol.conf.sample"
95
96
97	uninstall-all uninstall: uninstall-bin uninstall-man
98
99	uninstall-bin:
100	rm -f "$(DESTDIR)$(bindir)/pwol"
101
102	uninstall-man:
103	rm -f "$(DESTDIR)$(man1dir)/pwol.1.gz" "$(DESTDIR)$(man1dir)/pwol.1"
104	rm -f "$(DESTDIR)$(man5dir)/pwol.conf.5.gz" "$(DESTDIR)$(man5dir)/pwol.conf.5"
105	rm -f "$(DESTDIR)$(sysconfdir)/pwol.conf.sample"
106
107
108	# Check targets
109	check:
110	@echo "Nothing to check for now."
111
112
113	DISTCHECKDIR=/tmp/distcheck-$(PACKAGE)-$(VERSION)
114
115	distcheck: $(PACKAGE)-$(VERSION).tar.gz
116	@if test -d "$(DISTCHECKDIR)"; then \
117	chmod -R +w "$(DISTCHECKDIR)" && rm -fr "$(DISTCHECKDIR)"; \
118	fi;
119	mkdir -p "$(DISTCHECKDIR)" && \
120	gunzip <"$(PACKAGE)-$(VERSION).tar.gz" \| \
121	(cd "$(DISTCHECKDIR)" && $(TAR) xf - && \
122	chmod -R -w "$(PACKAGE)-$(VERSION)" && \
123	mkdir b && cd b && ../$(PACKAGE)-$(VERSION)/configure && \
124	$(MAKE) && $(MAKE) -s check) && echo "*** distcheck: OK"
125	@chmod -R +w "$(DISTCHECKDIR)" && rm -fr "$(DISTCHECKDIR)";
126
127
128	DISTDIR=/tmp/build-$(PACKAGE)-$(VERSION)
129
130	dist: $(PACKAGE)-$(VERSION).tar.gz
131
132	$(PACKAGE)-$(VERSION).tar.gz: Makefile
133	rm -fr "$(DISTDIR)" && mkdir -p "$(DISTDIR)/$(PACKAGE)-$(VERSION)" && \
134	cp -r * "$(DISTDIR)/$(PACKAGE)-$(VERSION)" && \
135	(cd "$(DISTDIR)/$(PACKAGE)-$(VERSION)" && $(MAKE) distclean)
136	(cd "$(DISTDIR)" && $(TAR) cvf - "$(PACKAGE)-$(VERSION)") \| gzip >"$(PACKAGE)-$(VERSION)".tar.gz
137	echo rm -fr "$(DISTDIR)"
138	@echo ""
139	@echo "*** $(PACKAGE)-$(VERSION).tar.gz created"
140

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/Makefile.in (+140 lines)
		1	# Makefile.in for pwol
		2	#
		3	# @configure_input@
		4
		5
		6	# Some 'make' variants does not include CPPFLAGS when compiling, some do
		7	.c.o:
		8	$(CC) $(CPPFLAGS) $(CFLAGS) -c -o $@ $<
		9
		10	@SET_MAKE@
		11
		12	srcdir = @srcdir@
		13	VPATH = @srcdir@
		14
		15	DESTDIR =
		16
		17	prefix = @prefix@
		18	exec_prefix = @exec_prefix@
		19	datarootdir = @datarootdir@
		20	sysconfdir = @sysconfdir@
		21
		22	bindir = @bindir@
		23	mandir = @mandir@
		24	man1dir = ${mandir}/man1
		25	man5dir = ${mandir}/man5
		26	man8dir = ${mandir}/man8
		27
		28	CC = @CC@
		29	INSTALL = @INSTALL@
		30	TAR = tar
		31
		32	PACKAGE = @PACKAGE_TARNAME@
		33	VERSION = @PACKAGE_VERSION@
		34
		35	CPPFLAGS = @CPPFLAGS@ -I. -I${srcdir} -DPATH_CONFIG="\"$(sysconfdir)/pwol.conf\""
		36	CFLAGS = @CFLAGS@ -Wall
		37	LDFLAGS = @LDFLAGS@
		38	LIBS = @LIBS@
		39
		40	VALGRIND = valgrind
		41	VALGRINDFLAGS = --leak-check=full --track-origins=yes --error-exitcode=1 # --show-leak-kinds=all
		42
		43	BINS = pwol
		44	OBJS = pwol.o
		45
		46	all: $(BINS) Makefile
		47
		48	Makefile: Makefile.in config.status
		49	./config.status
		50
		51	config.h: config.h.in config.status
		52	./config.status
		53
		54	pwol.o: pwol.c
		55
		56	pwol: $(OBJS)
		57	$(CC) $(LDFLAGS) -o pwol $(OBJS) $(LIBS)
		58
		59	# Clean targets
		60	maintainer-clean: distclean
		61	rm -f configure config.h.in
		62
		63	distclean: clean
		64	rm -fr config.status config.log stamp-h1 .deps autom4te.cache Makefile config.h *.tar.gz
65
66	clean mostlyclean:
67	-rm -f ~ \# .o $(BINS) core .core vgcore.*
68
69
70	# Git targets
71	push: distclean
72	git add -A && git commit -a && git push
73
74	pull:
75	git pull
76
77
78	# Install targets
79	install-all install: install-bin install-man install-conf
80
81	install-bin: $(BINS)
82	$(INSTALL) -d $(DESTDIR)$(bindir)
83	$(INSTALL) -c $(BINS) $(DESTDIR)$(bindir)
84
85	install-man: pwol.1 pwol.conf.5
86	$(INSTALL) -d "$(DESTDIR)$(man1dir)"
87	$(INSTALL) -c -m 644 pwol.1 "$(DESTDIR)$(man1dir)" && \
88	gzip -f "$(DESTDIR)$(man1dir)/pwol.1"
89	$(INSTALL) -d "$(DESTDIR)$(man5dir)"
90	$(INSTALL) -c -m 644 pwol.conf.5 "$(DESTDIR)$(man5dir)" && \
91	gzip -f "$(DESTDIR)$(man5dir)/pwol.conf.5"
92
93	install-conf: pwol.conf
94	$(INSTALL) -c -m 644 pwol.conf "$(DESTDIR)$(sysconfdir)/pwol.conf.sample"
95
96
97	uninstall-all uninstall: uninstall-bin uninstall-man
98
99	uninstall-bin:
100	rm -f "$(DESTDIR)$(bindir)/pwol"
101
102	uninstall-man:
103	rm -f "$(DESTDIR)$(man1dir)/pwol.1.gz" "$(DESTDIR)$(man1dir)/pwol.1"
104	rm -f "$(DESTDIR)$(man5dir)/pwol.conf.5.gz" "$(DESTDIR)$(man5dir)/pwol.conf.5"
105	rm -f "$(DESTDIR)$(sysconfdir)/pwol.conf.sample"
106
107
108	# Check targets
109	check:
110	@echo "Nothing to check for now."
111
112
113	DISTCHECKDIR=/tmp/distcheck-$(PACKAGE)-$(VERSION)
114
115	distcheck: $(PACKAGE)-$(VERSION).tar.gz
116	@if test -d "$(DISTCHECKDIR)"; then \
117	chmod -R +w "$(DISTCHECKDIR)" && rm -fr "$(DISTCHECKDIR)"; \
118	fi;
119	mkdir -p "$(DISTCHECKDIR)" && \
120	gunzip <"$(PACKAGE)-$(VERSION).tar.gz" \| \
121	(cd "$(DISTCHECKDIR)" && $(TAR) xf - && \
122	chmod -R -w "$(PACKAGE)-$(VERSION)" && \
123	mkdir b && cd b && ../$(PACKAGE)-$(VERSION)/configure && \
124	$(MAKE) && $(MAKE) -s check) && echo "*** distcheck: OK"
125	@chmod -R +w "$(DISTCHECKDIR)" && rm -fr "$(DISTCHECKDIR)";
126
127
128	DISTDIR=/tmp/build-$(PACKAGE)-$(VERSION)
129
130	dist: $(PACKAGE)-$(VERSION).tar.gz
131
132	$(PACKAGE)-$(VERSION).tar.gz: Makefile
133	rm -fr "$(DISTDIR)" && mkdir -p "$(DISTDIR)/$(PACKAGE)-$(VERSION)" && \
134	cp -r * "$(DISTDIR)/$(PACKAGE)-$(VERSION)" && \
135	(cd "$(DISTDIR)/$(PACKAGE)-$(VERSION)" && $(MAKE) distclean)
136	(cd "$(DISTDIR)" && $(TAR) cvf - "$(PACKAGE)-$(VERSION)") \| gzip >"$(PACKAGE)-$(VERSION)".tar.gz
137	echo rm -fr "$(DISTDIR)"
138	@echo ""
139	@echo "*** $(PACKAGE)-$(VERSION).tar.gz created"
140

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/Makefile.old (+45 lines)
	1	# Makefile for pwol
	2
	3	DEST=
	4	CC=gcc -Wall
	5	CFLAGS=-g -DVERSION="\"$(VERSION)\""
	6
	7	PACKAGE=pwol
	8	VERSION=1.4.2
	9
	10	ETCDIR=$(DEST)/etc
	11	BINDIR=$(DEST)/bin
	12	MANDIR=$(DEST)/share/man
	13
	14	BINOBJS=pwol.o
	15
	16	LIBS=
	17
	18	# Needed for Solaris:
	19	#LIBS=-lnsl -lsocket -lrt
	20
	21
	22	all: pwol
	23
	24	pwol: $(BINOBJS)
	25	$(CC) -g -o pwol $(BINOBJS) $(LIBS)
	26
	27	clean:
	28	-rm -f ~ core .core .o \# pwol
	29
	30	distclean: clean
	31	-rm -f pwol
	32
	33	install: pwol
	34	$(INSTALL) -o root -g wheel -m 0444 pwol $(BINDIR)
	35	$(INSTALL) -o root -g wheel -m 0444 pwol.1 $(MANDIR)/man1
	36
	37	pull: distclean
	38	git pull
	39
	40	push: distclean
	41	git add -A && git commit -a && git push
	42
	43	dist: distclean
	44	(mkdir -p ../dist && cd ../dist && ln -sf ../$(PACKAGE) $(PACKAGE)-$(VERSION) && tar zcf $(PACKAGE)-$(VERSION).tar.gz $(PACKAGE)-$(VERSION)/* && rm $(PACKAGE)-$(VERSION))
	45

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/pkgs/Makefile (+24 lines)
	1	# Makefile for pkgs
	2
	3	PORTSDIR=/usr/ports
	4	PORTSNAME=sysutils/pwol
	5
	6	all:
	7	@echo "Use 'make port'"
	8	@exit 1
	9
	10	port: Makefile.port pkg-descr
	11	mkdir -p "$(PORTSDIR)/$(PORTSNAME)"
	12	cp Makefile.port "$(PORTSDIR)/$(PORTSNAME)/Makefile"
	13	cp pkg-descr "$(PORTSDIR)/$(PORTSNAME)"
	14	(cd "$(PORTSDIR)/$(PORTSNAME)" && make distclean && make makesum && portlint -AC)
	15
	16
	17	# Clean targets
	18	maintainer-clean: distclean
	19
	20	distclean: clean
	21	rm -fr Makefile.port
	22
	23	clean mostlyclean:
	24	-rm -f ~ \#

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/pkgs/Makefile.port.in (+24 lines)
	1	# $FreeBSD$
	2
	3	PORTNAME= @PACKAGE_TARNAME@
	4	DISTVERSIONPREFIX= v
	5	DISTVERSION= @PACKAGE_VERSION@
	6	CATEGORIES= sysutils
	7
	8	MAINTAINER= @PACKAGE_BUGREPORT@
	9	COMMENT= Peter's Wake-on-LAN Tool
	10
	11	LICENSE= BSD3CLAUSE
	12	LICENSE_FILE= ${WRKSRC}/LICENSE
	13
	14	USE_GITHUB= yes
	15	GH_ACCOUNT= ptrrkssn
	16
	17	GNU_CONFIGURE= yes
	18
	19	PLIST_FILES= bin/pwol \
	20	man/man1/pwol.1.gz \
	21	man/man5/pwol.conf.5.gz \
	22	etc/pwol.conf.sample
	23
	24	.include <bsd.port.mk>

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/pwol.1 (+94 lines)
		1	.TH "PWOL" "1" "14 Jun 2020" "1.5" "pwol man page"
		2
		3	.SH "NAME"
		4	pwol \- Send Wake-On-LAN (WoL) packets to wake-up hosts over the network
		5
		6	.SH "SYNOPSIS"
		7	.B pwol
		8	.RI "[" "options" "]"
		9	.RI "[" "<hosts\|groups>" "]"
		10
		11	.SH "DESCRIPTION"
		12	.B pwol
		13	is a tool that can be used to send WoL (Wake-On-LAN) network packets
		14	in order to wake-up sleeping hosts, either directly or via routers.
		15	.PP
		16	It can also be used as a WoL proxy daemon listening to incoming WoL
		17	packets (possibly authenticated) and then forwarding requests to one
		18	or many other targets.
		19	.PP
		20	If no hosts or groups are specified on the command line then
		21	.B pwol
		22	will read them from the command line.
		23
		24	.SH "OPTIONS"
		25	.TP
		26	.B \-h
		27	Show summary of options.
		28	.TP
		29	.B \-V
		30	Print build version.
		31	.TP
		32	.B \-v
		33	Increase verbosity level.
		34	.TP
		35	.B \-i
		36	Ignore errors.
		37	.TP
		38	.B \-d
		39	Increase internal debugging level.
		40	.TP
		41	.B \-n
		42	No-send mode (dry run).
		43	.TP
		44	.B \-e
		45	Export configuration.
		46	.TP
		47	.BI \-f " path"
		48	Load additional configuration files.
		49	.PP
		50	.TP
		51	.BI \-g " name"
		52	Force (override) gateway.
		53	.TP
		54	.BI \-a " address"
		55	Force (override) destination address (DNS name).
		56	.TP
		57	.BI \-p " service"
		58	Force (override) gateway port (service name).
		59	.TP
		60	.BI \-t " delay"
		61	Force (override) inter-packet delay.
		62	.TP
		63	.BI \-T " delay"
		64	Force (override) inter-host delay.
65	.TP
66	.BI \-c " count"
67	Force (override) packet copies for hosts/groups.
68	.TP
69	.BI \-s " secret"
70	Force (override) WoL secret.
71	.PP
72	.TP
73	.B \-D
74	Enable proxy daemon mode
75	.TP
76	.B \-F
77	Run proxy in the foreground
78	.TP
79	.BI \-A " address"
80	Force (override) proxy address (DNS name).
81	.TP
82	.BI \-P " service"
83	Force (override) proxy port.
84	.TP
85	.BI \-S " secret"
86	Force (override) proxy secret.
87
88	.SH "SEE ALSO"
89	.BR pwol.conf (5),
90	.BR ping (8),
91	.B "https://github.com/ptrrkssn/pwol"
92
93	.SH "AUTHOR"
94	pwol was written by Peter Eriksson <pen@lysator.liu.se>.

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/pwol.1.in (+94 lines)
		1	.TH "PWOL" "1" "14 Jun 2020" "@PACKAGE_VERSION@" "pwol man page"
		2
		3	.SH "NAME"
		4	pwol \- Send Wake-On-LAN (WoL) packets to wake-up hosts over the network
		5
		6	.SH "SYNOPSIS"
		7	.B pwol
		8	.RI "[" "options" "]"
		9	.RI "[" "<hosts\|groups>" "]"
		10
		11	.SH "DESCRIPTION"
		12	.B pwol
		13	is a tool that can be used to send WoL (Wake-On-LAN) network packets
		14	in order to wake-up sleeping hosts, either directly or via routers.
		15	.PP
		16	It can also be used as a WoL proxy daemon listening to incoming WoL
		17	packets (possibly authenticated) and then forwarding requests to one
		18	or many other targets.
		19	.PP
		20	If no hosts or groups are specified on the command line then
		21	.B pwol
		22	will read them from the command line.
		23
		24	.SH "OPTIONS"
		25	.TP
		26	.B \-h
		27	Show summary of options.
		28	.TP
		29	.B \-V
		30	Print build version.
		31	.TP
		32	.B \-v
		33	Increase verbosity level.
		34	.TP
		35	.B \-i
		36	Ignore errors.
		37	.TP
		38	.B \-d
		39	Increase internal debugging level.
		40	.TP
		41	.B \-n
		42	No-send mode (dry run).
		43	.TP
		44	.B \-e
		45	Export configuration.
		46	.TP
		47	.BI \-f " path"
		48	Load additional configuration files.
		49	.PP
		50	.TP
		51	.BI \-g " name"
		52	Force (override) gateway.
		53	.TP
		54	.BI \-a " address"
		55	Force (override) destination address (DNS name).
		56	.TP
		57	.BI \-p " service"
		58	Force (override) gateway port (service name).
		59	.TP
		60	.BI \-t " delay"
		61	Force (override) inter-packet delay.
		62	.TP
		63	.BI \-T " delay"
		64	Force (override) inter-host delay.
65	.TP
66	.BI \-c " count"
67	Force (override) packet copies for hosts/groups.
68	.TP
69	.BI \-s " secret"
70	Force (override) WoL secret.
71	.PP
72	.TP
73	.B \-D
74	Enable proxy daemon mode
75	.TP
76	.B \-F
77	Run proxy in the foreground
78	.TP
79	.BI \-A " address"
80	Force (override) proxy address (DNS name).
81	.TP
82	.BI \-P " service"
83	Force (override) proxy port.
84	.TP
85	.BI \-S " secret"
86	Force (override) proxy secret.
87
88	.SH "SEE ALSO"
89	.BR pwol.conf (5),
90	.BR ping (8),
91	.B "https://github.com/ptrrkssn/pwol"
92
93	.SH "AUTHOR"
94	pwol was written by Peter Eriksson <pen@lysator.liu.se>.

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/pwol.conf (+38 lines)
	1	; pwol.conf
	2
	3	;;; Default settings:
	4	; copies 1
	5	; delay 0.0s
	6	; port 7
	7
	8	;;; Sample configuration:
	9	; gateway A
	10	; address 10.0.0.255
	11	; port 1
	12
	13	; gateway B address b.wol.example.com
	14	; gateway c.wol.example.com secret 1.2.3.4
	15	; gateway D address 2001:0:1::1
	16
	17	; host test-1 mac fc:3f:db:04:1e:01 via A secret 1:2:3:4:5:6
	18	; host test-2
	19	; mac fc:3f:db:04:1e:02
	20	; secret hello7
	21
	22	; [B]
	23
	24	;:; Inter-host delay
	25	; delay 1s
	26
	27	; host test-3 mac b8:ac:6f:1f:68:03 delay 100ns
	28	; host test-4 mac 00:1b:78:9b:c6:04 secret 1.2.3.4
	29	; host 00:11:22:33:44:55
	30	; host 00:11:22:33:44:ff name test-6
	31
	32	;;; Only works if hosts are defined in /etc/ethers
	33	; host test-7 mac test-7.example.com copies 2 delay 1s
	34	; host test-8.example.com
	35
	36	; [MyGroup]
	37	; host test-3
	38	; host test-6

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/pwol.conf.5 (+134 lines)
		1	.TH "PWOL.CONF" "5" "14 Jun 2020" "1.5" "pwol.conf man page"
		2
		3	.SH "NAME"
		4	.TP
		5	.BR pwol.conf "\- Global configuration file for pwol"
		6	.TP
		7	.BR ~/.pwolrc "\- Per-user configuration file for pwol"
		8
		9	.SH "DESCRIPTION"
		10	.B pwol is a command line utility to send Wake-On-LAN (WoL) packets to one or many hosts, either
		11	locally or via routers, in order to wake them up from sleep mode.
		12	.PP
		13	It can also be used as a WoL proxy daemon listening to incoming WoL packets (possibly authenticated)
		14	and then forwarding requests to one or many other targets.
		15	.PP
		16	The configuration file(s) for
		17	.B pwol
		18	define global options, gateways (that forwards WoL packets), hosts (destinations
		19	for WoL packets) and host groups (preferably in that order).
		20	.PP
		21	For gateways and hosts can override the global options plus use a few local ones
		22	defined below. The gateway and host options may be specified on the same line or
		23	on following lines (until the next gateway/host or host group definitions are
		24	started).
		25	.PP
		26	Lines starting with ";" or "#" and empty lines are ignored.
		27
		28	.SH "GLOBAL OPTIONS"
		29	.TP
		30	.BI copies " number"
		31	Set the number of WoL packets to send per host
		32	.TP
		33	.BI delay " time"
		34	Set the inter-packet delay.
		35	.TP
		36	.BI port " number"
		37	Set the destination UDP port to send WoL packets to.
		38	.TP
		39	.BI secret " ipv4\|mac\|text"
		40	Set the secret code to include in WoL packets
		41
		42	.TP
		43	.BI gateway " name [sub-options]"
		44	Start a gateway definition
		45	.TP
		46	.BI host " name\|mac [sub-options]"
		47	Start a host definition.
		48	.TP
		49	.BI "[" name "]"
		50	Start a host group section.
		51
		52	.SH "GATEWAY OPTIONS"
		53	.TP
		54	.BI address " ipv4\|ipv6\|hostname"
		55	Set the ip address of the gateway. If not specified will try to use the gateway name
		56	as a host name to lookup up the address.
		57
		58	.SH "HOST OPTIONS"
		59	.TP
		60	.BI mac " mac-address\|hostname"
		61	Set the mac address of the host. If not specified will try to use the host name
		62	to look up the mac address from /etc/ethers (if the system supports such lookups).
		63	.TP
		64	.BI name " text"
65	Override the name of the host (if mac is specified as
66	.BR name ")."
67	.TP
68	.BI via " gateway-name"
69	Send packets to this host via the specified gateway.
70
71	.SH "HOST GROUPS"
72	Host groups are specified by a group name enclosed in "[" and "]" and then
73	followed by a list of normal host declarations. As a short cut if a host is to
74	be defined in multiple host groups then you do not need to re-specify all host
75	sub-options and can just reference it via
76	.BI host " name."
77	Another shortcut is that if a group name equals the name of a gateway then that
78	is used for each host in the group.
79
80	.SH "EXAMPLE"
81	.nf
82	; pwol.conf
83
84	;; Global settings:
85	copies 1
86	delay 0.0s
87	port 7
88
89
90	;; Some gateways:
91	gateway A
92	address 10.0.0.255
93	port 1
94
95	gateway B address b.wol.example.com
96	gateway c.wol.example.com secret 1.2.3.4
97	gateway D address 2001:0:1::1
98
99
100	;; Some hosts:
101	host test-1 mac fc:3f:db:04:1e:01 via A secret 1:2:3:4:5:6
102	host test-2
103	mac fc:3f:db:04:1e:02
104	secret hello7
105
106
107	;; Host group using gateway "B"
108	[B]
109	:; These hosts need a longer inter-host delay
110	delay 1s
111
112	host test-3 mac b8:ac:6f:1f:68:03 delay 100ns
113	host test-4 mac 00:1b:78:9b:c6:04 secret 1.2.3.4
114	host 00:11:22:33:44:55
115	host 00:11:22:33:44:ff name test-6
116
117	;; Only works if hosts are defined in /etc/ethers
118	host test-7 mac test-7.example.com copies 2 delay 1s
119	host test-8.example.com
120
121
122	;; Standalone host group:
123	[MyGroup]
124	host test-3
125	host test-6
126	.fi
127
128	.SH "SEE ALSO"
129	.BR pwol (1),
130	.BR ping (8),
131	.B "https://github.com/ptrrkssn/pwol"
132
133	.SH "AUTHOR"
134	pwol was written by Peter Eriksson <pen@lysator.liu.se>.

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/pwol.conf.5.in (+134 lines)
		1	.TH "PWOL.CONF" "5" "14 Jun 2020" "@PACKAGE_VERSION@" "pwol.conf man page"
		2
		3	.SH "NAME"
		4	.TP
		5	.BR pwol.conf "\- Global configuration file for pwol"
		6	.TP
		7	.BR ~/.pwolrc "\- Per-user configuration file for pwol"
		8
		9	.SH "DESCRIPTION"
		10	.B pwol is a command line utility to send Wake-On-LAN (WoL) packets to one or many hosts, either
		11	locally or via routers, in order to wake them up from sleep mode.
		12	.PP
		13	It can also be used as a WoL proxy daemon listening to incoming WoL packets (possibly authenticated)
		14	and then forwarding requests to one or many other targets.
		15	.PP
		16	The configuration file(s) for
		17	.B pwol
		18	define global options, gateways (that forwards WoL packets), hosts (destinations
		19	for WoL packets) and host groups (preferably in that order).
		20	.PP
		21	For gateways and hosts can override the global options plus use a few local ones
		22	defined below. The gateway and host options may be specified on the same line or
		23	on following lines (until the next gateway/host or host group definitions are
		24	started).
		25	.PP
		26	Lines starting with ";" or "#" and empty lines are ignored.
		27
		28	.SH "GLOBAL OPTIONS"
		29	.TP
		30	.BI copies " number"
		31	Set the number of WoL packets to send per host
		32	.TP
		33	.BI delay " time"
		34	Set the inter-packet delay.
		35	.TP
		36	.BI port " number"
		37	Set the destination UDP port to send WoL packets to.
		38	.TP
		39	.BI secret " ipv4\|mac\|text"
		40	Set the secret code to include in WoL packets
		41
		42	.TP
		43	.BI gateway " name [sub-options]"
		44	Start a gateway definition
		45	.TP
		46	.BI host " name\|mac [sub-options]"
		47	Start a host definition.
		48	.TP
		49	.BI "[" name "]"
		50	Start a host group section.
		51
		52	.SH "GATEWAY OPTIONS"
		53	.TP
		54	.BI address " ipv4\|ipv6\|hostname"
		55	Set the ip address of the gateway. If not specified will try to use the gateway name
		56	as a host name to lookup up the address.
		57
		58	.SH "HOST OPTIONS"
		59	.TP
		60	.BI mac " mac-address\|hostname"
		61	Set the mac address of the host. If not specified will try to use the host name
		62	to look up the mac address from /etc/ethers (if the system supports such lookups).
		63	.TP
		64	.BI name " text"
65	Override the name of the host (if mac is specified as
66	.BR name ")."
67	.TP
68	.BI via " gateway-name"
69	Send packets to this host via the specified gateway.
70
71	.SH "HOST GROUPS"
72	Host groups are specified by a group name enclosed in "[" and "]" and then
73	followed by a list of normal host declarations. As a short cut if a host is to
74	be defined in multiple host groups then you do not need to re-specify all host
75	sub-options and can just reference it via
76	.BI host " name."
77	Another shortcut is that if a group name equals the name of a gateway then that
78	is used for each host in the group.
79
80	.SH "EXAMPLE"
81	.nf
82	; pwol.conf
83
84	;; Global settings:
85	copies 1
86	delay 0.0s
87	port 7
88
89
90	;; Some gateways:
91	gateway A
92	address 10.0.0.255
93	port 1
94
95	gateway B address b.wol.example.com
96	gateway c.wol.example.com secret 1.2.3.4
97	gateway D address 2001:0:1::1
98
99
100	;; Some hosts:
101	host test-1 mac fc:3f:db:04:1e:01 via A secret 1:2:3:4:5:6
102	host test-2
103	mac fc:3f:db:04:1e:02
104	secret hello7
105
106
107	;; Host group using gateway "B"
108	[B]
109	:; These hosts need a longer inter-host delay
110	delay 1s
111
112	host test-3 mac b8:ac:6f:1f:68:03 delay 100ns
113	host test-4 mac 00:1b:78:9b:c6:04 secret 1.2.3.4
114	host 00:11:22:33:44:55
115	host 00:11:22:33:44:ff name test-6
116
117	;; Only works if hosts are defined in /etc/ethers
118	host test-7 mac test-7.example.com copies 2 delay 1s
119	host test-8.example.com
120
121
122	;; Standalone host group:
123	[MyGroup]
124	host test-3
125	host test-6
126	.fi
127
128	.SH "SEE ALSO"
129	.BR pwol (1),
130	.BR ping (8),
131	.B "https://github.com/ptrrkssn/pwol"
132
133	.SH "AUTHOR"
134	pwol was written by Peter Eriksson <pen@lysator.liu.se>.

Line 0 Link Here

(-)sysutils/pwol/work/pwol-1.5/README (+29 lines)
	1	Peter's Wake-On-LAN utility
	2
	3	Author: Peter Eriksson <pen@lysator.liu.se>
	4	Website: https://github.com/ptrrkssn/pwol
	5
	6	pwol is a command line utility to send Wake-On-LAN (WoL) packets to one or many hosts, either
	7	locally or via routers, in order to wake them up from sleep mode.
	8
	9	It can also be used as a WoL proxy daemon listening to incoming WoL packets (possibly authenticated)
	10	and then forwarding requests to one or many other targets.
	11
	12
	13	LICENSE
	14
	15	BSD standard license. See the file LICENSE for details.
	16
	17
	18	BUILD INSTRUCTIONS
	19
	20	Edit 'Makefile' and run 'make'. Build has been tested on Solaris 10, OmniOS, Linux (CentOS 6) and FreeBSD 11.
	21
	22
	23	USAGE
	24
	25	pwol looks for a configuration file in two places by default, /etc/pwol.conf and
	26	$HOME/.pwolrc. Additional configuration files may be specified via the "-f" command
	27	line switch.
	28
	29	See the "pwol.conf" file for details.

Line 0 Link Here

(-)sysutils/pwol/work/stage/usr/local/etc/pwol.conf.sample (+38 lines)
	1	; pwol.conf
	2
	3	;;; Default settings:
	4	; copies 1
	5	; delay 0.0s
	6	; port 7
	7
	8	;;; Sample configuration:
	9	; gateway A
	10	; address 10.0.0.255
	11	; port 1
	12
	13	; gateway B address b.wol.example.com
	14	; gateway c.wol.example.com secret 1.2.3.4
	15	; gateway D address 2001:0:1::1
	16
	17	; host test-1 mac fc:3f:db:04:1e:01 via A secret 1:2:3:4:5:6
	18	; host test-2
	19	; mac fc:3f:db:04:1e:02
	20	; secret hello7
	21
	22	; [B]
	23
	24	;:; Inter-host delay
	25	; delay 1s
	26
	27	; host test-3 mac b8:ac:6f:1f:68:03 delay 100ns
	28	; host test-4 mac 00:1b:78:9b:c6:04 secret 1.2.3.4
	29	; host 00:11:22:33:44:55
	30	; host 00:11:22:33:44:ff name test-6
	31
	32	;;; Only works if hosts are defined in /etc/ethers
	33	; host test-7 mac test-7.example.com copies 2 delay 1s
	34	; host test-8.example.com
	35
	36	; [MyGroup]
	37	; host test-3
	38	; host test-6