Google


# Avoid depending upon Character  Ranges.   as_cr_letters='abcde-
fghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS             as_cr_dig-
its='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits

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

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


##  ---------------------  ##  ##  M4sh  Initialization.   ##  ##
--------------------- ##

#  Be  Bourne compatible if test -n "${ZSH_VERSION+set}" && (emu-
late sh) >/dev/null 2>&1; then
  emulate sh
  NULLCMD=: elif test -n "${BASH_VERSION+set}" && (set -o  posix)
>/dev/null 2>&1; then
  set -o posix fi

# Name of the executable.  as_me=`echo "$0" |sed 's,.*[\/],,'`

if expr a : '' >/dev/null 2>&1; then
  as_expr=expr else
  as_expr=false fi

rm  -f  conf$$  conf$$.exe conf$$.file echo >conf$$.file if ln -s
conf$$.file conf$$ 2>/dev/null; then
  # We could just check for DJGPP; but this test a) works  b)  is
more generic
  #  and c) will remain valid once DJGPP supports symlinks (DJGPP
2.04).
  if test -f conf$$.exe; then
    # Don't use ln at all; we don't have any links
    as_ln_s='cp -p'
  else
    as_ln_s='ln -s'
  fi elif ln conf$$.file conf$$ 2>/dev/null; then
  as_ln_s=ln else
  as_ln_s='cp -p' fi rm -f conf$$ conf$$.exe conf$$.file

as_executable_p="test -f"

#  Support  unset  when  possible.   if  (FOO=FOO;   unset   FOO)
>/dev/null 2>&1; then
  as_unset=unset else
  as_unset=false fi


# IFS # We need space, tab and new line, in precisely that order.
as_nl=' IFS="   $as_nl"

#  CDPATH.   $as_unset CDPATH || test "${CDPATH+set}" != set || {
CDPATH=:; export CDPATH; }


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

exec 6>&1

# # Initializations.  #  ac_default_prefix=/usr/local  cross_com-
piling=no     subdirs=     MFLAGS=     MAKEFLAGS=    SHELL=${CON-
FIG_SHELL-/bin/sh}

# Maximum number of lines to put in a  shell  here  document.   #
This variable seems obsolete.  It should probably be removed, and
#    only     ac_max_sed_lines     should     be     used.      :
${ac_max_here_lines=38}

ac_unique_file="ssh.c"  #  Factoring  default  headers  for  most
tests.      ac_includes_default="#include      <stdio.h>      #if
HAVE_SYS_TYPES_H    #    include    <sys/types.h>    #endif   #if
HAVE_SYS_STAT_H # include <sys/stat.h> #endif #if STDC_HEADERS  #
include  <stdlib.h> # include <stddef.h> #else # if HAVE_STDLIB_H
#  include <stdlib.h> #  endif  #endif  #if  HAVE_STRING_H  #  if
!STDC_HEADERS  &&  HAVE_MEMORY_H  #  include <memory.h> # endif #
include  <string.h>   #endif   #if   HAVE_STRINGS_H   #   include
confdefs.h

# Let the site file select an alternate cache file  if  it  wants
to.   # Prefer explicitly selected file to automatically selected
ones.  if test -z "$CONFIG_SITE"; then
  if test "x$prefix" != xNONE; then
    CONFIG_SITE="$prefix/share/config.site       $prefix/etc/con-
fig.site"
  else
    CONFIG_SITE="$ac_default_prefix/share/config.site     $ac_de-
fault_prefix/etc/config.site"
  fi fi for ac_site_file in $CONFIG_SITE; do
  if test -r "$ac_site_file"; then
    { echo "$as_me:__oline__: loading site script  $ac_site_file"
>&5 echo "$as_me: loading site script $ac_site_file" >&6;}
    sed 's/^/| /' "$ac_site_file" >&5
    . "$ac_site_file"
  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.
  if test -f "$cache_file"; then
    { echo "$as_me:__oline__: loading cache $cache_file" >&5 echo
"$as_me: loading cache $cache_file" >&6;}
    case $cache_file in
      [\/]* | ?:[\/]* ) . $cache_file;;
      *)                      . ./$cache_file;;
    esac
  fi else
  { echo "$as_me:__oline__: creating cache $cache_file" >&5  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  `(set)
2>&1 |
               sed -n 's/^ac_env_-zA-Z_0-9]*_set=.*/1/p'`; do
  eval ac_old_set=c_cv_env_${ac_var}_set
  eval ac_new_set=c_env_${ac_var}_set
  eval ac_old_val="c_cv_env_${ac_var}_value"
  eval ac_new_val="c_env_${ac_var}_value"
  case $ac_old_set,$ac_new_set in
    set,)
      {  echo  "$as_me:__oline__:  error:  `$ac_var'  was  set to
        {  echo  "$as_me:__oline__:   former value:  $ac_old_val"
>&5 echo "$as_me:   former value:  $ac_old_val" >&2;}
        { echo "$as_me:__oline__:   current  value:  $ac_new_val"
>&5 echo "$as_me:   current value: $ac_new_val" >&2;}
        ac_cache_corrupted=:
      fi;;
  esac
  #  Pass precious variables to config.status.  It doesn't matter
if
  # we pass some twice (in addition to  the  command  line  argu-
ments).
  if test "$ac_new_set" = set; then
    case $ac_new_val in
    *"  "*|*"    "*|*[       ac_arg=$ac_var=`echo "$ac_new_val" |
sed "s/'/'\\\\''/g"`
      ac_configure_args="$ac_configure_args '$ac_arg'"
      ;;
    *) ac_configure_args="$ac_configure_args $ac_var=$ac_new_val"
       ;;
    esac
  fi done if $ac_cache_corrupted; then
  { echo "$as_me:__oline__: error: changes in the environment can
compromise the build" >&5 echo "$as_me: error: changes in the en-
vironment can compromise the build" >&2;}
  {  { echo "$as_me:__oline__: error: run `make distclean' and/or
`rm $cache_file' and start over" >&5  echo  "$as_me:  error:  run
`make distclean' and/or `rm $cache_file' and start over" >&2;}
   { (exit 1); exit 1; }; } fi

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


case `echo "testing  *c*,-n*) ECHO_N= ECHO_C='
  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
  *)      ECHO_N= ECHO_C='esac echo "#! $SHELL" >conftest.sh echo
"exit   0"    >>conftest.sh  chmod  +x  conftest.sh  if  {  (echo
"$as_me:__oline__: PATH=
  (PATH=".;."; conftest.sh) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; then
  ac_path_separator=';' else
  ac_path_separator=: fi  PATH_SEPARATOR="$ac_path_separator"  rm
-f conftest.sh







ac_config_headers="$ac_config_headers config.h"

ac_ext=c   ac_cpp='$CPP  $CPPFLAGS'  ac_compile='$CC  -c  $CFLAGS
$CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o  conftest$ac_exe-
ext   $CFLAGS  $CPPFLAGS  $LDFLAGS  conftest.$ac_ext  $LIBS  >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu if test  -n  "$ac_tool_pre-
fix"; 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  echo  "$as_me:__oline__:  checking  for $ac_word" >&5
echo $ECHO_N "checking  for  $ac_word...  $ECHO_C"  >&6  if  test
"${ac_cv_prog_CC+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.  else
  ac_save_IFS=$IFS;  IFS=$ac_path_separator  ac_dummy="$PATH" for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  $as_executable_p      "$ac_dir/$ac_word"      ||       continue
ac_cv_prog_CC="${ac_tool_prefix}gcc"    echo   "$as_me:__oline__:
found $ac_dir/$ac_word" >&5 break done

fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then
  echo "$as_me:__oline__: result: $CC"  >&5  echo  "${ECHO_T}$CC"
>&6 else
  echo  "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}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 echo "$as_me:__oline__:
checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word...
$ECHO_C" >&6 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&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
  ac_save_IFS=$IFS; IFS=$ac_path_separator  ac_dummy="$PATH"  for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  $as_executable_p       "$ac_dir/$ac_word"      ||      continue
ac_cv_prog_ac_ct_CC="gcc"    echo    "$as_me:__oline__:     found
$ac_dir/$ac_word" >&5 break done

fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then
  echo    "$as_me:__oline__:    result:   $ac_ct_CC"   >&5   echo
"${ECHO_T}$ac_ct_CC" >&6 else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.  else
  ac_save_IFS=$IFS;  IFS=$ac_path_separator  ac_dummy="$PATH" for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  $as_executable_p      "$ac_dir/$ac_word"      ||       continue
ac_cv_prog_CC="${ac_tool_prefix}cc" echo "$as_me:__oline__: found
$ac_dir/$ac_word" >&5 break done

fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then
  echo "$as_me:__oline__: result: $CC"  >&5  echo  "${ECHO_T}$CC"
>&6 else
  echo  "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no" >&6
fi

fi if test -z "$ac_cv_prog_CC"; then
  ac_ct_CC=$CC
  # Extract the first word of "cc", so it can be a  program  name
with  args.   set  dummy  cc;  ac_word=$2 echo "$as_me:__oline__:
checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word...
$ECHO_C" >&6 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&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
  ac_save_IFS=$IFS; IFS=$ac_path_separator  ac_dummy="$PATH"  for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  $as_executable_p       "$ac_dir/$ac_word"      ||      continue
ac_cv_prog_ac_ct_CC="cc"    echo     "$as_me:__oline__:     found
$ac_dir/$ac_word" >&5 break done

fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then
  echo    "$as_me:__oline__:    result:   $ac_ct_CC"   >&5   echo
"${ECHO_T}$ac_ct_CC" >&6 else
  echo "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no"  >&6
fi

  CC=$ac_ct_CC else
  CC="$ac_cv_prog_CC" 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  echo  "$as_me:__oline__:
checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word...
$ECHO_C" >&6 if test "${ac_cv_prog_CC+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.  else
  ac_prog_rejected=no
  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
    set dummy "$ac_dir/$ac_word" ${1+"$@"}
    shift
    ac_cv_prog_CC="$@"
  fi fi fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then
  echo  "$as_me:__oline__:  result:  $CC" >&5 echo "${ECHO_T}$CC"
>&6 else
  echo "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no"  >&6
fi

fi if test -z "$CC"; then
  if test -n "$ac_tool_prefix"; then
  for ac_prog in cl
  do
    #  Extract the first word of "$ac_tool_prefix$ac_prog", so it
can be  a  program  name  with  args.   set  dummy  $ac_tool_pre-
fix$ac_prog;  ac_word=$2  echo  "$as_me:__oline__:  checking  for
$ac_word" >&5 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_CC+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.  else
  ac_save_IFS=$IFS;  IFS=$ac_path_separator  ac_dummy="$PATH" for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  $as_executable_p      "$ac_dir/$ac_word"      ||       continue
ac_cv_prog_CC="$ac_tool_prefix$ac_prog"  echo  "$as_me:__oline__:
found $ac_dir/$ac_word" >&5 break done

fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then
  echo "$as_me:__oline__: result: $CC"  >&5  echo  "${ECHO_T}$CC"
>&6 else
  echo  "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no" >&6
fi

    test -n "$CC" && break
  done fi if test -z "$CC"; then
  ac_ct_CC=$CC
  for ac_prog in cl do
  # Extract the first word of "$ac_prog", so it can be a  program
name   with   args.    set   dummy   $ac_prog;   ac_word=$2  echo
"$as_me:__oline__:  checking  for  $ac_word"  >&5  echo   $ECHO_N
"checking     for    $ac_word...    $ECHO_C"    >&6    if    test
"${ac_cv_prog_ac_ct_CC+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  echo  "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no" >&6
fi

  test -n "$ac_ct_CC" && break done

  CC=$ac_ct_CC fi

fi


test -z "$CC" && { { echo "$as_me:__oline__: error: no acceptable
cc  found in ATH" >&5 echo "$as_me: error: no acceptable cc found
in ATH" >&2;}
   { (exit 1); exit 1; }; }

#  Provide   some   information   about   the   compiler.    echo
"$as_me:__oline__:"       "checking  for  C compiler version" >&5
ac_compiler=`set  X  $ac_compile;   echo   $2`   {   (eval   echo
"$as_me:__oline__:
  (eval $ac_compiler --version </dev/null >&5) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } { (eval echo "$as_me:__oline__:
  (eval $ac_compiler -v </dev/null >&5) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } { (eval echo "$as_me:__oline__:
  (eval $ac_compiler -V </dev/null >&5) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }

cat  >conftest.$ac_ext  <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h"

#ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {

  ;
  return   0;   }   _ACEOF    ac_clean_files_save=$ac_clean_files
ac_clean_files="$ac_clean_files  a.out  a.exe" # Try to create an
executable without -o first, disregard a.out.  # It will help  us
diagnose broken compilers, and finding out an intuition # of exe-
ext.  echo "$as_me:__oline__: checking  for  C  compiler  default
output"  >&5  echo  $ECHO_N "checking for C compiler default out-
put... $ECHO_C" >&6 ac_link_default=`echo "$ac_link" | sed 's/ -o
*conftest[^ ]*//'` if { (eval echo "$as_me:__oline__:
  (eval $ac_link_default) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; then
          # FIXME: I believe we export ac_cv_exeext  for  Libtool
--akim.
          export ac_cv_exeext
          break;;
    * ) break;;
  esac done else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
{ { echo "$as_me:__oline__: error: C compiler cannot create  exe-
cutables"  >&5 echo "$as_me: error: C compiler cannot create exe-
cutables" >&2;}
   { (exit 77); exit 77; }; } fi

ac_exeext=$ac_cv_exeext echo "$as_me:__oline__: result: $ac_file"
>&5 echo "${ECHO_T}$ac_file" >&6

#  Check  the  compiler produces executables we can run.  If not,
either # the compiler is  broken,  or  we  cross  compile.   echo
"$as_me:__oline__:  checking  whether  the  C compiler works" >&5
echo $ECHO_N "checking whether the C compiler  works...  $ECHO_C"
>&6 # FIXME: These cross compiler hacks should be removed for Au-
toconf 3.0 # If not cross compiling, check that we can run a sim-
ple program.  if test "$cross_compiling" != yes; then
  if { ac_try='./$ac_file'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
    cross_compiling=no
  else
    if  test  "$cross_compiling" = maybe; then         cross_com-
piling=yes
    else         { { echo "$as_me:__oline__: error: cannot run  C
compiled programs.  If you meant to cross compile, use `--host'."
>&5 echo "$as_me: error: cannot run C compiled programs.  If  you
meant to cross compile, use `--host'." >&2;}
   { (exit 1); exit 1; }; }
    fi
  fi   fi   echo   "$as_me:__oline__:   result:   yes"  >&5  echo
"${ECHO_T}yes" >&6

rm       -f       a.out        a.exe        conftest$ac_cv_exeext
ac_clean_files=$ac_clean_files_save # Check the compiler produces
executables we can run.  If not, either # the compiler is broken,
or we cross compile.  echo "$as_me:__oline__: checking whether we
are cross compiling" >&5 echo $ECHO_N "checking  whether  we  are
cross  compiling...  $ECHO_C" >&6 echo "$as_me:__oline__: result:
$cross_compiling" >&5 echo "${ECHO_T}$cross_compiling" >&6

echo "$as_me:__oline__: checking for executable suffix" >&5  echo
$ECHO_N  "checking  for  executable  suffix...  $ECHO_C" >&6 if {
(eval echo "$as_me:__oline__:
    * ) break;;
  esac done else
  { { echo "$as_me:__oline__: error: cannot compute EXEEXT:  can-
not compile and link" >&5 echo "$as_me: error: cannot compute EX-
EEXT: cannot compile and link" >&2;}
   { (exit 1); exit 1; }; } fi

rm  -f  conftest$ac_cv_exeext  echo  "$as_me:__oline__:   result:
$ac_cv_exeext" >&5 echo "${ECHO_T}$ac_cv_exeext" >&6

rm  -f  conftest.$ac_ext  EXEEXT=$ac_cv_exeext  ac_exeext=$EXEEXT
echo "$as_me:__oline__: checking  for  object  suffix"  >&5  echo
$ECHO_N  "checking  for  object  suffix...  $ECHO_C"  >&6 if test
"${ac_cv_objext+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h"

#ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {

  ;
  return  0;  }  _ACEOF  rm -f conftest.o conftest.obj if { (eval
echo "$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; then
  for ac_file in `(ls  conftest.o  conftest.obj;  ls  conftest.*)
2>/dev/null`; do
  case $ac_file in
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb ) ;;
    *) ac_cv_objext=`expr "$ac_file" : '.*.'`
       break;;
  esac done else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
{ { echo "$as_me:__oline__: error: cannot compute OBJEXT:  cannot
compile"  >&5  echo "$as_me: error: cannot compute OBJEXT: cannot
compile" >&2;}
   { (exit 1); exit 1; }; } fi

rm   -f   conftest.$ac_cv_objext   conftest.$ac_ext    fi    echo
"$as_me:__oline__:     result:     $ac_cv_objext"     >&5    echo
"${ECHO_T}$ac_cv_objext" >&6 OBJEXT=$ac_cv_objext  ac_objext=$OB-
JEXT  echo  "$as_me:__oline__:  checking whether we are using the
GNU C compiler" >&5 echo $ECHO_N "checking whether we  are  using
the  GNU  C  compiler...  $ECHO_C" >&6 if test "${ac_cv_c_compil-
er_gnu+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h"
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_compiler_gnu=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_compiler_gnu=no fi rm -f conftest.$ac_objext  conftest.$ac_ext
ac_cv_c_compiler_gnu=$ac_compiler_gnu

fi  echo  "$as_me:__oline__:  result:  $ac_cv_c_compiler_gnu" >&5
echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6  GCC=`test  $ac_compil-
er_gnu   =   yes   &&   echo   yes`  ac_test_CFLAGS=${CFLAGS+set}
ac_save_CFLAGS=$CFLAGS CFLAGS="-g" echo "$as_me:__oline__: check-
ing  whether  $CC  accepts -g" >&5 echo $ECHO_N "checking whether
$CC accepts -g... $ECHO_C" >&6 if test "${ac_cv_prog_cc_g+set}" =
set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h"

#ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {

  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_prog_cc_g=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_cv_prog_cc_g=no fi rm -f conftest.$ac_objext  conftest.$ac_ext
fi  echo  "$as_me:__oline__:  result:  $ac_cv_prog_cc_g" >&5 echo
"${ECHO_T}$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
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  for  ac_declaration in    ''   '#include <stdlib.h>'    'extern
"C" void std::exit (int) throw (); using  std::exit;'     'extern
"C"  void  std::exit (int); using std::exit;'    'extern "C" void
exit (int) throw ();'    'extern "C" void exit  (int);'     'void
exit (int);' do
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h" @%:@include <stdlib.h> $ac_declaration  #ifdef
F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int  F77_DUMMY_MAIN()  { return 1; } #endif int main () { exit
(42);
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  : else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
continue fi rm -f conftest.$ac_objext conftest.$ac_ext
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h" $ac_declaration #ifdef F77_DUMMY_MAIN #  ifdef
__cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main ()  {  exit
(42);
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5

$CPPFLAGS  $LDFLAGS  conftest.$ac_ext   $LIBS   >&5'   ac_compil-
er_gnu=$ac_cv_c_compiler_gnu

ac_aux_dir= for ac_dir in $srcdir $srcdir/.. $srcdir/../..; 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
  {  {  echo  "$as_me:__oline__: error: cannot find install-sh or
install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5 echo "$as_me:
error: cannot find install-sh or install.sh in $srcdir $srcdir/..
$srcdir/../.." >&2;}
   {  (exit  1);  exit  1;  };   }   fi   ac_config_guess="$SHELL
$ac_aux_dir/config.guess"  ac_config_sub="$SHELL $ac_aux_dir/con-
fig.sub"  ac_configure="$SHELL  $ac_aux_dir/configure"   #   This
should be Cygnus configure.

#   Make   sure  we  can  run  config.sub.   $ac_config_sub  sun4
>/dev/null 2>&1 ||
  { { echo "$as_me:__oline__: error: cannot  run  $ac_config_sub"
>&5 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
   { (exit 1); exit 1; }; }

echo  "$as_me:__oline__:  checking  build  system  type" >&5 echo
$ECHO_N "checking build  system  type...  $ECHO_C"  >&6  if  test
"${ac_cv_build+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  ac_cv_build_alias=$build_alias test -z "$ac_cv_build_alias" &&
  ac_cv_build_alias=`$ac_config_guess`           test          -z
"$ac_cv_build_alias" &&
  { { echo "$as_me:__oline__: error: cannot guess build type; you
must  specify  one"  >&5  echo "$as_me: error: cannot guess build
type; you must specify one" >&2;}
   {  (exit  1);  exit  1;   };   }   ac_cv_build=`$ac_config_sub
$ac_cv_build_alias` ||
  {    {    echo    "$as_me:__oline__:    error:   $ac_config_sub
$ac_cv_build_alias failed." >&5  echo  "$as_me:  error:  $ac_con-
fig_sub $ac_cv_build_alias failed." >&2;}
   { (exit 1); exit 1; }; }

fi   echo   "$as_me:__oline__:  result:  $ac_cv_build"  >&5  echo
"${ECHO_T}$ac_cv_build"  >&6  build=$ac_cv_build  build_cpu=`echo
$ac_cv_build    |   sed   's/^-]*--]*-$/1/'`   build_vendor=`echo
   { (exit 1); exit 1; }; }

fi  echo  "$as_me:__oline__:  result:   $ac_cv_host"   >&5   echo
"${ECHO_T}$ac_cv_host"    >&6   host=$ac_cv_host   host_cpu=`echo
$ac_cv_host   |    sed    's/^-]*--]*-$/1/'`    host_vendor=`echo
$ac_cv_host  | sed 's/^-]*--]*-$/2/'` host_os=`echo $ac_cv_host |
sed 's/^-]*--]*-$/3/'`



echo "$as_me:__oline__: checking whether byte ordering is  bigen-
dian"  >&5 echo $ECHO_N "checking whether byte ordering is bigen-
dian... $ECHO_C" >&6 if test  "${ac_cv_c_bigendian+set}"  =  set;
then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  #  See  if sys/param.h defines the BYTE_ORDER macro.  cat >con-
ftest.$ac_ext  <<_ACEOF  #line  __oline__  "configure"   #include
"confdefs.h" #include <sys/types.h> #include <sys/param.h>

#ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int  F77_DUMMY_MAIN()  {  return 1; } #endif int main () { #if
!BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN
 bogus endian macros #endif

  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  #  It  does;  now  see whether it defined to BIG_ENDIAN or not.
cat >conftest.$ac_ext <<_ACEOF #line __oline__  "configure"  #in-
clude "confdefs.h" #include <sys/types.h> #include <sys/param.h>

#ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int  F77_DUMMY_MAIN()  {  return 1; } #endif int main () { #if
BYTE_ORDER != BIG_ENDIAN
 not big endian #endif

  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5

# It does not; compile a test program.  if  test  "$cross_compil-
ing" = yes; then
  #  try to guess the endianess by grep'ing values into an object
file
  ac_cv_c_bigendian=unknown
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude  "confdefs.h"  short ascii_mm[] = { 0x4249, 0x4765, 0x6E44,
0x6961, 0x6E53, 0x7953, 0 }; short ascii_ii[] = { 0x694C, 0x5454,
0x656C,  0x6E45,  0x6944, 0x6E61, 0 }; void _ascii () { char *s =
(char *) ascii_mm; s = (char *) ascii_ii; } short ebcdic_ii[] = {
0x89D3,  0xE3E3,  0x8593,  0x95C5,  0x89C4,  0x9581,  0  }; short
ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0
};  void  _ebcdic () { char *s = (char *) ebcdic_mm; s = (char *)
ebcdic_ii; } #ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 _ascii (); _ebcdic ();
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  if fgrep BIGenDianSyS conftest.$ac_objext >/dev/null ; then
  ac_cv_c_bigendian=yes fi if fgrep LiTTleEnDian conftest.$ac_ob-
jext >/dev/null ; then
  if test "$ac_cv_c_bigendian" = unknown; then
    ac_cv_c_bigendian=no
  else
    # finding both strings is unlikely to happen, but who  knows?
    ac_cv_c_bigendian=unknown
  fi fi else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
fi rm -f conftest.$ac_objext conftest.$ac_ext else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h" int main () {
  /* Are we little or big endian?  From Harbison&Steele.  */
  union
  {
    long l;
    char c[sizeof (long)];
  } u;
  u.l = 1;
  exit  (u.c[sizeof  (long)  -  1]  ==  1);  }  _ACEOF rm -f con-
ftest$ac_exeext if { (eval echo "$as_me:__oline__:
ftest.$ac_objext conftest.$ac_ext fi echo "$as_me:__oline__:  re-
sult:  $ac_cv_c_bigendian" >&5 echo "${ECHO_T}$ac_cv_c_bigendian"
>&6 case $ac_cv_c_bigendian in
  yes)

cat >>confdefs.h <<_ACEOF @%:@define WORDS_BIGENDIAN 1 _ACEOF
 ;;
  no)
     ;;
  *)
    { { echo "$as_me:__oline__: error: unknown endianess  preset-
ting  ac_cv_c_bigendian=no  (or yes) will help" >&5 echo "$as_me:
error: unknown endianess presetting ac_cv_c_bigendian=no (or yes)
will help" >&2;}
   { (exit 1); exit 1; }; } ;; esac


#  Checks for programs.  ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_com-
pile='$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     echo
"$as_me:__oline__:  checking  how  to run the C preprocessor" >&5
echo $ECHO_N "checking how to run the C preprocessor...  $ECHO_C"
>&6  #  On  Suns,  sometimes  $CPP names a directory.  if test -n
"$CPP" && test -d "$CPP"; then
  CPP= fi if test -z "$CPP"; then
  if test "${ac_cv_prog_CPP+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&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.
  # On the NeXT, cc -E runs the code through the compiler's pars-
er,
  # not just through cpp. "Syntax error" is here  to  catch  this
case.
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h" @%:@include <assert.h>
                     Syntax  error  _ACEOF  if   {   (eval   echo
"$as_me:__oline__:
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  egrep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
  else

(eval echo "$as_me:__oline__:
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  egrep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
  else
    ac_cpp_err=
  fi else
  ac_cpp_err=yes fi if test -z "$ac_cpp_err"; then
  # Broken: success on invalid input.  continue else
  echo "$as_me: failed program was:" >&5
  cat conftest.$ac_ext >&5
  #  Passes  both  tests.   ac_preproc_ok=:  break  fi rm -f con-
ftest.err conftest.$ac_ext

done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was
skipped.   rm -f 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 echo  "$as_me:__oline__:  result:  $CPP"
>&5  echo  "${ECHO_T}$CPP"  >&6 ac_preproc_ok=false for ac_c_pre-
proc_warn_flag in '' yes do
  # Use a header file that comes with gcc, so configuring glibc
  # with a fresh cross-compiler works.
  # On the NeXT, cc -E runs the code through the compiler's pars-
er,
  #  not  just  through cpp. "Syntax error" is here to catch this
case.
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h" @%:@include <assert.h>
                     Syntax   error   _ACEOF   if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  egrep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag

clude  "confdefs.h"  @%:@include  <ac_nonexistent.h>  _ACEOF if {
(eval echo "$as_me:__oline__:
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  egrep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
  else
    ac_cpp_err=
  fi else
  ac_cpp_err=yes fi if test -z "$ac_cpp_err"; then
  # Broken: success on invalid input.  continue else
  echo "$as_me: failed program was:" >&5
  cat conftest.$ac_ext >&5
  # Passes both tests.   ac_preproc_ok=:  break  fi  rm  -f  con-
ftest.err conftest.$ac_ext

done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was
skipped.  rm -f conftest.err conftest.$ac_ext if  $ac_preproc_ok;
then
  : else
  { { echo "$as_me:__oline__: error: C preprocessor echo "$as_me:
error: C preprocessor
   { (exit 1); exit 1; }; } fi

ac_ext=c  ac_cpp='$CPP  $CPPFLAGS'  ac_compile='$CC  -c   $CFLAGS
$CPPFLAGS  conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exe-
ext  $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}ranlib", so it
can be a program name with args.  set dummy ${ac_tool_prefix}ran-
lib;  ac_word=$2  echo  "$as_me:__oline__: checking for $ac_word"
>&5 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6  if  test
"${ac_cv_prog_RANLIB+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  if test -n "$RANLIB"; then
  ac_cv_prog_RANLIB="$RANLIB"  #  Let the user override the test.
else
  ac_save_IFS=$IFS; IFS=$ac_path_separator  ac_dummy="$PATH"  for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  $as_executable_p "$ac_dir/$ac_word" || continue ac_cv_prog_RAN-
LIB="${ac_tool_prefix}ranlib"   echo   "$as_me:__oline__:   found
$ac_dir/$ac_word" >&5 break done

  if test -n "$ac_ct_RANLIB"; then
  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override
the test.  else
  ac_save_IFS=$IFS; IFS=$ac_path_separator  ac_dummy="$PATH"  for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  $as_executable_p       "$ac_dir/$ac_word"      ||      continue
ac_cv_prog_ac_ct_RANLIB="ranlib"  echo  "$as_me:__oline__:  found
$ac_dir/$ac_word" >&5 break done

  test  -z  "$ac_cv_prog_ac_ct_RANLIB"  &&  ac_cv_prog_ac_ct_RAN-
LIB=":" fi fi ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB  if  test  -n
"$ac_ct_RANLIB"; then
  echo   "$as_me:__oline__:   result:   $ac_ct_RANLIB"  >&5  echo
"${ECHO_T}$ac_ct_RANLIB" >&6 else
  echo "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no"  >&6
fi

  RANLIB=$ac_ct_RANLIB else
  RANLIB="$ac_cv_prog_RANLIB" fi

# 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"  #  ./install,  which  can be erroneously created by make
from ./install.sh.  echo "$as_me:__oline__: checking  for  a  BSD
compatible install" >&5 echo $ECHO_N "checking for a BSD compati-
ble install... $ECHO_C" >&6 if test -z "$INSTALL"; then  if  test
"${ac_cv_path_install+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
    ac_save_IFS=$IFS; IFS=$ac_path_separator
  for ac_dir in $PATH; do
    IFS=$ac_save_IFS
    #  Account  for  people who put trailing slashes in PATH ele-
ments.
    case $ac_dir/ in
    / | ./ | .// | /cC/*     | /etc/* | /usr/sbin/* |  /usr/etc/*
| /sbin/* | /usr/afsws/bin/*     | /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
        if $as_executable_p "$ac_dir/$ac_prog"; then           if
test $ac_prog = install &&
  if test "${ac_cv_path_install+set}" = set; then
    INSTALL=$ac_cv_path_install
  else
    # As a last resort, use the  slow  shell  script.   We  don't
cache a
    #  path  for  INSTALL within a source directory, because that
will
    # break other packages using the cache if that directory is
    # removed, or if the path is relative.
    INSTALL=$ac_install_sh
  fi  fi  echo  "$as_me:__oline__:  result:  $INSTALL"  >&5  echo
"${ECHO_T}$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'

#  Extract  the  first  word of "ar", so it can be a program name
with args.  set  dummy  ar;  ac_word=$2  echo  "$as_me:__oline__:
checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word...
$ECHO_C" >&6 if test "${ac_cv_path_AR+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $AR in
  [\/]* | ?:[\/]*)
  ac_cv_path_AR="$AR" # Let the user override  the  test  with  a
path.
  ;;
  *)
  ac_save_IFS=$IFS;  IFS=$ac_path_separator  ac_dummy="$PATH" for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  if $as_executable_p "$ac_dir/$ac_word"; then
   ac_cv_path_AR="$ac_dir/$ac_word"
   echo "$as_me:__oline__: found $ac_dir/$ac_word" >&5
   break fi done

  ;; esac fi AR=$ac_cv_path_AR

if test -n "$AR"; then
  echo "$as_me:__oline__: result: $AR"  >&5  echo  "${ECHO_T}$AR"
>&6 else
  echo  "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no" >&6
fi

for ac_prog in perl5 perl do
  # Extract the first word of "$ac_prog", so it can be a  program
name   with   args.    set   dummy   $ac_prog;   ac_word=$2  echo
  if $as_executable_p "$ac_dir/$ac_word"; then
   ac_cv_path_PERL="$ac_dir/$ac_word"
   echo "$as_me:__oline__: found $ac_dir/$ac_word" >&5
   break fi done

  ;; esac fi PERL=$ac_cv_path_PERL

if test -n "$PERL"; then
  echo    "$as_me:__oline__:    result:    $PERL"    >&5     echo
"${ECHO_T}$PERL" >&6 else
  echo  "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no" >&6
fi

  test -n "$PERL" && break done


# Extract the first word of "ent", so it can be  a  program  name
with  args.   set  dummy  ent; ac_word=$2 echo "$as_me:__oline__:
checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word...
$ECHO_C" >&6 if test "${ac_cv_path_ENT+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $ENT in
  [\/]* | ?:[\/]*)
  ac_cv_path_ENT="$ENT"  #  Let the user override the test with a
path.
  ;;
  *)
  ac_save_IFS=$IFS; IFS=$ac_path_separator  ac_dummy="$PATH"  for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  if $as_executable_p "$ac_dir/$ac_word"; then
   ac_cv_path_ENT="$ac_dir/$ac_word"
   echo "$as_me:__oline__: found $ac_dir/$ac_word" >&5
   break fi done

  ;; esac fi ENT=$ac_cv_path_ENT

if test -n "$ENT"; then
  echo  "$as_me:__oline__: result: $ENT" >&5 echo "${ECHO_T}$ENT"
>&6 else
  echo "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no"  >&6
fi


for ac_prog in filepriv do
  #  Extract the first word of "$ac_prog", so it can be a program
name  with   args.    set   dummy   $ac_prog;   ac_word=$2   echo
"$as_me:__oline__:   checking  for  $ac_word"  >&5  echo  $ECHO_N
"checking    for    $ac_word...    $ECHO_C"    >&6    if     test
"${ac_cv_path_FILEPRIV+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

  ;; esac fi FILEPRIV=$ac_cv_path_FILEPRIV

if test -n "$FILEPRIV"; then
  echo    "$as_me:__oline__:    result:   $FILEPRIV"   >&5   echo
"${ECHO_T}$FILEPRIV" >&6 else
  echo "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no"  >&6
fi

  test  -n  "$FILEPRIV"  &&  break  done  test  -n "$FILEPRIV" ||
FILEPRIV="true"

# Extract the first word of "bash", so it can be a  program  name
with  args.   set  dummy bash; ac_word=$2 echo "$as_me:__oline__:
checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word...
$ECHO_C"  >&6  if test "${ac_cv_path_TEST_MINUS_S_SH+set}" = set;
then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $TEST_MINUS_S_SH in
  [\/]* | ?:[\/]*)
  ac_cv_path_TEST_MINUS_S_SH="$TEST_MINUS_S_SH" #  Let  the  user
override the test with a path.
  ;;
  *)
  ac_save_IFS=$IFS;  IFS=$ac_path_separator  ac_dummy="$PATH" for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  if $as_executable_p "$ac_dir/$ac_word"; then
   ac_cv_path_TEST_MINUS_S_SH="$ac_dir/$ac_word"
   echo "$as_me:__oline__: found $ac_dir/$ac_word" >&5
   break fi done

  ;; esac fi TEST_MINUS_S_SH=$ac_cv_path_TEST_MINUS_S_SH

if test -n "$TEST_MINUS_S_SH"; then
  echo  "$as_me:__oline__:  result:  $TEST_MINUS_S_SH"  >&5  echo
"${ECHO_T}$TEST_MINUS_S_SH" >&6 else
  echo  "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no" >&6
fi

# Extract the first word of "ksh", so it can be  a  program  name
with  args.   set  dummy  ksh; ac_word=$2 echo "$as_me:__oline__:
checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word...
$ECHO_C"  >&6  if test "${ac_cv_path_TEST_MINUS_S_SH+set}" = set;
then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $TEST_MINUS_S_SH in
  [\/]* | ?:[\/]*)
  ac_cv_path_TEST_MINUS_S_SH="$TEST_MINUS_S_SH" #  Let  the  user
override the test with a path.
  ;;

"${ECHO_T}$TEST_MINUS_S_SH" >&6 else
  echo  "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no" >&6
fi

# Extract the first word of "sh", so it can  be  a  program  name
with  args.   set  dummy  sh;  ac_word=$2 echo "$as_me:__oline__:
checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word...
$ECHO_C"  >&6  if test "${ac_cv_path_TEST_MINUS_S_SH+set}" = set;
then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $TEST_MINUS_S_SH in
  [\/]* | ?:[\/]*)
  ac_cv_path_TEST_MINUS_S_SH="$TEST_MINUS_S_SH" #  Let  the  user
override the test with a path.
  ;;
  *)
  ac_save_IFS=$IFS;  IFS=$ac_path_separator  ac_dummy="$PATH" for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  if $as_executable_p "$ac_dir/$ac_word"; then
   ac_cv_path_TEST_MINUS_S_SH="$ac_dir/$ac_word"
   echo "$as_me:__oline__: found $ac_dir/$ac_word" >&5
   break fi done

  ;; esac fi TEST_MINUS_S_SH=$ac_cv_path_TEST_MINUS_S_SH

if test -n "$TEST_MINUS_S_SH"; then
  echo  "$as_me:__oline__:  result:  $TEST_MINUS_S_SH"  >&5  echo
"${ECHO_T}$TEST_MINUS_S_SH" >&6 else
  echo  "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no" >&6
fi


# System features # Check whether  --enable-largefile  or  --dis-
able-largefile  was  given.   if test "${enable_largefile+set}" =
set; then
  enableval="$enable_largefile"

fi; if test "$enable_largefile" != no; then

  echo "$as_me:__oline__: checking for special C compiler options
needed  for large files" >&5 echo $ECHO_N "checking for special C
compiler options needed for large files... $ECHO_C" >&6  if  test
"${ac_cv_sys_largefile_CC+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  ac_cv_sys_largefile_CC=no
     if test "$GCC" != yes; then
       ac_save_CC=$CC
       while :; do
          #  IRIX 6.2 and later do not support large files by de-
fault,

  ;
  return 0; } _ACEOF
           rm   -f   conftest.$ac_objext   if   {   (eval    echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  break else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
fi rm -f conftest.$ac_objext
         CC="$CC -n32"
           rm   -f   conftest.$ac_objext   if   {   (eval    echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_sys_largefile_CC=' -n32'; break else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
fi rm -f conftest.$ac_objext
         break
       done
       CC=$ac_save_CC
       rm -f conftest.$ac_ext
    fi  fi  echo  "$as_me:__oline__:  result:   $ac_cv_sys_large-
file_CC" >&5 echo "${ECHO_T}$ac_cv_sys_largefile_CC" >&6
  if test "$ac_cv_sys_largefile_CC" != no; then
    CC=$CC$ac_cv_sys_largefile_CC
  fi

  echo  "$as_me:__oline__:  checking  for _FILE_OFFSET_BITS value
needed for large files" >&5 echo $ECHO_N "checking for _FILE_OFF-
SET_BITS  value  needed  for  large files... $ECHO_C" >&6 if test
"${ac_cv_sys_file_offset_bits+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  while :; do
  ac_cv_sys_file_offset_bits=no
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  break else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
fi rm -f conftest.$ac_objext conftest.$ac_ext
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude  "confdefs.h"  @%:@define  _FILE_OFFSET_BITS 64 @%:@include
exit(2);
  exit  (0);  }  _ACEOF  rm -f conftest$ac_exeext if { (eval echo
"$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5

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  memo-
ry.h  strings.h                   inttypes.h stdint.h unistd.h do
as_ac_Header=`echo "ac_cv_header_$ac_header"  |  $as_tr_sh`  echo
"$as_me:__oline__:  checking  for  $ac_header"  >&5  echo $ECHO_N
"checking for $ac_header... $ECHO_C" >&6 if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h" $ac_includes_default

@%:@include  <$ac_header>  _ACEOF  rm -f conftest.$ac_objext if {
(eval echo "$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  eval "$as_ac_Header=yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
eval   "$as_ac_Header=no"   fi  rm  -f  conftest.$ac_objext  con-
ftest.$ac_ext  fi  echo  "$as_me:__oline__:  result:  `eval  echo
'${'$as_ac_Header'}'`"     >&5    echo    "${ECHO_T}`eval    echo
'${'$as_ac_Header'}'`" >&6 if test  `eval  echo  '${'$as_ac_Head-
er'}'` = yes; then
  cat  >>confdefs.h <<_ACEOF @%:@define `echo "HAVE_$ac_header" |
$as_tr_cpp` 1 _ACEOF

fi

done



# Check whether --with-pcre or --without-pcre was given.  if test
"${with_pcre+set}" = set; then
  withval="$with_pcre"

"${need_dash_r}";                                            then
                                                LD-
FLAGS="-L${withval}           -R${withval}            ${LDFLAGS}"
                                        else
                                                LD-
FLAGS="-L${withval}                                   ${LDFLAGS}"
                                        fi
                                fi
                                if  test  -d  "$withval/include";
then                                          CPPFLAGS="-I${with-
val}/include  ${CPPFLAGS}"                                   else
                                        CPPFLAGS="-I${withval}
${CPPFLAGS}"                                                   fi
                        fi

                        if test "${ac_cv_header_pcreposix_h+set}"
= set; then
  echo "$as_me:__oline__:  checking  for  pcreposix.h"  >&5  echo
$ECHO_N   "checking  for  pcreposix.h...  $ECHO_C"  >&6  if  test
"${ac_cv_header_pcreposix_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 fi echo  "$as_me:__oline__:
result:         $ac_cv_header_pcreposix_h"        >&5        echo
"${ECHO_T}$ac_cv_header_pcreposix_h" >&6 else
  # Is the header compilable?  echo  "$as_me:__oline__:  checking
pcreposix.h usability" >&5 echo $ECHO_N "checking pcreposix.h us-
ability... $ECHO_C"  >&6  cat  >conftest.$ac_ext  <<_ACEOF  #line
__oline__  "configure" #include "confdefs.h" $ac_includes_default
@%:@include <pcreposix.h> _ACEOF rm -f conftest.$ac_objext  if  {
(eval echo "$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_header_compiler=no   fi   rm   -f   conftest.$ac_objext   con-
ftest.$ac_ext  echo "$as_me:__oline__: result: $ac_header_compil-
er" >&5 echo "${ECHO_T}$ac_header_compiler" >&6

#  Is  the  header  present?   echo  "$as_me:__oline__:  checking
pcreposix.h  presence"  >&5  echo  $ECHO_N  "checking pcreposix.h
presence... $ECHO_C" >&6  cat  >conftest.$ac_ext  <<_ACEOF  #line
__oline__    "configure"    #include   "confdefs.h"   @%:@include
conftest.$ac_ext  <<_ACEOF  #line __oline__ "configure" #include
"confdefs.h"

/* Override any gcc2 internal prototype to avoid  an  error.   */
#ifdef  __cplusplus  extern "C" #endif /* We use char because int
might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char innetgr (); #ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () { innet-
gr ();
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_rpc_innetgr=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_cv_lib_rpc_innetgr=no  fi  rm  -f   conftest.$ac_objext   con-
ftest$ac_exeext  conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi
echo "$as_me:__oline__: result: $ac_cv_lib_rpc_innetgr" >&5  echo
"${ECHO_T}$ac_cv_lib_rpc_innetgr"  >&6 if test $ac_cv_lib_rpc_in-
netgr = yes; then
  LIBS="-lrpc -lyp -lrpc $LIBS" fi

    fi fi

echo "$as_me:__oline__: checking for getspnam" >&5  echo  $ECHO_N
"checking for getspnam... $ECHO_C" >&6 if test "${ac_cv_func_get-
   int F77_DUMMY_MAIN() { return 1; } #endif int main () { /* 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_getspnam) || defined (__stub___getspnam)
choke me #else f = getspnam; #endif

  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_func_getspnam=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_cv_func_getspnam=no  fi   rm   -f   conftest.$ac_objext   con-
ftest$ac_exeext  conftest.$ac_ext  fi echo "$as_me:__oline__: re-
sult: $ac_cv_func_getspnam" >&5 echo "${ECHO_T}$ac_cv_func_getsp-
nam" >&6 if test $ac_cv_func_getspnam = yes; then
  : else
  echo  "$as_me:__oline__:  checking  for  getspnam in -lgen" >&5
echo $ECHO_N "checking for getspnam in -lgen... $ECHO_C"  >&6  if
test "${ac_cv_lib_gen_getspnam+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  ac_check_lib_save_LIBS=$LIBS   LIBS="-lgen   $LIBS"  cat  >con-
ftest.$ac_ext  <<_ACEOF  #line  __oline__  "configure"   #include
"confdefs.h"

/*  Override  any  gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus extern "C" #endif /* We use char  because  int
might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char getspnam (); #ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () { getsp-
nam ();
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest$ac_exeext'

fi



# Check whether --with-zlib or --without-zlib was given.  if test
"${with_zlib+set}" = set; then
  withval="$with_zlib"

                if     test     -d      "$withval/lib";      then
                        if   test   -n   "${need_dash_r}";   then
                                LDFLAGS="-L${withval}/lib
-R${withval}/lib     ${LDFLAGS}"                             else
                                LDFLAGS="-L${withval}/lib   ${LD-
FLAGS}"                              fi                      else
                        if   test   -n   "${need_dash_r}";   then
                                LDFLAGS="-L${withval}   -R${with-
val}           ${LDFLAGS}"                                   else
                                LDFLAGS="-L${withval} ${LDFLAGS}"
                        fi                 fi                  if
test            -d            "$withval/include";            then
                        CPPFLAGS="-I${withval}/include
${CPPFLAGS}"                                                 else
                        CPPFLAGS="-I${withval}       ${CPPFLAGS}"
                fi

fi;


echo  "$as_me:__oline__:  checking  for  deflate in -lz" >&5 echo
$ECHO_N "checking for deflate in  -lz...  $ECHO_C"  >&6  if  test
"${ac_cv_lib_z_deflate+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  ac_check_lib_save_LIBS=$LIBS   LIBS="-lz    $LIBS"   cat  >con-
ftest.$ac_ext  <<_ACEOF  #line  __oline__  "configure"   #include
"confdefs.h"

/*  Override  any  gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus extern "C" #endif /* We use char  because  int
might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char deflate (); #ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main  ()  {  de-
flate ();
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest$ac_exeext'

  LIBS="-lz $LIBS"

else
  {  {  echo  "$as_me:__oline__: error: *** zlib missing - please
install first or check config.log ***" >&5 echo  "$as_me:  error:
***  zlib missing - please install first or check config.log ***"
>&2;}
   { (exit 1); exit 1; }; } fi


# We don't want to check if we did an pcre override.  if test  -z
"$no_comp_check"  ; then         echo "$as_me:__oline__: checking
for regcomp" >&5 echo $ECHO_N "checking for  regcomp...  $ECHO_C"
>&6 if test "${ac_cv_func_regcomp+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h" /* System header to define __stub  macros  and
hopefully few prototypes,
    which  can conflict with char regcomp (); below.  */ #include
hosts_access(0);
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then

                                        echo   "$as_me:__oline__:
result:      yes"      >&5      echo      "${ECHO_T}yes"      >&6
                                        cat >>confdefs.h <<_ACEOF
@%:@define LIBWRAP 1 _ACEOF

                                        TCPW_MSG="yes"
                                 else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5

                                        {         {          echo
"$as_me:__oline__:  error: *** libwrap missing" >&5 echo "$as_me:
error: *** libwrap missing" >&2;}
   { (exit 1);  exit  1;  };  }
                           fi   rm  -f  conftest.$ac_objext  con-
ftest$ac_exeext conftest.$ac_ext                 fi

fi;















































for ac_func in arc4random atexit b64_ntop  bcopy  bindresvport_sa
        clock  fchmod  fchown  freeaddrinfo  futimes gai_strerror
 getaddrinfo getcwd getgrouplist getnameinfo  getopt    getrlimit
getrusage  getttyent  glob  inet_aton inet_ntoa         inet_ntop
innetgr  login_getcapbool  md5_crypt  memmove   mkdtemp   on_exit
openpty  readpassphrase  realpath     rresvport_af  setdtablesize
setegid setenv seteuid     setlogin  setproctitle  setresgid  se-
treuid setrlimit         setsid setvbuf sigaction sigvec snprintf
strerror        strlcat strlcpy strmode strsep sysconf  tcgetpgrp
utimes          vhangup  vsnprintf  waitpid __b64_ntop _getpty do
#ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () { /* 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_$ac_func) || defined (__stub___$ac_func)
choke me #else f = $ac_func; #endif

  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  eval "$as_ac_var=yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
eval "$as_ac_var=no" fi rm -f conftest.$ac_objext conftest$ac_ex-
eext  conftest.$ac_ext  fi  echo "$as_me:__oline__: result: `eval
echo   '${'$as_ac_var'}'`"   >&5   echo   "${ECHO_T}`eval    echo
'${'$as_ac_var'}'`"  >&6  if test `eval echo '${'$as_ac_var'}'` =
yes; then
  cat >>confdefs.h <<_ACEOF @%:@define  `echo  "HAVE_$ac_func"  |
$as_tr_cpp` 1 _ACEOF

fi done



for ac_func in dirname do as_ac_var=`echo "ac_cv_func_$ac_func" |
$as_tr_sh` echo "$as_me:__oline__:  checking  for  $ac_func"  >&5
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6 if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude  "confdefs.h"  /* System header to define __stub macros and
hopefully few prototypes,
    which can conflict with char $ac_func (); below.  */ #include
exit(1);
    } else {         exit(0);
    }  }                                    _ACEOF  rm  -f   con-
ftest$ac_exeext if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_broken_dirname="no" else
  echo  "$as_me:  program exited with status $ac_status" >&5 echo

$ECHO_N "checking for $ac_header... $ECHO_C" >&6 if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 fi echo  "$as_me:__oline__:
result:    `eval    echo    '${'$as_ac_Header'}'`"    >&5    echo
"${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 else
  # Is the header compilable?  echo  "$as_me:__oline__:  checking
$ac_header  usability"  >&5 echo $ECHO_N "checking $ac_header us-
ability... $ECHO_C"  >&6  cat  >conftest.$ac_ext  <<_ACEOF  #line
__oline__  "configure" #include "confdefs.h" $ac_includes_default
@%:@include <$ac_header> _ACEOF rm -f  conftest.$ac_objext  if  {
(eval echo "$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_header_compiler=no   fi   rm   -f   conftest.$ac_objext   con-
ftest.$ac_ext  echo "$as_me:__oline__: result: $ac_header_compil-
er" >&5 echo "${ECHO_T}$ac_header_compiler" >&6

#  Is  the  header  present?   echo  "$as_me:__oline__:  checking
$ac_header  presence" >&5 echo $ECHO_N "checking $ac_header pres-
ence...  $ECHO_C"  >&6  cat  >conftest.$ac_ext   <<_ACEOF   #line
__oline__    "configure"    #include   "confdefs.h"   @%:@include
<$ac_header> _ACEOF if { (eval echo "$as_me:__oline__:
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  egrep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
  else
    ac_cpp_err=
  fi else
  ac_cpp_err=yes fi if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes else
  echo "$as_me: failed program was:" >&5
  cat conftest.$ac_ext >&5
  ac_header_preproc=no fi  rm  -f  conftest.err  conftest.$ac_ext
echo  "$as_me:__oline__:  result:  $ac_header_preproc"  >&5  echo
"${ECHO_T}$ac_header_preproc" >&6

#  So?   What  about  this   header?    case   $ac_header_compil-
missing   prerequisite   headers?"  >&5  echo  "$as_me:  WARNING:
$ac_header: check for missing prerequisite headers?" >&2;}
    { echo  "$as_me:__oline__:  WARNING:  $ac_header:  proceeding
with  the  preprocessor's  result"  >&5  echo  "$as_me:  WARNING:
$ac_header: proceeding with the  preprocessor's  result"  >&2;};;
esac  echo  "$as_me:__oline__:  checking for $ac_header" >&5 echo
$ECHO_N "checking for $ac_header... $ECHO_C" >&6 if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  eval      "$as_ac_Header=$ac_header_preproc"      fi       echo
"$as_me:__oline__:  result: `eval echo '${'$as_ac_Header'}'`" >&5
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

fi if test `eval echo '${'$as_ac_Header'}'` = yes; then
  cat >>confdefs.h <<_ACEOF @%:@define `echo "HAVE_$ac_header"  |
$as_tr_cpp` 1 _ACEOF

fi

done

                fi          fi


fi done




for    ac_func    in   gettimeofday   time   do   as_ac_var=`echo
"ac_cv_func_$ac_func" | $as_tr_sh` echo "$as_me:__oline__: check-
ing  for  $ac_func"  >&5  echo  $ECHO_N "checking for $ac_func...
$ECHO_C" >&6 if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude  "confdefs.h"  /* System header to define __stub macros and
hopefully few prototypes,
    which can conflict with char $ac_func (); below.  */ #include
exit(1);
  else if (child == 0)
    {
      np = getpid ();
      /*  If this is Sys V, this will not work; pgrp will be  set
to np          because setpgrp just changes a pgrp to be the same
as the          pid.  */
      setpgrp (np, pg1);
      ng = getpgrp (0);        /* Same result for Sys V  and  BSD
*/
      if (ng == pg1)
        exit (1);
      else
        exit (0);
    }
  else
    {
      wait (&s);
      exit (s>>8);

  echo "$as_me: program exited with status $ac_status"  >&5  echo
"$as_me:  failed  program  was:"  >&5  cat  conftest.$ac_ext  >&5
ac_cv_func_getpgrp_void=no fi  rm  -f  core  core.*  *.core  con-
ftest$ac_exeext  conftest.$ac_objext conftest.$ac_ext fi;; esac #
$ac_func_getpgrp_0:$ac_func_getpgrp_1

fi echo "$as_me:__oline__: result: $ac_cv_func_getpgrp_void"  >&5
echo     "${ECHO_T}$ac_cv_func_getpgrp_void"    >&6    if    test
$ac_cv_func_getpgrp_void = yes; then

cat >>confdefs.h <<_ACEOF @%:@define GETPGRP_VOID 1 _ACEOF

fi


# Check for PAM libs PAM_MSG="no"

# Check whether --with-pam or --without-pam was given.   if  test
"${with_pam+set}" = set; then
  withval="$with_pam"

                if    test    "x$withval"   !=   "xno"   ;   then
                        if test  "x$ac_cv_header_security_pam_ap-
pl_h"  !=  "xyes" ; then                                 { { echo
"$as_me:__oline__:  error:  PAM  headers  not  found"  >&5   echo
"$as_me: error: PAM headers not found" >&2;}
   { (exit 1); exit 1; }; }                         fi

                          echo  "$as_me:__oline__:  checking  for
dlopen in -ldl" >&5 echo $ECHO_N "checking for dlopen in  -ldl...
$ECHO_C" >&6 if test "${ac_cv_lib_dl_dlopen+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  ac_check_lib_save_LIBS=$LIBS   LIBS="-ldl    $LIBS"  cat  >con-
ftest.$ac_ext  <<_ACEOF  #line  __oline__  "configure"   #include
"confdefs.h"

/*  Override  any  gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus extern "C" #endif /* We use char  because  int
might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char dlopen (); #ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () { dlopen
();
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest$ac_exeext'

  LIBS="-ldl $LIBS"

fi

                          echo  "$as_me:__oline__:  checking  for
pam_set_item  in  -lpam"   >&5   echo   $ECHO_N   "checking   for
pam_set_item     in     -lpam...    $ECHO_C"    >&6    if    test
"${ac_cv_lib_pam_pam_set_item+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  ac_check_lib_save_LIBS=$LIBS  LIBS="-lpam   $LIBS"  cat   >con-
ftest.$ac_ext   <<_ACEOF  #line  __oline__  "configure"  #include
"confdefs.h"

/* Override any gcc2 internal prototype to avoid  an  error.   */
#ifdef  __cplusplus  extern "C" #endif /* We use char because int
might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char pam_set_item (); #ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int  F77_DUMMY_MAIN()  {  return  1;  }  #endif  int main () {
pam_set_item ();
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_pam_pam_set_item=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_cv_lib_pam_pam_set_item=no fi rm -f  conftest.$ac_objext  con-
ftest$ac_exeext  conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi
echo "$as_me:__oline__: result: $ac_cv_lib_pam_pam_set_item"  >&5
echo    "${ECHO_T}$ac_cv_lib_pam_pam_set_item"    >&6   if   test
$ac_cv_lib_pam_pam_set_item = yes; then
  cat >>confdefs.h <<_ACEOF @%:@define HAVE_LIBPAM 1 _ACEOF

  LIBS="-lpam $LIBS"

else
  { { echo "$as_me:__oline__: error: *** libpam missing" >&5 echo
"$as_me: error: *** libpam missing" >&2;}
   { (exit 1); exit 1; }; } fi

                           for   ac_func   in  pam_getenvlist  do
as_ac_var=`echo   "ac_cv_func_$ac_func"   |    $as_tr_sh`    echo
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () { /* 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_$ac_func) || defined (__stub___$ac_func)
choke me #else f = $ac_func; #endif

  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  eval "$as_ac_var=yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
eval "$as_ac_var=no" fi rm -f conftest.$ac_objext conftest$ac_ex-
eext  conftest.$ac_ext  fi  echo "$as_me:__oline__: result: `eval
echo   '${'$as_ac_var'}'`"   >&5   echo   "${ECHO_T}`eval    echo
'${'$as_ac_var'}'`"  >&6  if test `eval echo '${'$as_ac_var'}'` =
yes; then
  cat >>confdefs.h <<_ACEOF @%:@define  `echo  "HAVE_$ac_func"  |
$as_tr_cpp` 1 _ACEOF

fi done


                        disable_shadow=yes
                        PAM_MSG="yes"

                        cat  >>confdefs.h   <<_ACEOF   @%:@define
USE_PAM 1 _ACEOF

                fi

fi;

#  Check  for  older  PAM  if  test  "x$PAM_MSG"  = "xyes" ; then
        # Check PAM strerror  arguments  (old  PAM)          echo
"$as_me:__oline__:  checking  whether pam_strerror takes only one
argument" >&5 echo $ECHO_N "checking whether  pam_strerror  takes
only  one  argument... $ECHO_C" >&6         cat >conftest.$ac_ext
<<_ACEOF #line __oline__ "configure" #include "confdefs.h"

  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  echo  "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no" >&6
else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5

                        cat   >>confdefs.h   <<_ACEOF  @%:@define
HAVE_OLD_PAM 1 _ACEOF

                        echo "$as_me:__oline__: result: yes"  >&5
echo "${ECHO_T}yes" >&6                         PAM_MSG="yes (old
library)"                           fi rm -f  conftest.$ac_objext
conftest.$ac_ext fi

# The big search for OpenSSL

#  Check  whether  --with-ssl-dir or --without-ssl-dir was given.
if test "${with_ssl_dir+set}" = set; then
  withval="$with_ssl_dir"

                if   test   "x$withval"   !=   "xno"    ;    then
                        tryssldir=$withval                     fi


fi;

saved_LIBS="$LIBS"                       saved_LDFLAGS="$LDFLAGS"
saved_CPPFLAGS="$CPPFLAGS"  if  test "x$prefix" != "xNONE" ; then
        tryssldir="$tryssldir $prefix" fi echo "$as_me:__oline__:
checking  for  OpenSSL  directory" >&5 echo $ECHO_N "checking for
OpenSSL     directory...      $ECHO_C"      >&6      if      test
"${ac_cv_openssldir+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        for    ssldir   in   $tryssldir   ""   /usr/local/openssl
/usr/lib/openssl /usr/local/ssl /usr/lib/ssl /usr/local  /usr/pkg
/opt /opt/openssl ; do                 CPPFLAGS="$saved_CPPFLAGS"
                LDFLAGS="$saved_LDFLAGS"
                LIBS="$saved_LIBS    -lcrypto"
                #  Skip   directories   if   they   don't   exist
                if  test  ! -z "$ssldir" -a ! -d "$ssldir" ; then
                        continue;                              fi
                if  test ! -z "$ssldir" -a "x$ssldir" != "x/usr";
then                         # Try to use $ssldir/lib if  it  ex-
ists,       otherwise                              #      $ssldir
                        if   test   -d   "$ssldir/lib"   ;   then
                                LDFLAGS="-L$ssldir/lib $saved_LD-
FLAGS"                                    if    test     !     -z
"$need_dash_r" ; then                                         LD-
FLAGS="-R$ssldir/lib $LDFLAGS"                                 fi
correct  linking                 # *does not* test for RSA - that
comes later.                  if test "$cross_compiling"  =  yes;
then
  {  {  echo  "$as_me:__oline__:  error:  cannot run test program
while cross compiling" >&5 echo "$as_me: error: cannot  run  test
program while cross compiling" >&2;}
   { (exit 1); exit 1; }; } else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h"

#include <string.h> #include <openssl/rand.h>  int  main(void)  {
        char    a[2048];            memset(a,    0,   sizeof(a));
        RAND_add(a,    sizeof(a),     sizeof(a));             re-
turn(RAND_status() <= 0); }                          _ACEOF rm -f
conftest$ac_exeext if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then

                                found_crypto=1
                                break;
else
  echo "$as_me: program exited with status $ac_status"  >&5  echo
"$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5

                  fi  rm -f core core.* *.core conftest$ac_exeext
conftest.$ac_objext conftest.$ac_ext fi

                if   test   !   -z   "$found_crypto"    ;    then
                        break;                 fi         done

        if  test  -z  "$found_crypto"  ; then                 { {
echo "$as_me:__oline__: error: Could not find working OpenSSL li-
brary,  please install or check config.log" >&5 echo "$as_me: er-
ror: Could not find working OpenSSL library,  please  install  or
check config.log" >&2;}
   {  (exit  1);  exit 1; }; }              fi         if test -z
"$ssldir" ; then                 ssldir="(system)"         fi

        ac_cv_openssldir=$ssldir

fi echo "$as_me:__oline__: result:  $ac_cv_openssldir"  >&5  echo
"${ECHO_T}$ac_cv_openssldir" >&6

if (test ! -z "$ac_cv_openssldir" && test "x$ac_cv_openssldir" !=
"x(system)") ; then         cat >>confdefs.h <<_ACEOF  @%:@define
Try    to   use   $ssldir/include   if   it   exists,   otherwise
                # $ssldir                 if test -d "$ssldir/in-
clude" ; then                         CPPFLAGS="-I$ssldir/include
$saved_CPPFLAGS"                                             else
                        CPPFLAGS="-I$ssldir      $saved_CPPFLAGS"
                fi         fi fi LIBS="$saved_LIBS -lcrypto"

# Now test RSA support saved_LIBS="$LIBS" echo "$as_me:__oline__:
checking for RSA support" >&5 echo $ECHO_N "checking for RSA sup-
port... $ECHO_C" >&6 for WANTS_RSAREF in ""  1  ;  do          if
test -z "$WANTS_RSAREF" ; then                 LIBS="$saved_LIBS"
        else                  LIBS="$saved_LIBS  -lRSAglue   -lr-
saref"         fi         if test "$cross_compiling" = yes; then
  {  {  echo  "$as_me:__oline__:  error:  cannot run test program
while cross compiling" >&5 echo "$as_me: error: cannot  run  test
program while cross compiling" >&2;}
   { (exit 1); exit 1; }; } else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h"

#include   <string.h>    #include    <openssl/rand.h>    #include
return(1);         num  =  RSA_public_encrypt(size-
of(p_in) - 1, p_in, c, key, RSA_PKCS1_PADDING);         return(-1
== RSA_private_decrypt(num, c,  p,  key,  RSA_PKCS1_PADDING));  }
           _ACEOF  rm  -f  conftest$ac_exeext  if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then

                rsa_works=1                 break;          else
  echo "$as_me: program exited with status $ac_status"  >&5  echo
"$as_me:  failed program was:" >&5 cat conftest.$ac_ext >&5 fi rm
-f core core.* *.core conftest$ac_exeext conftest.$ac_objext con-
ftest.$ac_ext fi done LIBS="$saved_LIBS"

if test ! -z "$no_rsa" ; then         echo "$as_me:__oline__: re-
sult:    disabled"    >&5    echo     "${ECHO_T}disabled"     >&6
        RSA_MSG="disabled" else         if test -z "$rsa_works" ;
then                 { echo "$as_me:__oline__:  WARNING:  ***  No
RSA  support  found  ***  " >&5 echo "$as_me: WARNING: *** No RSA
>&5 echo $ECHO_N "checking for crypt in -lcrypt...  $ECHO_C"  >&6
if test "${ac_cv_lib_crypt_crypt+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  ac_check_lib_save_LIBS=$LIBS  LIBS="-lcrypt   $LIBS"  cat >con-
ftest.$ac_ext  <<_ACEOF  #line  __oline__  "configure"   #include
"confdefs.h"

/*  Override  any  gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus extern "C" #endif /* We use char  because  int
might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char crypt (); #ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {  crypt
();
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_crypt_crypt=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_cv_lib_crypt_crypt=no   fi   rm  -f  conftest.$ac_objext  con-
ftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS  fi
echo  "$as_me:__oline__: result: $ac_cv_lib_crypt_crypt" >&5 echo
"${ECHO_T}$ac_cv_lib_crypt_crypt"       >&6        if        test
$ac_cv_lib_crypt_crypt = yes; then
  LIBS="$LIBS -lcrypt" fi

fi

#  Cheap hack to ensure NEWS-OS libraries are arranged right.  if
test ! -z "$SONY" ; then
  LIBS="$LIBS -liberty"; fi

# Checks for data  types  echo  "$as_me:__oline__:  checking  for
char" >&5 echo $ECHO_N "checking for char... $ECHO_C" >&6 if test
"${ac_cv_type_char+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude  "confdefs.h"  $ac_includes_default #ifdef F77_DUMMY_MAIN #
ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int  main  ()  {  if

  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_type_char=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_cv_type_char=no  fi rm -f conftest.$ac_objext conftest.$ac_ext
fi echo "$as_me:__oline__:  result:  $ac_cv_type_char"  >&5  echo
"${ECHO_T}$ac_cv_type_char" >&6

echo  "$as_me:__oline__:  checking size of char" >&5 echo $ECHO_N
"checking size of char... $ECHO_C"  >&6  if  test  "${ac_cv_size-
of_char+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  if test "$ac_cv_type_char" = yes; then
  if test "$cross_compiling" = yes; then
  #  Depending  upon the size, compute the lo and hi bounds.  cat
>conftest.$ac_ext <<_ACEOF #line __oline__  "configure"  #include
"confdefs.h"  $ac_includes_default #ifdef F77_DUMMY_MAIN #  ifdef
__cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main  ()  {  int
_array_ @<:@1 - 2 * !((sizeof (char)) >= 0)@:>@
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_lo=0 ac_mid=0
  while :; do
    cat >conftest.$ac_ext <<_ACEOF  #line  __oline__  "configure"
#include  "confdefs.h" $ac_includes_default #ifdef F77_DUMMY_MAIN
#  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main  ()  {  int
_array_ @<:@1 - 2 * !((sizeof (char)) <= $ac_mid)@:>@
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
     extern "C" #  endif
   int  F77_DUMMY_MAIN()  {  return 1; } #endif int main () { int
_array_ @<:@1 - 2 * !((sizeof (char)) >= $ac_mid)@:>@
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_lo=$ac_mid; break else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_hi=`expr $ac_mid - 1`; ac_mid=`expr 2 '*' $ac_mid`  fi  rm  -f
conftest.$ac_objext conftest.$ac_ext
  done  fi  rm  -f  conftest.$ac_objext conftest.$ac_ext # Binary
search between  lo  and  hi  bounds.   while  test  "x$ac_lo"  !=
"x$ac_hi"; do
  ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h" $ac_includes_default #ifdef  F77_DUMMY_MAIN  #
ifdef __cplusplus
     extern "C" #  endif
   int  F77_DUMMY_MAIN()  {  return 1; } #endif int main () { int
_array_ @<:@1 - 2 * !((sizeof (char)) <= $ac_mid)@:>@
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_hi=$ac_mid else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_lo=`expr $ac_mid  +  1`  fi  rm  -f  conftest.$ac_objext  con-
ftest.$ac_ext done ac_cv_sizeof_char=$ac_lo else
  if test "$cross_compiling" = yes; then
  {  {  echo  "$as_me:__oline__:  error:  cannot run test program
while cross compiling" >&5 echo "$as_me: error: cannot  run  test
program while cross compiling" >&2;}
   { (exit 1); exit 1; }; } else

  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_sizeof_char=`cat conftest.val` else
  echo  "$as_me:  program exited with status $ac_status" >&5 echo
"$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 fi  rm
-f core core.* *.core conftest$ac_exeext conftest.$ac_objext con-
ftest.$ac_ext fi fi rm -f conftest.val else
  ac_cv_sizeof_char=0  fi  fi  echo  "$as_me:__oline__:   result:
$ac_cv_sizeof_char"  >&5  echo  "${ECHO_T}$ac_cv_sizeof_char" >&6
cat >>confdefs.h  <<_ACEOF  @%:@define  SIZEOF_CHAR  $ac_cv_size-
of_char _ACEOF


echo  "$as_me:__oline__: checking for short int" >&5 echo $ECHO_N
"checking   for   short   int...    $ECHO_C"    >&6    if    test
"${ac_cv_type_short_int+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h" $ac_includes_default #ifdef  F77_DUMMY_MAIN  #
ifdef __cplusplus
     extern "C" #  endif
   int  F77_DUMMY_MAIN()  {  return  1; } #endif int main () { if
((short int *) 0)
  return 0; if (sizeof (short int))
  return 0;
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_type_short_int=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_cv_type_short_int=no  fi  rm   -f   conftest.$ac_objext   con-
ftest.$ac_ext      fi     echo     "$as_me:__oline__:     result:
$ac_cv_type_short_int" >&5 echo  "${ECHO_T}$ac_cv_type_short_int"
>&6

echo  "$as_me:__oline__:  checking  size  of  short int" >&5 echo
$ECHO_N "checking size of  short  int...  $ECHO_C"  >&6  if  test
"${ac_cv_sizeof_short_int+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_lo=0 ac_mid=0
  while :; do
    cat >conftest.$ac_ext <<_ACEOF  #line  __oline__  "configure"
#include  "confdefs.h" $ac_includes_default #ifdef F77_DUMMY_MAIN
#  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main  ()  {  int
_array_ @<:@1 - 2 * !((sizeof (short int)) <= $ac_mid)@:>@
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_hi=$ac_mid; break else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_lo=`expr  $ac_mid  + 1`; ac_mid=`expr 2 '*' $ac_mid + 1` fi rm
-f conftest.$ac_objext conftest.$ac_ext
  done else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_hi=-1 ac_mid=-1
  while :; do
    cat  >conftest.$ac_ext  <<_ACEOF  #line __oline__ "configure"
#include "confdefs.h" $ac_includes_default #ifdef  F77_DUMMY_MAIN
#  ifdef __cplusplus
     extern "C" #  endif
   int  F77_DUMMY_MAIN()  {  return 1; } #endif int main () { int
_array_ @<:@1 - 2 * !((sizeof (short int)) >= $ac_mid)@:>@
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:

ifdef __cplusplus
     extern "C" #  endif
   int  F77_DUMMY_MAIN()  {  return 1; } #endif int main () { int
_array_ @<:@1 - 2 * !((sizeof (short int)) <= $ac_mid)@:>@
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_hi=$ac_mid else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_lo=`expr $ac_mid  +  1`  fi  rm  -f  conftest.$ac_objext  con-
ftest.$ac_ext done ac_cv_sizeof_short_int=$ac_lo else
  if test "$cross_compiling" = yes; then
  {  {  echo  "$as_me:__oline__:  error:  cannot run test program
while cross compiling" >&5 echo "$as_me: error: cannot  run  test
program while cross compiling" >&2;}
   { (exit 1); exit 1; }; } else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h" $ac_includes_default #ifdef  F77_DUMMY_MAIN  #
ifdef __cplusplus
     extern "C" #  endif
   int  F77_DUMMY_MAIN()  { return 1; } #endif int main () { FILE
*f = fopen ("conftest.val", "w"); if (!f)
  exit (1); fprintf (f, "%d", (sizeof (short int))); fclose (f);
  ;
  return 0; } _ACEOF rm -f conftest$ac_exeext  if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_sizeof_short_int=`cat conftest.val` else
  echo  "$as_me:  program exited with status $ac_status" >&5 echo
"$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 fi  rm
-f core core.* *.core conftest$ac_exeext conftest.$ac_objext con-
ftest.$ac_ext fi fi rm -f conftest.val else
  ac_cv_sizeof_short_int=0 fi fi echo "$as_me:__oline__:  result:
$ac_cv_sizeof_short_int"    >&5    echo    "${ECHO_T}$ac_cv_size-
  return 0; if (sizeof (int))
  return 0;
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_type_int=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_cv_type_int=no fi rm -f  conftest.$ac_objext  conftest.$ac_ext
fi  echo  "$as_me:__oline__:  result:  $ac_cv_type_int"  >&5 echo
"${ECHO_T}$ac_cv_type_int" >&6

echo "$as_me:__oline__: checking size of int"  >&5  echo  $ECHO_N
"checking  size  of  int...  $ECHO_C"  >&6 if test "${ac_cv_size-
of_int+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  if test "$ac_cv_type_int" = yes; then
  if test "$cross_compiling" = yes; then
  # Depending upon the size, compute the lo and hi  bounds.   cat
>conftest.$ac_ext  <<_ACEOF  #line __oline__ "configure" #include
"confdefs.h" $ac_includes_default #ifdef F77_DUMMY_MAIN #   ifdef
__cplusplus
     extern "C" #  endif
   int  F77_DUMMY_MAIN()  {  return 1; } #endif int main () { int
_array_ @<:@1 - 2 * !((sizeof (int)) >= 0)@:>@
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_lo=0 ac_mid=0
  while :; do
    cat  >conftest.$ac_ext  <<_ACEOF  #line __oline__ "configure"
#include "confdefs.h" $ac_includes_default #ifdef  F77_DUMMY_MAIN
#  ifdef __cplusplus
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_hi=$ac_mid; break else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_lo=`expr $ac_mid + 1`; ac_mid=`expr 2 '*' $ac_mid + 1`  fi  rm
-f conftest.$ac_objext conftest.$ac_ext
  done else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_hi=-1 ac_mid=-1
  while :; do
    cat >conftest.$ac_ext <<_ACEOF  #line  __oline__  "configure"
#include  "confdefs.h" $ac_includes_default #ifdef F77_DUMMY_MAIN
#  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main  ()  {  int
_array_ @<:@1 - 2 * !((sizeof (int)) >= $ac_mid)@:>@
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_lo=$ac_mid; break else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_hi=`expr  $ac_mid  -  1`; ac_mid=`expr 2 '*' $ac_mid` fi rm -f
conftest.$ac_objext conftest.$ac_ext
  done fi rm -f  conftest.$ac_objext  conftest.$ac_ext  #  Binary
search  between  lo  and  hi  bounds.   while  test  "x$ac_lo" !=
"x$ac_hi"; do
  ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude  "confdefs.h"  $ac_includes_default #ifdef F77_DUMMY_MAIN #
ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main  ()  {  int
_array_ @<:@1 - 2 * !((sizeof (int)) <= $ac_mid)@:>@
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:

clude  "confdefs.h"  $ac_includes_default #ifdef F77_DUMMY_MAIN #
ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main ()  {  FILE
*f = fopen ("conftest.val", "w"); if (!f)
  exit (1); fprintf (f, "%d", (sizeof (int))); fclose (f);
  ;
  return  0;  }  _ACEOF  rm -f conftest$ac_exeext if { (eval echo
"$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_sizeof_int=`cat conftest.val` else
  echo "$as_me: program exited with status $ac_status"  >&5  echo
"$as_me:  failed program was:" >&5 cat conftest.$ac_ext >&5 fi rm
-f core core.* *.core conftest$ac_exeext conftest.$ac_objext con-
ftest.$ac_ext fi fi rm -f conftest.val else
  ac_cv_sizeof_int=0   fi   fi  echo  "$as_me:__oline__:  result:
$ac_cv_sizeof_int" >&5 echo "${ECHO_T}$ac_cv_sizeof_int" >&6  cat
>>confdefs.h  <<_ACEOF  @%:@define  SIZEOF_INT  $ac_cv_sizeof_int
_ACEOF


echo "$as_me:__oline__: checking for long int" >&5  echo  $ECHO_N
"checking    for    long    int...    $ECHO_C"    >&6   if   test
"${ac_cv_type_long_int+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude  "confdefs.h"  $ac_includes_default #ifdef F77_DUMMY_MAIN #
ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int  main  ()  {  if
((long int *) 0)
  return 0; if (sizeof (long int))
  return 0;
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  if test "$cross_compiling" = yes; then
  # Depending upon the size, compute the lo and hi  bounds.   cat
>conftest.$ac_ext  <<_ACEOF  #line __oline__ "configure" #include
"confdefs.h" $ac_includes_default #ifdef F77_DUMMY_MAIN #   ifdef
__cplusplus
     extern "C" #  endif
   int  F77_DUMMY_MAIN()  {  return 1; } #endif int main () { int
_array_ @<:@1 - 2 * !((sizeof (long int)) >= 0)@:>@
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_lo=0 ac_mid=0
  while :; do
    cat  >conftest.$ac_ext  <<_ACEOF  #line __oline__ "configure"
#include "confdefs.h" $ac_includes_default #ifdef  F77_DUMMY_MAIN
#  ifdef __cplusplus
     extern "C" #  endif
   int  F77_DUMMY_MAIN()  {  return 1; } #endif int main () { int
_array_ @<:@1 - 2 * !((sizeof (long int)) <= $ac_mid)@:>@
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_hi=$ac_mid; break else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_lo=`expr $ac_mid + 1`; ac_mid=`expr 2 '*' $ac_mid + 1`  fi  rm
-f conftest.$ac_objext conftest.$ac_ext
  done else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_hi=-1 ac_mid=-1
  while :; do
    cat >conftest.$ac_ext <<_ACEOF  #line  __oline__  "configure"
#include  "confdefs.h" $ac_includes_default #ifdef F77_DUMMY_MAIN
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_lo=$ac_mid; break else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_hi=`expr  $ac_mid  -  1`; ac_mid=`expr 2 '*' $ac_mid` fi rm -f
conftest.$ac_objext conftest.$ac_ext
  done fi rm -f  conftest.$ac_objext  conftest.$ac_ext  #  Binary
search  between  lo  and  hi  bounds.   while  test  "x$ac_lo" !=
"x$ac_hi"; do
  ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude  "confdefs.h"  $ac_includes_default #ifdef F77_DUMMY_MAIN #
ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main  ()  {  int
_array_ @<:@1 - 2 * !((sizeof (long int)) <= $ac_mid)@:>@
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_hi=$ac_mid else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_lo=`expr  $ac_mid  +  1`  fi  rm  -f  conftest.$ac_objext con-
ftest.$ac_ext done ac_cv_sizeof_long_int=$ac_lo else
  if test "$cross_compiling" = yes; then
  { { echo "$as_me:__oline__:  error:  cannot  run  test  program
while  cross  compiling" >&5 echo "$as_me: error: cannot run test
program while cross compiling" >&2;}
   { (exit 1); exit 1; }; } else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude  "confdefs.h"  $ac_includes_default #ifdef F77_DUMMY_MAIN #
ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main ()  {  FILE
*f = fopen ("conftest.val", "w"); if (!f)
  exit (1); fprintf (f, "%d", (sizeof (long int))); fclose (f);
  ;
  return  0;  }  _ACEOF  rm -f conftest$ac_exeext if { (eval echo
"$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5

OF_LONG_INT $ac_cv_sizeof_long_int _ACEOF


echo "$as_me:__oline__: checking for  long  long  int"  >&5  echo
$ECHO_N  "checking  for  long  long  int...  $ECHO_C" >&6 if test
"${ac_cv_type_long_long_int+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude  "confdefs.h"  $ac_includes_default #ifdef F77_DUMMY_MAIN #
ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int  main  ()  {  if
((long long int *) 0)
  return 0; if (sizeof (long long int))
  return 0;
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_type_long_long_int=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_cv_type_long_long_int=no  fi  rm  -f  conftest.$ac_objext con-
ftest.$ac_ext     fi     echo     "$as_me:__oline__:      result:
$ac_cv_type_long_long_int"                >&5                echo
"${ECHO_T}$ac_cv_type_long_long_int" >&6

echo "$as_me:__oline__: checking size of long long int" >&5  echo
$ECHO_N  "checking  size of long long int... $ECHO_C" >&6 if test
"${ac_cv_sizeof_long_long_int+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  if test "$ac_cv_type_long_long_int" = yes; then
  if test "$cross_compiling" = yes; then
  # Depending upon the size, compute the lo and hi  bounds.   cat
>conftest.$ac_ext  <<_ACEOF  #line __oline__ "configure" #include
"confdefs.h" $ac_includes_default #ifdef F77_DUMMY_MAIN #   ifdef
__cplusplus
     extern "C" #  endif
   int  F77_DUMMY_MAIN()  {  return 1; } #endif int main () { int
_array_ @<:@1 - 2 * !((sizeof (long long int)) >= 0)@:>@
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
     extern "C" #  endif
   int  F77_DUMMY_MAIN()  {  return 1; } #endif int main () { int
_array_ @<:@1 - 2 * !((sizeof (long long int)) <= $ac_mid)@:>@
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_hi=$ac_mid; break else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_lo=`expr $ac_mid + 1`; ac_mid=`expr 2 '*' $ac_mid + 1`  fi  rm
-f conftest.$ac_objext conftest.$ac_ext
  done else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_hi=-1 ac_mid=-1
  while :; do
    cat >conftest.$ac_ext <<_ACEOF  #line  __oline__  "configure"
#include  "confdefs.h" $ac_includes_default #ifdef F77_DUMMY_MAIN
#  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main  ()  {  int
_array_ @<:@1 - 2 * !((sizeof (long long int)) >= $ac_mid)@:>@
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_lo=$ac_mid; break else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_hi=`expr  $ac_mid  -  1`; ac_mid=`expr 2 '*' $ac_mid` fi rm -f
conftest.$ac_objext conftest.$ac_ext
  done fi rm -f  conftest.$ac_objext  conftest.$ac_ext  #  Binary
search  between  lo  and  hi  bounds.   while  test  "x$ac_lo" !=
"x$ac_hi"; do
  ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_hi=$ac_mid else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_lo=`expr  $ac_mid  +  1`  fi  rm  -f  conftest.$ac_objext con-
ftest.$ac_ext done ac_cv_sizeof_long_long_int=$ac_lo else
  if test "$cross_compiling" = yes; then
  { { echo "$as_me:__oline__:  error:  cannot  run  test  program
while  cross  compiling" >&5 echo "$as_me: error: cannot run test
program while cross compiling" >&2;}
   { (exit 1); exit 1; }; } else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude  "confdefs.h"  $ac_includes_default #ifdef F77_DUMMY_MAIN #
ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main ()  {  FILE
*f = fopen ("conftest.val", "w"); if (!f)
  exit  (1);  fprintf (f, "%d", (sizeof (long long int))); fclose
(f);
  ;
  return 0; } _ACEOF rm -f conftest$ac_exeext  if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_sizeof_long_long_int=`cat conftest.val` else
  echo  "$as_me:  program exited with status $ac_status" >&5 echo
"$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 fi  rm
-f core core.* *.core conftest$ac_exeext conftest.$ac_objext con-
ftest.$ac_ext fi fi rm -f conftest.val else
  ac_cv_sizeof_long_long_int=0 fi fi echo "$as_me:__oline__:  re-
sult:         $ac_cv_sizeof_long_long_int"        >&5        echo
"${ECHO_T}$ac_cv_sizeof_long_long_int"   >&6   cat   >>confdefs.h
<<_ACEOF     @%:@define     SIZEOF_LONG_LONG_INT     $ac_cv_size-
of_long_long_int _ACEOF



# More checks for data types echo "$as_me:__oline__: checking for
u_int type" >&5 echo $ECHO_N "checking for u_int type... $ECHO_C"
>&6 if test "${ac_cv_have_u_int+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        cat >conftest.$ac_ext <<_ACEOF #line  __oline__  "config-

  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_u_int="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_u_int="no"          fi rm -f conftest.$ac_objext con-
ftest.$ac_ext

fi  echo  "$as_me:__oline__:  result: $ac_cv_have_u_int" >&5 echo
"${ECHO_T}$ac_cv_have_u_int" >&6 if test  "x$ac_cv_have_u_int"  =
"xyes"   ;  then          cat  >>confdefs.h  <<_ACEOF  @%:@define
HAVE_U_INT 1 _ACEOF

        have_u_int=1 fi

echo "$as_me:__oline__: checking  for  intXX_t  types"  >&5  echo
$ECHO_N  "checking  for  intXX_t  types...  $ECHO_C"  >&6 if test
"${ac_cv_have_intxx_t+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        cat >conftest.$ac_ext <<_ACEOF #line  __oline__  "config-
ure" #include "confdefs.h"
 #include  <sys/types.h>  #ifdef F77_DUMMY_MAIN #  ifdef __cplus-
plus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 int8_t a; int16_t b; int32_t c; a = b = c = 1;
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_intxx_t="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_intxx_t="no"          fi  rm  -f  conftest.$ac_objext
conftest.$ac_ext

fi  echo "$as_me:__oline__: result: $ac_cv_have_intxx_t" >&5 echo
"${ECHO_T}$ac_cv_have_intxx_t" >&6 if test "x$ac_cv_have_intxx_t"
=  "xyes"  ;  then          cat  >>confdefs.h <<_ACEOF @%:@define
HAVE_INTXX_T 1 _ACEOF

"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then

                        cat   >>confdefs.h   <<_ACEOF  @%:@define
HAVE_INTXX_T 1 _ACEOF

                        echo "$as_me:__oline__: result: yes"  >&5
echo "${ECHO_T}yes" >&6                  else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 echo "$as_me:__oline__: result: no" >&5 echo  "${ECHO_T}no"  >&6
         fi rm -f conftest.$ac_objext conftest.$ac_ext fi

echo  "$as_me:__oline__:  checking  for  int64_t  type"  >&5 echo
$ECHO_N "checking  for  int64_t  type...  $ECHO_C"  >&6  if  test
"${ac_cv_have_int64_t+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        cat  >conftest.$ac_ext  <<_ACEOF #line __oline__ "config-
ure" #include "confdefs.h"
 #include <sys/types.h> #ifdef F77_DUMMY_MAIN #   ifdef  __cplus-
plus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 int64_t a; a = 1;
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_int64_t="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_int64_t="no"            fi  rm -f conftest.$ac_objext
conftest.$ac_ext

fi echo "$as_me:__oline__: result: $ac_cv_have_int64_t" >&5  echo
 int64_t a; a = 1
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then

                        cat   >>confdefs.h   <<_ACEOF  @%:@define
HAVE_INT64_T 1 _ACEOF

                        echo "$as_me:__oline__: result: yes"  >&5
echo "${ECHO_T}yes" >&6                  else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 echo "$as_me:__oline__: result: no" >&5 echo  "${ECHO_T}no"  >&6
         fi rm -f conftest.$ac_objext conftest.$ac_ext fi

echo  "$as_me:__oline__:  checking  for u_intXX_t types" >&5 echo
$ECHO_N "checking for u_intXX_t types...  $ECHO_C"  >&6  if  test
"${ac_cv_have_u_intxx_t+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        cat  >conftest.$ac_ext  <<_ACEOF #line __oline__ "config-
ure" #include "confdefs.h"
 #include <sys/types.h> #ifdef F77_DUMMY_MAIN #   ifdef  __cplus-
plus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 u_int8_t a; u_int16_t b; u_int32_t c; a = b = c = 1;
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_u_intxx_t="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_u_intxx_t="no"           fi rm -f conftest.$ac_objext
 #include <sys/socket.h> #ifdef F77_DUMMY_MAIN #  ifdef  __cplus-
plus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 u_int8_t a; u_int16_t b; u_int32_t c; a = b = c = 1;
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then

                        cat  >>confdefs.h   <<_ACEOF   @%:@define
HAVE_U_INTXX_T 1 _ACEOF

                        echo  "$as_me:__oline__: result: yes" >&5
echo "${ECHO_T}yes" >&6                  else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 echo  "$as_me:__oline__:  result: no" >&5 echo "${ECHO_T}no" >&6
         fi rm -f conftest.$ac_objext conftest.$ac_ext fi

echo "$as_me:__oline__: checking for u_int64_t  types"  >&5  echo
$ECHO_N  "checking  for  u_int64_t  types... $ECHO_C" >&6 if test
"${ac_cv_have_u_int64_t+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        cat >conftest.$ac_ext <<_ACEOF #line  __oline__  "config-
ure" #include "confdefs.h"
 #include  <sys/types.h>  #ifdef F77_DUMMY_MAIN #  ifdef __cplus-
plus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 u_int64_t a; a = 1;
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5

"$as_me:__oline__:  checking for uintXX_t types" >&5 echo $ECHO_N
"checking  for   uintXX_t   types...   $ECHO_C"   >&6   if   test
"${ac_cv_have_uintxx_t+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

                cat  >conftest.$ac_ext  <<_ACEOF  #line __oline__
"configure" #include "confdefs.h"

#include <sys/types.h>                           #ifdef  F77_DUM-
MY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 uint8_t a; uint16_t b; uint32_t c; a = b = c = 1;
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_uintxx_t="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_uintxx_t="no"                      fi   rm   -f  con-
ftest.$ac_objext    conftest.$ac_ext                  fi     echo
"$as_me:__oline__:   result:   $ac_cv_have_uintxx_t"   >&5   echo
"${ECHO_T}$ac_cv_have_uintxx_t"     >&6              if      test
"x$ac_cv_have_uintxx_t"   =  "xyes"  ;  then                  cat
>>confdefs.h <<_ACEOF @%:@define HAVE_UINTXX_T 1 _ACEOF

        fi fi

if test -z "$have_uintxx_t" ; then
    echo  "$as_me:__oline__:  checking  for  uintXX_t  types   in
stdint.h"  >&5  echo  $ECHO_N  "checking  for  uintXX_t  types in
stdint.h... $ECHO_C" >&6         cat  >conftest.$ac_ext  <<_ACEOF
#line __oline__ "configure" #include "confdefs.h"
 #include <stdint.h> #ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 uint8_t a; uint16_t b; uint32_t c; a = b = c = 1;
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5

 echo  "$as_me:__oline__:  result: no" >&5 echo "${ECHO_T}no" >&6
         fi rm -f conftest.$ac_objext conftest.$ac_ext fi

if (test -z  "$have_u_intxx_t"  ||  test  -z  "$have_intxx_t"  &&
test  "x$ac_cv_header_sys_bitypes_h"  = "xyes") then         echo
"$as_me:__oline__: checking for intXX_t and  u_intXX_t  types  in
sys/bitypes.h"  >&5  echo $ECHO_N "checking for intXX_t and u_in-
tXX_t types in sys/bitypes.h... $ECHO_C"  >&6          cat  >con-
ftest.$ac_ext   <<_ACEOF  #line  __oline__  "configure"  #include
"confdefs.h"

#include <sys/bitypes.h>                  #ifdef F77_DUMMY_MAIN #
ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {

                        int8_t   a;   int16_t   b;   int32_t   c;
                        u_int8_t e;  u_int16_t  f;  u_int32_t  g;
                        a   =   b   =  c  =  e  =  f  =  g  =  1;

  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then

                        cat   >>confdefs.h   <<_ACEOF  @%:@define
HAVE_U_INTXX_T 1 _ACEOF

                        cat  >>confdefs.h   <<_ACEOF   @%:@define
HAVE_INTXX_T 1 _ACEOF

                        echo  "$as_me:__oline__: result: yes" >&5
echo "${ECHO_T}yes" >&6                  else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
echo  "$as_me:__oline__:  result:  no" >&5 echo "${ECHO_T}no" >&6
         fi rm -f conftest.$ac_objext conftest.$ac_ext fi


echo "$as_me:__oline__: checking for  u_char"  >&5  echo  $ECHO_N
"checking     for     u_char...     $ECHO_C"    >&6    if    test
"${ac_cv_have_u_char+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_u_char="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_u_char="no"           fi  rm  -f  conftest.$ac_objext
conftest.$ac_ext

fi  echo  "$as_me:__oline__: result: $ac_cv_have_u_char" >&5 echo
"${ECHO_T}$ac_cv_have_u_char" >&6 if test "x$ac_cv_have_u_char" =
"xyes"   ;  then          cat  >>confdefs.h  <<_ACEOF  @%:@define
HAVE_U_CHAR 1 _ACEOF

fi


   echo  "$as_me:__oline__:  checking  for  socklen_t"  >&5  echo
$ECHO_N   "checking   for   socklen_t...  $ECHO_C"  >&6  if  test
"${ac_cv_type_socklen_t+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h" #include <sys/types.h> #include <sys/socket.h>

#ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int  main  ()  {  if
((socklen_t *) 0)
  return 0; if (sizeof (socklen_t))
  return 0;
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_type_socklen_t=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_cv_type_socklen_t=no   fi   rm   -f  conftest.$ac_objext  con-
ftest.$ac_ext     fi     echo     "$as_me:__oline__:      result:
$ac_cv_type_socklen_t"  >&5 echo "${ECHO_T}$ac_cv_type_socklen_t"
>&6 if test $ac_cv_type_socklen_t = yes; then

                   #include  <sys/types.h>                   #in-
clude <sys/socket.h>

                  int getpeername (int, $arg2 *, $t *);
#ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {

                      $t    len;                         getpeer-
name(0,0,&len);
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then

                   curl_cv_socklen_t_equiv="$t"
break          else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
fi  rm  -f  conftest.$ac_objext conftest.$ac_ext             done
         done

         if test "x$curl_cv_socklen_t_equiv" = x;  then
{  {  echo "$as_me:__oline__: error: Cannot find a type to use in
place of socklen_t" >&5 echo "$as_me: error: Cannot find  a  type
to use in place of socklen_t" >&2;}
   { (exit 1); exit 1; }; }          fi

fi

      echo  "$as_me:__oline__:  result: $curl_cv_socklen_t_equiv"
>&5 echo "${ECHO_T}$curl_cv_socklen_t_equiv" >&6

cat     >>confdefs.h      <<_ACEOF      @%:@define      socklen_t
$curl_cv_socklen_t_equiv _ACEOF

fi



echo  "$as_me:__oline__:  checking  for  size_t" >&5 echo $ECHO_N
"checking    for    size_t...    $ECHO_C"     >&6     if     test
"${ac_cv_have_size_t+set}" = set; then
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_size_t="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_size_t="no"            fi  rm  -f conftest.$ac_objext
conftest.$ac_ext

fi echo "$as_me:__oline__: result: $ac_cv_have_size_t"  >&5  echo
"${ECHO_T}$ac_cv_have_size_t" >&6 if test "x$ac_cv_have_size_t" =
"xyes"  ;  then          cat  >>confdefs.h  <<_ACEOF   @%:@define
HAVE_SIZE_T 1 _ACEOF

fi

echo  "$as_me:__oline__:  checking  for ssize_t" >&5 echo $ECHO_N
"checking    for    ssize_t...    $ECHO_C"    >&6     if     test
"${ac_cv_have_ssize_t+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        cat  >conftest.$ac_ext  <<_ACEOF #line __oline__ "config-
ure" #include "confdefs.h"

#include <sys/types.h>                  #ifdef  F77_DUMMY_MAIN  #
ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 ssize_t foo; foo = 1235;
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_ssize_t="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_ssize_t="no"            fi  rm -f conftest.$ac_objext
conftest.$ac_ext


#include <time.h>                  #ifdef F77_DUMMY_MAIN #  ifdef
__cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 clock_t foo; foo = 1235;
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_clock_t="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_clock_t="no"            fi  rm -f conftest.$ac_objext
conftest.$ac_ext

fi echo "$as_me:__oline__: result: $ac_cv_have_clock_t" >&5  echo
"${ECHO_T}$ac_cv_have_clock_t" >&6 if test "x$ac_cv_have_clock_t"
= "xyes" ;  then          cat  >>confdefs.h  <<_ACEOF  @%:@define
HAVE_CLOCK_T 1 _ACEOF

fi

echo   "$as_me:__oline__:  checking  for  sa_family_t"  >&5  echo
$ECHO_N  "checking  for  sa_family_t...  $ECHO_C"  >&6  if   test
"${ac_cv_have_sa_family_t+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        cat  >conftest.$ac_ext  <<_ACEOF #line __oline__ "config-
ure" #include "confdefs.h"

#include <sys/types.h> #include  <sys/socket.h>
#ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 sa_family_t foo; foo = 1235;
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'

   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 sa_family_t foo; foo = 1235;
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_sa_family_t="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_sa_family_t="no"          fi rm  -f  conftest.$ac_ob-
jext  conftest.$ac_ext          fi rm -f conftest.$ac_objext con-
ftest.$ac_ext

fi echo "$as_me:__oline__: result:  $ac_cv_have_sa_family_t"  >&5
echo     "${ECHO_T}$ac_cv_have_sa_family_t"     >&6    if    test
"x$ac_cv_have_sa_family_t"   =   "xyes"   ;   then            cat
>>confdefs.h <<_ACEOF @%:@define HAVE_SA_FAMILY_T 1 _ACEOF

fi

echo  "$as_me:__oline__:  checking  for  pid_t"  >&5 echo $ECHO_N
"checking    for    pid_t...     $ECHO_C"     >&6     if     test
"${ac_cv_have_pid_t+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        cat  >conftest.$ac_ext  <<_ACEOF #line __oline__ "config-
ure" #include "confdefs.h"

#include <sys/types.h>                  #ifdef  F77_DUMMY_MAIN  #
ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 pid_t foo; foo = 1235;
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?

echo  "$as_me:__oline__:  checking  for  mode_t" >&5 echo $ECHO_N
"checking    for    mode_t...    $ECHO_C"     >&6     if     test
"${ac_cv_have_mode_t+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        cat  >conftest.$ac_ext  <<_ACEOF #line __oline__ "config-
ure" #include "confdefs.h"

#include <sys/types.h>                  #ifdef  F77_DUMMY_MAIN  #
ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 mode_t foo; foo = 1235;
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_mode_t="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_mode_t="no"            fi  rm  -f conftest.$ac_objext
conftest.$ac_ext

fi echo "$as_me:__oline__: result: $ac_cv_have_mode_t"  >&5  echo
"${ECHO_T}$ac_cv_have_mode_t" >&6 if test "x$ac_cv_have_mode_t" =
"xyes"  ;  then          cat  >>confdefs.h  <<_ACEOF   @%:@define
HAVE_MODE_T 1 _ACEOF

fi


echo "$as_me:__oline__: checking for struct sockaddr_storage" >&5
echo $ECHO_N "checking for  struct  sockaddr_storage...  $ECHO_C"
>&6  if  test  "${ac_cv_have_struct_sockaddr_storage+set}" = set;
then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        cat >conftest.$ac_ext <<_ACEOF #line  __oline__  "config-
ure" #include "confdefs.h"

#include  <sys/types.h>  #include <sys/socket.h>
#ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
   ac_cv_have_struct_sockaddr_storage="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_struct_sockaddr_storage="no"          fi rm  -f  con-
ftest.$ac_objext conftest.$ac_ext

fi  echo  "$as_me:__oline__:  result:  $ac_cv_have_struct_sockad-
dr_storage" >&5 echo  "${ECHO_T}$ac_cv_have_struct_sockaddr_stor-
age"  >&6 if test "x$ac_cv_have_struct_sockaddr_storage" = "xyes"
;   then            cat    >>confdefs.h    <<_ACEOF    @%:@define
HAVE_STRUCT_SOCKADDR_STORAGE 1 _ACEOF

fi

echo  "$as_me:__oline__:  checking  for  struct sockaddr_in6" >&5
echo $ECHO_N "checking for struct sockaddr_in6... $ECHO_C" >&6 if
test "${ac_cv_have_struct_sockaddr_in6+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        cat  >conftest.$ac_ext  <<_ACEOF #line __oline__ "config-
ure" #include "confdefs.h"

#include <sys/types.h> #include  <netinet/in.h>
#ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 struct sockaddr_in6 s; s.sin6_family = 0;
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_struct_sockaddr_in6="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_struct_sockaddr_in6="no"             fi  rm  -f  con-
ftest.$ac_objext conftest.$ac_ext

fi  echo  "$as_me:__oline__:  result:  $ac_cv_have_struct_sockad-
dr_in6"  >&5  echo "${ECHO_T}$ac_cv_have_struct_sockaddr_in6" >&6
if  test  "x$ac_cv_have_struct_sockaddr_in6"  =  "xyes"  ;   then
        cat  >>confdefs.h <<_ACEOF @%:@define HAVE_STRUCT_SOCKAD-
DR_IN6 1 _ACEOF

fi

  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_struct_in6_addr="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_struct_in6_addr="no"              fi   rm   -f   con-
ftest.$ac_objext conftest.$ac_ext

fi  echo  "$as_me:__oline__: result: $ac_cv_have_struct_in6_addr"
>&5  echo  "${ECHO_T}$ac_cv_have_struct_in6_addr"  >&6  if   test
"x$ac_cv_have_struct_in6_addr"   =   "xyes"  ;  then          cat
>>confdefs.h <<_ACEOF @%:@define HAVE_STRUCT_IN6_ADDR 1 _ACEOF

fi

echo "$as_me:__oline__: checking for struct  addrinfo"  >&5  echo
$ECHO_N  "checking  for  struct  addrinfo... $ECHO_C" >&6 if test
"${ac_cv_have_struct_addrinfo+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        cat >conftest.$ac_ext <<_ACEOF #line  __oline__  "config-
ure" #include "confdefs.h"

#include <sys/types.h> #include <sys/socket.h> #include <netdb.h>
                 #ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 struct addrinfo s; s.ai_flags = AI_PASSIVE;
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_struct_addrinfo="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5

        cat >conftest.$ac_ext <<_ACEOF #line  __oline__  "config-
ure" #include "confdefs.h"
 #include <sys/time.h> #ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 struct timeval tv; tv.tv_sec = 1;
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_struct_timeval="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_struct_timeval="no"              fi   rm   -f    con-
ftest.$ac_objext conftest.$ac_ext

fi  echo  "$as_me:__oline__:  result: $ac_cv_have_struct_timeval"
>&5  echo  "${ECHO_T}$ac_cv_have_struct_timeval"  >&6   if   test
"x$ac_cv_have_struct_timeval"   =   "xyes"   ;  then          cat
>>confdefs.h <<_ACEOF @%:@define HAVE_STRUCT_TIMEVAL 1 _ACEOF

        have_struct_timeval=1 fi

# If we don't have int64_t then we can't compile sftp-server.  So
don't  # even attempt to do it.  if test "x$ac_cv_have_int64_t" =
"xno"   -a          "x$ac_cv_sizeof_long_int"    !=    "x8"    -a
   "x$ac_cv_sizeof_long_long_int"      =      "x0"     ;     then
        NO_SFTP='#' else          if  test  "$cross_compiling"  =
yes; then
  {  {  echo  "$as_me:__oline__:  error:  cannot run test program
while cross compiling" >&5 echo "$as_me: error: cannot  run  test
program while cross compiling" >&2;}
   { (exit 1); exit 1; }; } else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h"

#include  <stdio.h>  #include  <string.h>  #ifdef   HAVE_SNPRINTF
main()  {          char  buf[50];          char expected_out[50];
        int  mazsize  =  50  ;   #if   (SIZEOF_LONG_INT   ==   8)
        long  int  num  =  0x7fffffffffffffff; #else         long
long num =  0x7fffffffffffffffll;  #endif          strcpy(expect-
ed_out,  "9223372036854775807");          snprintf(buf,  mazsize,
"%lld", num);         if(strcmp(buf, expected_out) != 0)
"$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 cat >>confdefs.h <<_ACEOF @%:@define BROKEN_SNPRINTF 1 _ACEOF

          fi  rm  -f  core  core.* *.core conftest$ac_exeext con-
ftest.$ac_objext conftest.$ac_ext fi fi



# look for field 'ut_host' in header 'utmp.h'                 os-
sh_safe=`echo  "utmp.h" | sed 'y%./+-%__p_%'`                 os-
sh_varname="ossh_cv_$ossh_safe""_has_"ut_host                echo
"$as_me:__oline__: checking for ut_host field in utmp.h" >&5 echo
$ECHO_N "checking for ut_host field  in  utmp.h...  $ECHO_C"  >&6
        if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

                cat  >conftest.$ac_ext  <<_ACEOF  #line __oline__
"configure" #include "confdefs.h" #include <utmp.h>

_ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  egrep "ut_host" >/dev/null 2>&1; then
                        eval "$ossh_varname=yes"
else
                        eval  "$ossh_varname=no"
fi rm -f conftest*
         fi

        ossh_result=`eval  'echo  $'"$ossh_varname"`           if
test   -n   "`echo   $ossh_varname`";  then                  echo
"$as_me:__oline__: result: $ossh_result" >&5 echo  "${ECHO_T}$os-
sh_result"  >&6                 if test "x$ossh_result" = "xyes";
then                         cat >>confdefs.h <<_ACEOF @%:@define
HAVE_HOST_IN_UTMP 1 _ACEOF

                fi                else                       echo
"$as_me:__oline__:  result:  no"  >&5  echo   "${ECHO_T}no"   >&6
        fi


#    look    for    field    'ut_host'    in   header   'utmpx.h'
                ossh_safe=`echo "utmpx.h" |  sed  'y%./+-%__p_%'`
                ossh_varname="ossh_cv_$ossh_safe""_has_"ut_host
        echo "$as_me:__oline__: checking  for  ut_host  field  in
utmpx.h"  >&5  echo  $ECHO_N  "checking for ut_host field in utm-
px.h... $ECHO_C" >&6         if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

                cat >conftest.$ac_ext  <<_ACEOF  #line  __oline__
"configure" #include "confdefs.h" #include <utmpx.h>

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

"$as_me:__oline__:   result:   no"  >&5  echo  "${ECHO_T}no"  >&6
        fi


# look for field 'syslen' in header 'utmpx.h'                 os-
sh_safe=`echo "utmpx.h" | sed 'y%./+-%__p_%'`                 os-
sh_varname="ossh_cv_$ossh_safe""_has_"syslen                 echo
"$as_me:__oline__: checking for syslen field in utmpx.h" >&5 echo
$ECHO_N "checking for syslen field  in  utmpx.h...  $ECHO_C"  >&6
        if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

                cat  >conftest.$ac_ext  <<_ACEOF  #line __oline__
"configure" #include "confdefs.h" #include <utmpx.h>

_ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  egrep "syslen" >/dev/null 2>&1; then
                        eval "$ossh_varname=yes"
else
                        eval  "$ossh_varname=no"
fi rm -f conftest*
         fi

        ossh_result=`eval  'echo  $'"$ossh_varname"`           if
test   -n   "`echo   $ossh_varname`";  then                  echo
"$as_me:__oline__: result: $ossh_result" >&5 echo  "${ECHO_T}$os-
sh_result"  >&6                 if test "x$ossh_result" = "xyes";
then                         cat >>confdefs.h <<_ACEOF @%:@define
HAVE_SYSLEN_IN_UTMPX 1 _ACEOF

                fi                else                       echo
"$as_me:__oline__:  result:  no"  >&5  echo   "${ECHO_T}no"   >&6
        fi


#  look for field 'ut_pid' in header 'utmp.h'                 os-
sh_safe=`echo "utmp.h" | sed 'y%./+-%__p_%'`                  os-
sh_varname="ossh_cv_$ossh_safe""_has_"ut_pid                 echo
"$as_me:__oline__: checking for ut_pid field in utmp.h" >&5  echo
$ECHO_N  "checking  for  ut_pid  field  in utmp.h... $ECHO_C" >&6
        if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

                cat >conftest.$ac_ext  <<_ACEOF  #line  __oline__
"configure" #include "confdefs.h" #include <utmp.h>

_ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  egrep "ut_pid" >/dev/null 2>&1; then
                        eval  "$ossh_varname=yes"
else
                        eval "$ossh_varname=no"
fi rm -f conftest*
# look for field 'ut_type' in header 'utmp.h'                 os-
sh_safe=`echo  "utmp.h" | sed 'y%./+-%__p_%'`                 os-
sh_varname="ossh_cv_$ossh_safe""_has_"ut_type                echo
"$as_me:__oline__: checking for ut_type field in utmp.h" >&5 echo
$ECHO_N "checking for ut_type field  in  utmp.h...  $ECHO_C"  >&6
        if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

                cat  >conftest.$ac_ext  <<_ACEOF  #line __oline__
"configure" #include "confdefs.h" #include <utmp.h>

_ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  egrep "ut_type" >/dev/null 2>&1; then
                        eval "$ossh_varname=yes"
else
                        eval  "$ossh_varname=no"
fi rm -f conftest*
         fi

        ossh_result=`eval  'echo  $'"$ossh_varname"`           if
test   -n   "`echo   $ossh_varname`";  then                  echo
"$as_me:__oline__: result: $ossh_result" >&5 echo  "${ECHO_T}$os-
sh_result"  >&6                 if test "x$ossh_result" = "xyes";
then                         cat >>confdefs.h <<_ACEOF @%:@define
HAVE_TYPE_IN_UTMP 1 _ACEOF

                fi                else                       echo
"$as_me:__oline__:  result:  no"  >&5  echo   "${ECHO_T}no"   >&6
        fi


#    look    for    field    'ut_type'    in   header   'utmpx.h'
                ossh_safe=`echo "utmpx.h" |  sed  'y%./+-%__p_%'`
                ossh_varname="ossh_cv_$ossh_safe""_has_"ut_type
        echo "$as_me:__oline__: checking  for  ut_type  field  in
utmpx.h"  >&5  echo  $ECHO_N  "checking for ut_type field in utm-
px.h... $ECHO_C" >&6         if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

                cat >conftest.$ac_ext  <<_ACEOF  #line  __oline__
"configure" #include "confdefs.h" #include <utmpx.h>

_ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  egrep "ut_type" >/dev/null 2>&1; then
                        eval  "$ossh_varname=yes"
else
                        eval "$ossh_varname=no"
fi rm -f conftest*
         fi

        ossh_result=`eval   'echo  $'"$ossh_varname"`          if
test  -n  "`echo   $ossh_varname`";   then                   echo
$ECHO_N "checking for  ut_tv  field  in  utmp.h...  $ECHO_C"  >&6
        if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

                cat  >conftest.$ac_ext  <<_ACEOF  #line __oline__
"configure" #include "confdefs.h" #include <utmp.h>

_ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  egrep "ut_tv" >/dev/null 2>&1; then
                        eval "$ossh_varname=yes"
else
                        eval  "$ossh_varname=no"
fi rm -f conftest*
         fi

        ossh_result=`eval  'echo  $'"$ossh_varname"`           if
test   -n   "`echo   $ossh_varname`";  then                  echo
"$as_me:__oline__: result: $ossh_result" >&5 echo  "${ECHO_T}$os-
sh_result"  >&6                 if test "x$ossh_result" = "xyes";
then                         cat >>confdefs.h <<_ACEOF @%:@define
HAVE_TV_IN_UTMP 1 _ACEOF

                fi                else                       echo
"$as_me:__oline__:  result:  no"  >&5  echo   "${ECHO_T}no"   >&6
        fi


#  look  for field 'ut_id' in header 'utmp.h'                 os-
sh_safe=`echo "utmp.h" | sed 'y%./+-%__p_%'`                  os-
sh_varname="ossh_cv_$ossh_safe""_has_"ut_id                  echo
"$as_me:__oline__: checking for ut_id field in utmp.h"  >&5  echo
$ECHO_N  "checking  for  ut_id  field  in  utmp.h... $ECHO_C" >&6
        if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

                cat >conftest.$ac_ext  <<_ACEOF  #line  __oline__
"configure" #include "confdefs.h" #include <utmp.h>

_ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  egrep "ut_id" >/dev/null 2>&1; then
                        eval  "$ossh_varname=yes"
else
                        eval "$ossh_varname=no"
fi rm -f conftest*
         fi

        ossh_result=`eval   'echo  $'"$ossh_varname"`          if
test  -n  "`echo   $ossh_varname`";   then                   echo
"$as_me:__oline__:  result: $ossh_result" >&5 echo "${ECHO_T}$os-
sh_result" >&6                 if test "x$ossh_result" =  "xyes";
then                         cat >>confdefs.h <<_ACEOF @%:@define
HAVE_ID_IN_UTMP 1 _ACEOF
                cat  >conftest.$ac_ext  <<_ACEOF  #line __oline__
"configure" #include "confdefs.h" #include <utmpx.h>

_ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  egrep "ut_id" >/dev/null 2>&1; then
                        eval "$ossh_varname=yes"
else
                        eval  "$ossh_varname=no"
fi rm -f conftest*
         fi

        ossh_result=`eval  'echo  $'"$ossh_varname"`           if
test   -n   "`echo   $ossh_varname`";  then                  echo
"$as_me:__oline__: result: $ossh_result" >&5 echo  "${ECHO_T}$os-
sh_result"  >&6                 if test "x$ossh_result" = "xyes";
then                         cat >>confdefs.h <<_ACEOF @%:@define
HAVE_ID_IN_UTMPX 1 _ACEOF

                fi                else                       echo
"$as_me:__oline__:  result:  no"  >&5  echo   "${ECHO_T}no"   >&6
        fi


# look for field 'ut_addr' in header 'utmp.h'                 os-
sh_safe=`echo "utmp.h" | sed 'y%./+-%__p_%'`                  os-
sh_varname="ossh_cv_$ossh_safe""_has_"ut_addr                echo
"$as_me:__oline__: checking for ut_addr field in utmp.h" >&5 echo
$ECHO_N  "checking  for  ut_addr  field in utmp.h... $ECHO_C" >&6
        if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

                cat >conftest.$ac_ext  <<_ACEOF  #line  __oline__
"configure" #include "confdefs.h" #include <utmp.h>

_ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  egrep "ut_addr" >/dev/null 2>&1; then
                        eval  "$ossh_varname=yes"
else
                        eval "$ossh_varname=no"
fi rm -f conftest*
         fi

        ossh_result=`eval   'echo  $'"$ossh_varname"`          if
test  -n  "`echo   $ossh_varname`";   then                   echo
"$as_me:__oline__:  result: $ossh_result" >&5 echo "${ECHO_T}$os-
sh_result" >&6                 if test "x$ossh_result" =  "xyes";
then                         cat >>confdefs.h <<_ACEOF @%:@define
HAVE_ADDR_IN_UTMP 1 _ACEOF

                fi               else                        echo
"$as_me:__oline__:   result:   no"  >&5  echo  "${ECHO_T}no"  >&6
        fi

  egrep "ut_addr" >/dev/null 2>&1; then
                        eval "$ossh_varname=yes"
else
                        eval  "$ossh_varname=no"
fi rm -f conftest*
         fi

        ossh_result=`eval  'echo  $'"$ossh_varname"`           if
test   -n   "`echo   $ossh_varname`";  then                  echo
"$as_me:__oline__: result: $ossh_result" >&5 echo  "${ECHO_T}$os-
sh_result"  >&6                 if test "x$ossh_result" = "xyes";
then                         cat >>confdefs.h <<_ACEOF @%:@define
HAVE_ADDR_IN_UTMPX 1 _ACEOF

                fi                else                       echo
"$as_me:__oline__:  result:  no"  >&5  echo   "${ECHO_T}no"   >&6
        fi


#    look    for    field   'ut_addr_v6'   in   header   'utmp.h'
                ossh_safe=`echo "utmp.h"  |  sed  'y%./+-%__p_%'`
                ossh_varname="ossh_cv_$ossh_safe""_has_"ut_ad-
dr_v6         echo  "$as_me:__oline__:  checking  for  ut_addr_v6
field  in utmp.h" >&5 echo $ECHO_N "checking for ut_addr_v6 field
in utmp.h... $ECHO_C" >&6         if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

                cat >conftest.$ac_ext  <<_ACEOF  #line  __oline__
"configure" #include "confdefs.h" #include <utmp.h>

_ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  egrep "ut_addr_v6" >/dev/null 2>&1; then
                        eval  "$ossh_varname=yes"
else
                        eval "$ossh_varname=no"
fi rm -f conftest*
         fi

        ossh_result=`eval   'echo  $'"$ossh_varname"`          if
test  -n  "`echo   $ossh_varname`";   then                   echo
"$as_me:__oline__:  result: $ossh_result" >&5 echo "${ECHO_T}$os-
sh_result" >&6                 if test "x$ossh_result" =  "xyes";
then                         cat >>confdefs.h <<_ACEOF @%:@define
HAVE_ADDR_V6_IN_UTMP 1 _ACEOF

                fi               else                        echo
"$as_me:__oline__:   result:   no"  >&5  echo  "${ECHO_T}no"  >&6
        fi


#   look   for   field   'ut_addr_v6'   in    header    'utmpx.h'
                ossh_safe=`echo  "utmpx.h"  | sed 'y%./+-%__p_%'`

fi rm -f conftest*
         fi

        ossh_result=`eval  'echo  $'"$ossh_varname"`           if
test   -n   "`echo   $ossh_varname`";  then                  echo
"$as_me:__oline__: result: $ossh_result" >&5 echo  "${ECHO_T}$os-
sh_result"  >&6                 if test "x$ossh_result" = "xyes";
then                         cat >>confdefs.h <<_ACEOF @%:@define
HAVE_ADDR_V6_IN_UTMPX 1 _ACEOF

                fi                else                       echo
"$as_me:__oline__:  result:  no"  >&5  echo   "${ECHO_T}no"   >&6
        fi


# look for field 'ut_exit' in header 'utmp.h'                 os-
sh_safe=`echo "utmp.h" | sed 'y%./+-%__p_%'`                  os-
sh_varname="ossh_cv_$ossh_safe""_has_"ut_exit                echo
"$as_me:__oline__: checking for ut_exit field in utmp.h" >&5 echo
$ECHO_N  "checking  for  ut_exit  field in utmp.h... $ECHO_C" >&6
        if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

                cat >conftest.$ac_ext  <<_ACEOF  #line  __oline__
"configure" #include "confdefs.h" #include <utmp.h>

_ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  egrep "ut_exit" >/dev/null 2>&1; then
                        eval  "$ossh_varname=yes"
else
                        eval "$ossh_varname=no"
fi rm -f conftest*
         fi

        ossh_result=`eval   'echo  $'"$ossh_varname"`          if
test  -n  "`echo   $ossh_varname`";   then                   echo
"$as_me:__oline__:  result: $ossh_result" >&5 echo "${ECHO_T}$os-
sh_result" >&6                 if test "x$ossh_result" =  "xyes";
then                         cat >>confdefs.h <<_ACEOF @%:@define
HAVE_EXIT_IN_UTMP 1 _ACEOF

                fi               else                        echo
"$as_me:__oline__:   result:   no"  >&5  echo  "${ECHO_T}no"  >&6
        fi


# look for field 'ut_time' in header 'utmp.h'                 os-
sh_safe=`echo  "utmp.h" | sed 'y%./+-%__p_%'`                 os-
sh_varname="ossh_cv_$ossh_safe""_has_"ut_time                echo
"$as_me:__oline__: checking for ut_time field in utmp.h" >&5 echo
$ECHO_N "checking for ut_time field  in  utmp.h...  $ECHO_C"  >&6
        if eval "test

test   -n   "`echo   $ossh_varname`";  then                  echo
"$as_me:__oline__: result: $ossh_result" >&5 echo  "${ECHO_T}$os-
sh_result"  >&6                 if test "x$ossh_result" = "xyes";
then                         cat >>confdefs.h <<_ACEOF @%:@define
HAVE_TIME_IN_UTMP 1 _ACEOF

                fi                else                       echo
"$as_me:__oline__:  result:  no"  >&5  echo   "${ECHO_T}no"   >&6
        fi


#    look    for    field    'ut_time'    in   header   'utmpx.h'
                ossh_safe=`echo "utmpx.h" |  sed  'y%./+-%__p_%'`
                ossh_varname="ossh_cv_$ossh_safe""_has_"ut_time
        echo "$as_me:__oline__: checking  for  ut_time  field  in
utmpx.h"  >&5  echo  $ECHO_N  "checking for ut_time field in utm-
px.h... $ECHO_C" >&6         if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

                cat >conftest.$ac_ext  <<_ACEOF  #line  __oline__
"configure" #include "confdefs.h" #include <utmpx.h>

_ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  egrep "ut_time" >/dev/null 2>&1; then
                        eval  "$ossh_varname=yes"
else
                        eval "$ossh_varname=no"
fi rm -f conftest*
         fi

        ossh_result=`eval   'echo  $'"$ossh_varname"`          if
test  -n  "`echo   $ossh_varname`";   then                   echo
"$as_me:__oline__:  result: $ossh_result" >&5 echo "${ECHO_T}$os-
sh_result" >&6                 if test "x$ossh_result" =  "xyes";
then                         cat >>confdefs.h <<_ACEOF @%:@define
HAVE_TIME_IN_UTMPX 1 _ACEOF

                fi               else                        echo
"$as_me:__oline__:   result:   no"  >&5  echo  "${ECHO_T}no"  >&6
        fi


# look for field 'ut_tv' in header 'utmpx.h'                  os-
sh_safe=`echo "utmpx.h" | sed 'y%./+-%__p_%'`                 os-
sh_varname="ossh_cv_$ossh_safe""_has_"ut_tv                  echo
"$as_me:__oline__:  checking for ut_tv field in utmpx.h" >&5 echo
$ECHO_N "checking for ut_tv  field  in  utmpx.h...  $ECHO_C"  >&6
        if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

                cat  >conftest.$ac_ext  <<_ACEOF  #line __oline__
"configure" #include "confdefs.h" #include <utmpx.h>
HAVE_TV_IN_UTMPX 1 _ACEOF

                fi                else                       echo
"$as_me:__oline__:  result:  no"  >&5  echo   "${ECHO_T}no"   >&6
        fi


echo  "$as_me:__oline__: checking for struct stat.st_blksize" >&5
echo $ECHO_N "checking for struct stat.st_blksize... $ECHO_C" >&6
if test "${ac_cv_member_struct_stat_st_blksize+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h" $ac_includes_default #ifdef  F77_DUMMY_MAIN  #
ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () { static
struct stat ac_aggr; if (ac_aggr.st_blksize) return 0;
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_member_struct_stat_st_blksize=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_cv_member_struct_stat_st_blksize=no fi rm -f  conftest.$ac_ob-
jext   conftest.$ac_ext   fi   echo   "$as_me:__oline__:  result:
$ac_cv_member_struct_stat_st_blksize"          >&5           echo
"${ECHO_T}$ac_cv_member_struct_stat_st_blksize"   >&6   if   test
$ac_cv_member_struct_stat_st_blksize = yes; then

cat >>confdefs.h <<_ACEOF @%:@define  HAVE_STRUCT_STAT_ST_BLKSIZE
1 _ACEOF


fi


echo  "$as_me:__oline__:  checking  for ss_family field in struct
sockaddr_storage" >&5 echo $ECHO_N "checking for ss_family  field
in    struct    sockaddr_storage...    $ECHO_C"   >&6   if   test
"${ac_cv_have_ss_family_in_struct_ss+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        cat >conftest.$ac_ext <<_ACEOF #line  __oline__  "config-
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_ss_family_in_struct_ss="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_ss_family_in_struct_ss="no" fi rm -f conftest.$ac_ob-
jext conftest.$ac_ext

fi    echo    "$as_me:__oline__:   result:   $ac_cv_have_ss_fami-
ly_in_struct_ss"    >&5    echo    "${ECHO_T}$ac_cv_have_ss_fami-
ly_in_struct_ss"     >&6     if    test    "x$ac_cv_have_ss_fami-
ly_in_struct_ss" = "xyes" ; then         cat >>confdefs.h <<_ACE-
OF @%:@define HAVE_SS_FAMILY_IN_SS 1 _ACEOF

fi

echo  "$as_me:__oline__: checking for __ss_family field in struct
sockaddr_storage" >&5  echo  $ECHO_N  "checking  for  __ss_family
field   in   struct  sockaddr_storage...  $ECHO_C"  >&6  if  test
"${ac_cv_have___ss_family_in_struct_ss+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        cat >conftest.$ac_ext <<_ACEOF #line  __oline__  "config-
ure" #include "confdefs.h"

#include  <sys/types.h>  #include <sys/socket.h>
#ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 struct sockaddr_storage s; s.__ss_family = 1;
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have___ss_family_in_struct_ss="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have___ss_family_in_struct_ss="no"          fi rm -f  con-
ftest.$ac_objext conftest.$ac_ext

fi   echo   "$as_me:__oline__:   result:   $ac_cv_have___ss_fami-
ure" #include "confdefs.h"

#include  <pwd.h>                  #ifdef F77_DUMMY_MAIN #  ifdef
__cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 struct passwd p; p.pw_class = 0;
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_pw_class_in_struct_passwd="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_pw_class_in_struct_passwd="no"          fi rm -f con-
ftest.$ac_objext conftest.$ac_ext

fi            echo           "$as_me:__oline__:           result:
$ac_cv_have_pw_class_in_struct_passwd"          >&5          echo
"${ECHO_T}$ac_cv_have_pw_class_in_struct_passwd"   >&6   if  test
"x$ac_cv_have_pw_class_in_struct_passwd"   =   "xyes"   ;    then
        cat        >>confdefs.h        <<_ACEOF        @%:@define
HAVE_PW_CLASS_IN_PASSWD 1 _ACEOF

fi

echo "$as_me:__oline__: checking for pw_expire  field  in  struct
passwd"  >&5 echo $ECHO_N "checking for pw_expire field in struct
passwd...   $ECHO_C"    >&6    if    test    "${ac_cv_have_pw_ex-
pire_in_struct_passwd+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        cat  >conftest.$ac_ext  <<_ACEOF #line __oline__ "config-
ure" #include "confdefs.h"

#include <pwd.h>                  #ifdef F77_DUMMY_MAIN #   ifdef
__cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 struct passwd p; p.pw_expire = 0;
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5

fi    echo    "$as_me:__oline__:    result:    $ac_cv_have_pw_ex-
pire_in_struct_passwd"   >&5   echo  "${ECHO_T}$ac_cv_have_pw_ex-
pire_in_struct_passwd"   >&6   if    test    "x$ac_cv_have_pw_ex-
pire_in_struct_passwd"  =  "xyes" ; then         cat >>confdefs.h
<<_ACEOF @%:@define HAVE_PW_EXPIRE_IN_PASSWD 1 _ACEOF

fi

echo "$as_me:__oline__: checking for pw_change  field  in  struct
passwd"  >&5 echo $ECHO_N "checking for pw_change field in struct
passwd...         $ECHO_C"          >&6          if          test
"${ac_cv_have_pw_change_in_struct_passwd+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        cat  >conftest.$ac_ext  <<_ACEOF #line __oline__ "config-
ure" #include "confdefs.h"

#include <pwd.h>                  #ifdef F77_DUMMY_MAIN #   ifdef
__cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 struct passwd p; p.pw_change = 0;
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_pw_change_in_struct_passwd="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_pw_change_in_struct_passwd="no"            fi  rm  -f
conftest.$ac_objext conftest.$ac_ext

fi           echo           "$as_me:__oline__:            result:
$ac_cv_have_pw_change_in_struct_passwd"          >&5         echo
"${ECHO_T}$ac_cv_have_pw_change_in_struct_passwd"  >&6  if   test
"x$ac_cv_have_pw_change_in_struct_passwd"   =   "xyes"   ;   then
        cat        >>confdefs.h        <<_ACEOF        @%:@define
HAVE_PW_CHANGE_IN_PASSWD 1 _ACEOF

fi

echo  "$as_me:__oline__: checking if libc defines __progname" >&5
echo $ECHO_N "checking if libc defines __progname... $ECHO_C" >&6
if test "${ac_cv_libc_defines___progname+set}" = set; then
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_libc_defines___progname="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_libc_defines___progname="no"            fi  rm   -f   con-
ftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

fi  echo  "$as_me:__oline__:  result: $ac_cv_libc_defines___prog-
name" >&5 echo "${ECHO_T}$ac_cv_libc_defines___progname"  >&6  if
test    "x$ac_cv_libc_defines___progname"   =   "xyes"   ;   then
        cat >>confdefs.h <<_ACEOF  @%:@define  HAVE___PROGNAME  1
_ACEOF

fi

echo "$as_me:__oline__: checking whether getopt has optreset sup-
port" >&5 echo $ECHO_N "checking whether getopt has optreset sup-
port...  $ECHO_C" >&6 if test "${ac_cv_have_getopt_optreset+set}"
= set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        cat >conftest.$ac_ext <<_ACEOF #line  __oline__  "config-
ure" #include "confdefs.h"

#include  <getopt.h>                    #ifdef  F77_DUMMY_MAIN  #
ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 extern int optreset; optreset = 0;
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_have_getopt_optreset="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_have_getopt_optreset="no"              fi   rm   -f   con-
ftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
ure" #include "confdefs.h"

#ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 extern  const  char  *const  sys_errlist[]; printf("%s", sys_er-
rlist[0]);
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   ac_cv_libc_defines_sys_errlist="yes" else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
 ac_cv_libc_defines_sys_errlist="no"            fi  rm  -f   con-
ftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

fi  echo  "$as_me:__oline__:  result: $ac_cv_libc_defines_sys_er-
rlist" >&5 echo "${ECHO_T}$ac_cv_libc_defines_sys_errlist" >&6 if
test   "x$ac_cv_libc_defines_sys_errlist"   =   "xyes"   ;   then
        cat >>confdefs.h <<_ACEOF @%:@define  HAVE_SYS_ERRLIST  1
_ACEOF

fi


echo  "$as_me:__oline__:  checking  if libc defines sys_nerr" >&5
echo $ECHO_N "checking if libc defines sys_nerr...  $ECHO_C"  >&6
if test "${ac_cv_libc_defines_sys_nerr+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

        cat  >conftest.$ac_ext  <<_ACEOF #line __oline__ "config-
ure" #include "confdefs.h"

#ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 extern int sys_nerr; printf("%i", sys_nerr);
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5

"x$ac_cv_libc_defines_sys_nerr"   =  "xyes"  ;  then          cat
>>confdefs.h <<_ACEOF @%:@define HAVE_SYS_NERR 1 _ACEOF

fi


# Check whether user wants Kerberos support SCARD_MSG="no"

# Check whether --with-smartcard or --without-smartcard was  giv-
en.  if test "${with_smartcard+set}" = set; then
  withval="$with_smartcard"

                if    test    "x$withval"   !=   "xno"   ;   then
                        if test  "x$withval"  !=  "xyes"  ;  then
                                CPPFLAGS="$CPPFLAGS -I${withval}"
                                LDFLAGS="$LDFLAGS   -L${withval}"
                                if  test  !  -z  "$need_dash_r" ;
then                                            LDFLAGS="$LDFLAGS
-R${withval}"                                                  fi
                                if test ! -z "$blibpath"  ;  then
                                        blibpath="$blib-
path:${withval}"                                               fi
                        fi                          for ac_header
in sectok.h  do  as_ac_Header=`echo  "ac_cv_header_$ac_header"  |
$as_tr_sh` if eval "test
  echo  "$as_me:__oline__:  checking  for  $ac_header"  >&5  echo
$ECHO_N "checking for $ac_header... $ECHO_C" >&6 if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 fi echo  "$as_me:__oline__:
result:    `eval    echo    '${'$as_ac_Header'}'`"    >&5    echo
"${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 else
  # Is the header compilable?  echo  "$as_me:__oline__:  checking
$ac_header  usability"  >&5 echo $ECHO_N "checking $ac_header us-
ability... $ECHO_C"  >&6  cat  >conftest.$ac_ext  <<_ACEOF  #line
__oline__  "configure" #include "confdefs.h" $ac_includes_default
@%:@include <$ac_header> _ACEOF rm -f  conftest.$ac_objext  if  {
(eval echo "$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_header_compiler=no   fi   rm   -f   conftest.$ac_objext   con-
ftest.$ac_ext  echo "$as_me:__oline__: result: $ac_header_compil-
er" >&5 echo "${ECHO_T}$ac_header_compiler" >&6

  else
    ac_cpp_err=
  fi else
  ac_cpp_err=yes fi if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes else
  echo "$as_me: failed program was:" >&5
  cat conftest.$ac_ext >&5
  ac_header_preproc=no fi  rm  -f  conftest.err  conftest.$ac_ext
echo  "$as_me:__oline__:  result:  $ac_header_preproc"  >&5  echo
"${ECHO_T}$ac_header_preproc" >&6

#  So?   What  about  this   header?    case   $ac_header_compil-
er:$ac_header_preproc in
  yes:no )
    {  echo  "$as_me:__oline__:  WARNING: $ac_header: accepted by
the compiler, rejected by the preprocessor!"  >&5  echo  "$as_me:
WARNING:  $ac_header:  accepted  by the compiler, rejected by the
preprocessor!" >&2;}
    { echo  "$as_me:__oline__:  WARNING:  $ac_header:  proceeding
with  the  preprocessor's  result"  >&5  echo  "$as_me:  WARNING:
$ac_header: proceeding with the preprocessor's result" >&2;};;
  no:yes )
    { echo "$as_me:__oline__: WARNING:  $ac_header:  present  but
cannot  be  compiled."  >&5  echo  "$as_me:  WARNING: $ac_header:
present but cannot be compiled." >&2;}
    { echo  "$as_me:__oline__:  WARNING:  $ac_header:  check  for
missing   prerequisite   headers?"  >&5  echo  "$as_me:  WARNING:
$ac_header: check for missing prerequisite headers?" >&2;}
    { echo  "$as_me:__oline__:  WARNING:  $ac_header:  proceeding
with  the  preprocessor's  result"  >&5  echo  "$as_me:  WARNING:
$ac_header: proceeding with the  preprocessor's  result"  >&2;};;
esac  echo  "$as_me:__oline__:  checking for $ac_header" >&5 echo
$ECHO_N "checking for $ac_header... $ECHO_C" >&6 if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  eval      "$as_ac_Header=$ac_header_preproc"      fi       echo
"$as_me:__oline__:  result: `eval echo '${'$as_ac_Header'}'`" >&5
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

fi if test `eval echo '${'$as_ac_Header'}'` = yes; then
  cat >>confdefs.h <<_ACEOF @%:@define `echo "HAVE_$ac_header"  |
$as_tr_cpp` 1 _ACEOF

fi

done

                        if  test "$ac_cv_header_sectok_h" != yes;
then                                 { { echo  "$as_me:__oline__:
error:  Can't  find sectok.h" >&5 echo "$as_me: error: Can't find
sectok.h" >&2;}
   {  (exit  1);  exit   1;   };   }                           fi
                          echo  "$as_me:__oline__:  checking  for

   int  F77_DUMMY_MAIN()  { return 1; } #endif int main () { sec-
tok_open ();
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_sectok_sectok_open=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_cv_lib_sectok_sectok_open=no fi rm -f conftest.$ac_objext con-
ftest$ac_exeext  conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi
echo  "$as_me:__oline__:  result:  $ac_cv_lib_sectok_sectok_open"
>&5  echo  "${ECHO_T}$ac_cv_lib_sectok_sectok_open"  >&6  if test
$ac_cv_lib_sectok_sectok_open = yes; then
  cat >>confdefs.h <<_ACEOF @%:@define HAVE_LIBSECTOK 1 _ACEOF

  LIBS="-lsectok $LIBS"

fi

                        if  test  "$ac_cv_lib_sectok_sectok_open"
!=    yes;    then                                   {   {   echo
"$as_me:__oline__: error: Can't find libsectok" >&5 echo "$as_me:
error: Can't find libsectok" >&2;}
   {   (exit   1);   exit   1;  };  }                          fi
                        cat  >>confdefs.h   <<_ACEOF   @%:@define
SMARTCARD 1 _ACEOF

                        SCARD_MSG="yes"                        fi


fi;

# Check whether user wants Kerberos support KRB4_MSG="no"

# Check whether --with-kerberos4 or --without-kerberos4 was  giv-
en.  if test "${with_kerberos4+set}" = set; then
  withval="$with_kerberos4"

                if    test    "x$withval"   !=   "xno"   ;   then
                        if test  "x$withval"  !=  "xyes"  ;  then
                                CPPFLAGS="$CPPFLAGS     -I${with-
val}/include"                                   LDFLAGS="$LDFLAGS
-L${withval}/lib"                                  if  test  ! -z
  echo  "$as_me:__oline__:  checking  for  $ac_header"  >&5  echo
$ECHO_N "checking for $ac_header... $ECHO_C" >&6 if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 fi echo  "$as_me:__oline__:
result:    `eval    echo    '${'$as_ac_Header'}'`"    >&5    echo
"${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 else
  # Is the header compilable?  echo  "$as_me:__oline__:  checking
$ac_header  usability"  >&5 echo $ECHO_N "checking $ac_header us-
ability... $ECHO_C"  >&6  cat  >conftest.$ac_ext  <<_ACEOF  #line
__oline__  "configure" #include "confdefs.h" $ac_includes_default
@%:@include <$ac_header> _ACEOF rm -f  conftest.$ac_objext  if  {
(eval echo "$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_header_compiler=no   fi   rm   -f   conftest.$ac_objext   con-
ftest.$ac_ext  echo "$as_me:__oline__: result: $ac_header_compil-
er" >&5 echo "${ECHO_T}$ac_header_compiler" >&6

#  Is  the  header  present?   echo  "$as_me:__oline__:  checking
$ac_header  presence" >&5 echo $ECHO_N "checking $ac_header pres-
ence...  $ECHO_C"  >&6  cat  >conftest.$ac_ext   <<_ACEOF   #line
__oline__    "configure"    #include   "confdefs.h"   @%:@include
<$ac_header> _ACEOF if { (eval echo "$as_me:__oline__:
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  egrep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
  else
    ac_cpp_err=
  fi else
  ac_cpp_err=yes fi if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes else
  echo "$as_me: failed program was:" >&5
  cat conftest.$ac_ext >&5
  ac_header_preproc=no fi  rm  -f  conftest.err  conftest.$ac_ext
echo  "$as_me:__oline__:  result:  $ac_header_preproc"  >&5  echo
"${ECHO_T}$ac_header_preproc" >&6

    { echo  "$as_me:__oline__:  WARNING:  $ac_header:  check  for
missing   prerequisite   headers?"  >&5  echo  "$as_me:  WARNING:
$ac_header: check for missing prerequisite headers?" >&2;}
    { echo  "$as_me:__oline__:  WARNING:  $ac_header:  proceeding
with  the  preprocessor's  result"  >&5  echo  "$as_me:  WARNING:
$ac_header: proceeding with the  preprocessor's  result"  >&2;};;
esac  echo  "$as_me:__oline__:  checking for $ac_header" >&5 echo
$ECHO_N "checking for $ac_header... $ECHO_C" >&6 if eval "test
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  eval      "$as_ac_Header=$ac_header_preproc"      fi       echo
"$as_me:__oline__:  result: `eval echo '${'$as_ac_Header'}'`" >&5
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

fi if test `eval echo '${'$as_ac_Header'}'` = yes; then
  cat >>confdefs.h <<_ACEOF @%:@define `echo "HAVE_$ac_header"  |
$as_tr_cpp` 1 _ACEOF

fi

done

                        if  test  "$ac_cv_header_krb_h"  !=  yes;
then                                  {  echo  "$as_me:__oline__:
WARNING:  Cannot  find  krb.h,  build may fail" >&5 echo "$as_me:
WARNING:   Cannot   find   krb.h,   build   may    fail"    >&2;}
                        fi                                   echo
"$as_me:__oline__: checking for main in -lkrb" >&5  echo  $ECHO_N
"checking   for   main   in   -lkrb...   $ECHO_C"   >&6  if  test
"${ac_cv_lib_krb_main+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  ac_check_lib_save_LIBS=$LIBS  LIBS="-lkrb   $LIBS"  cat   >con-
ftest.$ac_ext   <<_ACEOF  #line  __oline__  "configure"  #include
"confdefs.h"


#ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main ()  {  main
();
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then

then                                    echo   "$as_me:__oline__:
checking  for main in -lkrb4" >&5 echo $ECHO_N "checking for main
in -lkrb4... $ECHO_C" >&6 if test "${ac_cv_lib_krb4_main+set}"  =
set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  ac_check_lib_save_LIBS=$LIBS  LIBS="-lkrb4   $LIBS"  cat  >con-
ftest.$ac_ext  <<_ACEOF  #line  __oline__  "configure"   #include
"confdefs.h"


#ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int  F77_DUMMY_MAIN()  { return 1; } #endif int main () { main
();
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_krb4_main=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_cv_lib_krb4_main=no  fi   rm   -f   conftest.$ac_objext   con-
ftest$ac_exeext  conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi
echo "$as_me:__oline__: result:  $ac_cv_lib_krb4_main"  >&5  echo
"${ECHO_T}$ac_cv_lib_krb4_main"  >&6 if test $ac_cv_lib_krb4_main
= yes; then
  cat >>confdefs.h <<_ACEOF @%:@define HAVE_LIBKRB4 1 _ACEOF

  LIBS="-lkrb4 $LIBS"

fi

                                if test "$ac_cv_lib_krb4_main" !=
yes;    then                                            {    echo
"$as_me:__oline__: WARNING: Cannot find libkrb nor libkrb4, build
may  fail"  >&5  echo  "$as_me:  WARNING:  Cannot find libkrb nor
libkrb4,         build          may          fail"          >&2;}
                                else
                                        KLIBS="-lkrb4"
                                fi                           else
                                KLIBS="-lkrb"
                        fi                                   echo
"$as_me:__oline__: checking for  des_cbc_encrypt  in  -ldes"  >&5
echo  $ECHO_N  "checking for des_cbc_encrypt in -ldes... $ECHO_C"
des_cbc_encrypt ();
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_des_des_cbc_encrypt=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_cv_lib_des_des_cbc_encrypt=no  fi  rm  -f  conftest.$ac_objext
conftest$ac_exeext conftest.$ac_ext  LIBS=$ac_check_lib_save_LIBS
fi  echo  "$as_me:__oline__:  result:  $ac_cv_lib_des_des_cbc_en-
crypt" >&5 echo "${ECHO_T}$ac_cv_lib_des_des_cbc_encrypt" >&6  if
test $ac_cv_lib_des_des_cbc_encrypt = yes; then
  cat >>confdefs.h <<_ACEOF @%:@define HAVE_LIBDES 1 _ACEOF

  LIBS="-ldes $LIBS"

fi

                        if  test "$ac_cv_lib_des_des_cbc_encrypt"
!=    yes;     then                                          echo
"$as_me:__oline__:  checking for des_cbc_encrypt in -ldes425" >&5
echo  $ECHO_N  "checking  for  des_cbc_encrypt   in   -ldes425...
$ECHO_C"  >&6 if test "${ac_cv_lib_des425_des_cbc_encrypt+set}" =
set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  ac_check_lib_save_LIBS=$LIBS LIBS="-ldes425  $LIBS"  cat  >con-
ftest.$ac_ext   <<_ACEOF  #line  __oline__  "configure"  #include
"confdefs.h"

/* Override any gcc2 internal prototype to avoid  an  error.   */
#ifdef  __cplusplus  extern "C" #endif /* We use char because int
might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char  des_cbc_encrypt (); #ifdef F77_DUMMY_MAIN #  ifdef __cplus-
plus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return  1;  }  #endif  int  main  ()  {
des_cbc_encrypt ();
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?

if test $ac_cv_lib_des425_des_cbc_encrypt = yes; then
  cat >>confdefs.h <<_ACEOF @%:@define HAVE_LIBDES425 1 _ACEOF

  LIBS="-ldes425 $LIBS"

fi

                                if                           test
"$ac_cv_lib_des425_des_cbc_encrypt"      !=       yes;       then
                                        { echo "$as_me:__oline__:
WARNING: Cannot find libdes nor libdes425, build  may  fail"  >&5
echo  "$as_me:  WARNING:  Cannot find libdes nor libdes425, build
may     fail"     >&2;}                                      else
                                        KLIBS="-ldes425"
                                fi                           else
                                KLIBS="-ldes"
                        fi                                   echo
"$as_me:__oline__:  checking  for dn_expand in -lresolv" >&5 echo
$ECHO_N "checking for dn_expand in -lresolv...  $ECHO_C"  >&6  if
test "${ac_cv_lib_resolv_dn_expand+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  ac_check_lib_save_LIBS=$LIBS  LIBS="-lresolv   $LIBS" cat >con-
ftest.$ac_ext  <<_ACEOF  #line  __oline__  "configure"   #include
"confdefs.h"

/*  Override  any  gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus extern "C" #endif /* We use char  because  int
might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char dn_expand (); #ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () { dn_ex-
pand ();
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_resolv_dn_expand=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5
ac_cv_lib_resolv_dn_expand=no  fi  rm -f conftest.$ac_objext con-
ftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS  fi
echo  "$as_me:__oline__: result: $ac_cv_lib_resolv_dn_expand" >&5
echo   "${ECHO_T}$ac_cv_lib_resolv_dn_expand"   >&6    if    test
fi;

# Check whether user wants AFS support AFS_MSG="no"

# Check whether --with-afs or --without-afs was given.   if  test
"${with_afs+set}" = set; then
  withval="$with_afs"

                if test "x$withval" != "xno" ; then

                        if  test  "x$withval"  !=  "xyes"  ; then
                                CPPFLAGS="$CPPFLAGS     -I${with-
val}/include"                                   LDFLAGS="$LDFLAGS
-L${withval}/lib"                         fi

                        if    test    -z    "$KRB4"    ;     then
                                {  echo  "$as_me:__oline__: WARN-
ING: AFS requires Kerberos IV support, build may fail"  >&5  echo
"$as_me:  WARNING:  AFS  requires  Kerberos IV support, build may
fail" >&2;}                         fi

                        LIBS="-lkafs                       $LIBS"
                        if   test   !   -z   "$AFS_LIBS"  ;  then
                                LIBS="$LIBS            $AFS_LIBS"
                        fi                                    cat
>>confdefs.h <<_ACEOF @%:@define AFS 1 _ACEOF

                        AFS_MSG="yes"                 fi

fi; LIBS="$LIBS $KLIBS"

# Looking for programs, paths and files

#  Check  whether --with-rsh or --without-rsh was given.  if test
"${with_rsh+set}" = set; then
  withval="$with_rsh"

                if   test   "x$withval"   !=   "$no"    ;    then
                        rsh_path=$withval                      fi
         else

                # Extract the first word of "rsh", so it can be a
program   name   with  args.   set  dummy  rsh;  ac_word=$2  echo
"$as_me:__oline__:  checking  for  $ac_word"  >&5  echo   $ECHO_N
"checking     for    $ac_word...    $ECHO_C"    >&6    if    test
"${ac_cv_path_rsh_path+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $rsh_path in
  [\/]* | ?:[\/]*)
  ac_cv_path_rsh_path="$rsh_path" # Let  the  user  override  the
test with a path.
  ;;

"${ECHO_T}$rsh_path" >&6 else
  echo  "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no" >&6
fi



fi;


# Check whether --with-xauth or --without-xauth  was  given.   if
test "${with_xauth+set}" = set; then
  withval="$with_xauth"

                if    test    "x$withval"   !=   "xno"   ;   then
                        xauth_path=$withval                    fi
         else

                # Extract the first word of "xauth", so it can be
a program name with  args.   set  dummy  xauth;  ac_word=$2  echo
"$as_me:__oline__:   checking  for  $ac_word"  >&5  echo  $ECHO_N
"checking    for    $ac_word...    $ECHO_C"    >&6    if     test
"${ac_cv_path_xauth_path+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $xauth_path in
  [\/]* | ?:[\/]*)
  ac_cv_path_xauth_path="$xauth_path" # Let the user override the
test with a path.
  ;;
  *)
  ac_save_IFS=$IFS;        IFS=$ac_path_separator         ac_dum-
my="$PATH:/usr/X/bin:/usr/bin/X11:/usr/X11R6/bin:/usr/open-
win/bin" for ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  if $as_executable_p "$ac_dir/$ac_word"; then
   ac_cv_path_xauth_path="$ac_dir/$ac_word"
   echo "$as_me:__oline__: found $ac_dir/$ac_word" >&5
   break fi done

  ;; esac fi xauth_path=$ac_cv_path_xauth_path

if test -n "$xauth_path"; then
  echo   "$as_me:__oline__:   result:   $xauth_path"   >&5   echo
"${ECHO_T}$xauth_path" >&6 else
  echo  "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no" >&6
fi

                if  (test  !  -z   "$xauth_path"   &&   test   -x
"/usr/openwin/bin/xauth")                  ;                 then
                        xauth_path="/usr/openwin/bin/xauth"
                fi

$MAIL`         cat >>confdefs.h <<_ACEOF @%:@define MAIL_DIRECTO-
RY "$maildir" _ACEOF

fi

if test -z "$no_dev_ptmx" ; then         echo  "$as_me:__oline__:
checking    for    echo    $ECHO_N    "checking   for   if   test
"${ac_cv_file___dev_ptmx_+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  test "$cross_compiling" = yes &&
  { { echo "$as_me:__oline__: error: cannot check for file  exis-
tence when cross compiling" >&5 echo "$as_me: error: cannot check
for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; } if test -r ""/dev/ptmx""; then
  ac_cv_file___dev_ptmx_=yes else
  ac_cv_file___dev_ptmx_=no fi fi echo "$as_me:__oline__: result:
$ac_cv_file___dev_ptmx_" >&5 echo "${ECHO_T}$ac_cv_file___dev_pt-
mx_" >&6 if test $ac_cv_file___dev_ptmx_ = yes; then

                        cat  >>confdefs.h   <<_ACEOF   @%:@define
HAVE_DEV_PTMX 1 _ACEOF

                        have_dev_ptmx=1
fi

fi echo "$as_me:__oline__: checking for  echo  $ECHO_N  "checking
for if test "${ac_cv_file___dev_ptc_+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  test "$cross_compiling" = yes &&
  {  { echo "$as_me:__oline__: error: cannot check for file exis-
tence when cross compiling" >&5 echo "$as_me: error: cannot check
for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; } if test -r ""/dev/ptc""; then
  ac_cv_file___dev_ptc_=yes else
  ac_cv_file___dev_ptc_=no  fi fi echo "$as_me:__oline__: result:
$ac_cv_file___dev_ptc_"                 >&5                  echo
"${ECHO_T}$ac_cv_file___dev_ptc_"        >&6        if       test
$ac_cv_file___dev_ptc_ = yes; then

                cat     >>confdefs.h     <<_ACEOF      @%:@define
HAVE_DEV_PTS_AND_PTC 1 _ACEOF

                have_dev_ptc=1

fi


#  Options  from  here  on.  Some of these are preset by platform
above

#  Check  for  user-specified  random  device,  otherwise   check
/dev/urandom
test "${ac_cv_file___dev_urandom_+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  test "$cross_compiling" = yes &&
  {  { echo "$as_me:__oline__: error: cannot check for file exis-
tence when cross compiling" >&5 echo "$as_me: error: cannot check
for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; } if test -r ""/dev/urandom""; then
  ac_cv_file___dev_urandom_=yes else
  ac_cv_file___dev_urandom_=no  fi fi echo "$as_me:__oline__: re-
sult:        $ac_cv_file___dev_urandom_"         >&5         echo
"${ECHO_T}$ac_cv_file___dev_urandom_"       >&6      if      test
$ac_cv_file___dev_urandom_ = yes; then

                                RANDOM_POOL="/dev/urandom";

                                cat >>confdefs.h <<_ACEOF @%:@de-
fine RANDOM_POOL "$RANDOM_POOL" _ACEOF

                                          fi



fi;

# Check for PRNGD/EGD pool file

#  Check  whether  --with-prngd-port  or --without-prngd-port was
given.  if test "${with_prngd_port+set}" = set; then
  withval="$with_prngd_port"

                if test ! -z "$withval" -a "x$withval" != "xno" ;
then                                        PRNGD_PORT="$withval"
                        cat  >>confdefs.h   <<_ACEOF   @%:@define
PRNGD_PORT $PRNGD_PORT _ACEOF

                fi

fi;

# Check for PRNGD/EGD pool file

# Check whether --with-prngd-socket or --without-prngd-socket was
given.  if test "${with_prngd_socket+set}" = set; then
  withval="$with_prngd_socket"

                if   test   "x$withval"   !=   "xno"    ;    then
                        PRNGD_SOCKET="$withval"
                        cat  >>confdefs.h   <<_ACEOF   @%:@define
PRNGD_SOCKET "$PRNGD_SOCKET" _ACEOF

                fi          else

                                fi                           done
                        if  test  !  -z  "$PRNGD_SOCKET"  ;  then
                                echo  "$as_me:__oline__:  result:
$PRNGD_SOCKET"    >&5    echo    "${ECHO_T}$PRNGD_SOCKET"     >&6
                        else                                 echo
"$as_me:__oline__: result:  not  found"  >&5  echo  "${ECHO_T}not
found" >&6                         fi                 fi

fi;


# detect pathnames for entropy gathering  commands,  if  we  need
them  INSTALL_SSH_PRNG_CMDS=""  rm  -f  prng_commands if (test -z
"$RANDOM_POOL" && test -z "$PRNGD") ; then          #  Use  these
commands  to collect entropy                  # Extract the first
word of "ls", so it can be a program name with args.   set  dummy
ls; ac_word=$2 echo "$as_me:__oline__: checking for $ac_word" >&5
echo $ECHO_N "checking  for  $ac_word...  $ECHO_C"  >&6  if  test
"${ac_cv_path_PROG_LS+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $PROG_LS in
  [\/]* | ?:[\/]*)
  ac_cv_path_PROG_LS="$PROG_LS"  # Let the user override the test
with a path.
  ;;
  *)
  ac_save_IFS=$IFS; IFS=$ac_path_separator  ac_dummy="$PATH"  for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  if $as_executable_p "$ac_dir/$ac_word"; then
   ac_cv_path_PROG_LS="$ac_dir/$ac_word"
   echo "$as_me:__oline__: found $ac_dir/$ac_word" >&5
   break fi done

  ;; esac fi PROG_LS=$ac_cv_path_PROG_LS

if test -n "$PROG_LS"; then
  echo    "$as_me:__oline__:    result:    $PROG_LS"   >&5   echo
"${ECHO_T}$PROG_LS" >&6 else
  echo "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no"  >&6
fi

        if test -z "$PROG_LS" ; then                 PROG_LS="un-
def"         fi

                 # Extract the first word of "netstat", so it can
be  a program name with args.  set dummy netstat; ac_word=$2 echo
"$as_me:__oline__:  checking  for  $ac_word"  >&5  echo   $ECHO_N
"checking     for    $ac_word...    $ECHO_C"    >&6    if    test
"${ac_cv_path_PROG_NETSTAT+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else

  ;; esac fi PROG_NETSTAT=$ac_cv_path_PROG_NETSTAT

if test -n "$PROG_NETSTAT"; then
  echo  "$as_me:__oline__:  result:   $PROG_NETSTAT"   >&5   echo
"${ECHO_T}$PROG_NETSTAT" >&6 else
  echo  "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no" >&6
fi

        if     test      -z      "$PROG_NETSTAT"      ;      then
                PROG_NETSTAT="undef"         fi

                  # Extract the first word of "arp", so it can be
a program  name  with  args.   set  dummy  arp;  ac_word=$2  echo
"$as_me:__oline__:   checking  for  $ac_word"  >&5  echo  $ECHO_N
"checking    for    $ac_word...    $ECHO_C"    >&6    if     test
"${ac_cv_path_PROG_ARP+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $PROG_ARP in
  [\/]* | ?:[\/]*)
  ac_cv_path_PROG_ARP="$PROG_ARP"  #  Let  the  user override the
test with a path.
  ;;
  *)
  ac_save_IFS=$IFS; IFS=$ac_path_separator  ac_dummy="$PATH"  for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  if $as_executable_p "$ac_dir/$ac_word"; then
   ac_cv_path_PROG_ARP="$ac_dir/$ac_word"
   echo "$as_me:__oline__: found $ac_dir/$ac_word" >&5
   break fi done

  ;; esac fi PROG_ARP=$ac_cv_path_PROG_ARP

if test -n "$PROG_ARP"; then
  echo    "$as_me:__oline__:    result:   $PROG_ARP"   >&5   echo
"${ECHO_T}$PROG_ARP" >&6 else
  echo "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no"  >&6
fi

        if       test       -z       "$PROG_ARP"      ;      then
                PROG_ARP="undef"         fi

                 # Extract the first word of  "ifconfig",  so  it
can  be a program name with args.  set dummy ifconfig; ac_word=$2
echo "$as_me:__oline__: checking for $ac_word" >&5  echo  $ECHO_N
"checking     for    $ac_word...    $ECHO_C"    >&6    if    test
"${ac_cv_path_PROG_IFCONFIG+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $PROG_IFCONFIG in
  [\/]* | ?:[\/]*)

if test -n "$PROG_IFCONFIG"; then
  echo  "$as_me:__oline__:  result:  $PROG_IFCONFIG"   >&5   echo
"${ECHO_T}$PROG_IFCONFIG" >&6 else
  echo  "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no" >&6
fi

        if     test     -z      "$PROG_IFCONFIG"      ;      then
                PROG_IFCONFIG="undef"         fi

                  #  Extract the first word of "jstat", so it can
be a program name with args.  set dummy  jstat;  ac_word=$2  echo
"$as_me:__oline__:   checking  for  $ac_word"  >&5  echo  $ECHO_N
"checking    for    $ac_word...    $ECHO_C"    >&6    if     test
"${ac_cv_path_PROG_JSTAT+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $PROG_JSTAT in
  [\/]* | ?:[\/]*)
  ac_cv_path_PROG_JSTAT="$PROG_JSTAT" # Let the user override the
test with a path.
  ;;
  *)
  ac_save_IFS=$IFS; IFS=$ac_path_separator  ac_dummy="$PATH"  for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  if $as_executable_p "$ac_dir/$ac_word"; then
   ac_cv_path_PROG_JSTAT="$ac_dir/$ac_word"
   echo "$as_me:__oline__: found $ac_dir/$ac_word" >&5
   break fi done

  ;; esac fi PROG_JSTAT=$ac_cv_path_PROG_JSTAT

if test -n "$PROG_JSTAT"; then
  echo   "$as_me:__oline__:   result:   $PROG_JSTAT"   >&5   echo
"${ECHO_T}$PROG_JSTAT" >&6 else
  echo "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no"  >&6
fi

        if  test -z "$PROG_JSTAT" ; then                 PROG_JS-
TAT="undef"         fi

                 # Extract the first word of "ps", so it can be a
program   name   with   args.   set  dummy  ps;  ac_word=$2  echo
"$as_me:__oline__:  checking  for  $ac_word"  >&5  echo   $ECHO_N
"checking     for    $ac_word...    $ECHO_C"    >&6    if    test
"${ac_cv_path_PROG_PS+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $PROG_PS in
  [\/]* | ?:[\/]*)
  ac_cv_path_PROG_PS="$PROG_PS" # Let the user override the  test
with a path.
  echo   "$as_me:__oline__:   result:    $PROG_PS"    >&5    echo
"${ECHO_T}$PROG_PS" >&6 else
  echo  "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no" >&6
fi

        if test -z "$PROG_PS" ; then                 PROG_PS="un-
def"         fi

                  # Extract the first word of "sar", so it can be
a program  name  with  args.   set  dummy  sar;  ac_word=$2  echo
"$as_me:__oline__:   checking  for  $ac_word"  >&5  echo  $ECHO_N
"checking    for    $ac_word...    $ECHO_C"    >&6    if     test
"${ac_cv_path_PROG_SAR+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $PROG_SAR in
  [\/]* | ?:[\/]*)
  ac_cv_path_PROG_SAR="$PROG_SAR"  #  Let  the  user override the
test with a path.
  ;;
  *)
  ac_save_IFS=$IFS; IFS=$ac_path_separator  ac_dummy="$PATH"  for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  if $as_executable_p "$ac_dir/$ac_word"; then
   ac_cv_path_PROG_SAR="$ac_dir/$ac_word"
   echo "$as_me:__oline__: found $ac_dir/$ac_word" >&5
   break fi done

  ;; esac fi PROG_SAR=$ac_cv_path_PROG_SAR

if test -n "$PROG_SAR"; then
  echo    "$as_me:__oline__:    result:   $PROG_SAR"   >&5   echo
"${ECHO_T}$PROG_SAR" >&6 else
  echo "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no"  >&6
fi

        if       test       -z       "$PROG_SAR"      ;      then
                PROG_SAR="undef"         fi

                 # Extract the first word of "w", so it can be  a
program   name   with   args.    set  dummy  w;  ac_word=$2  echo
"$as_me:__oline__:  checking  for  $ac_word"  >&5  echo   $ECHO_N
"checking     for    $ac_word...    $ECHO_C"    >&6    if    test
"${ac_cv_path_PROG_W+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $PROG_W in
  [\/]* | ?:[\/]*)
  ac_cv_path_PROG_W="$PROG_W" # Let the user  override  the  test
with a path.
  ;;
  *)
  echo  "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no" >&6
fi

        if test -z "$PROG_W" ;  then                  PROG_W="un-
def"         fi

                  # Extract the first word of "who", so it can be
a program  name  with  args.   set  dummy  who;  ac_word=$2  echo
"$as_me:__oline__:   checking  for  $ac_word"  >&5  echo  $ECHO_N
"checking    for    $ac_word...    $ECHO_C"    >&6    if     test
"${ac_cv_path_PROG_WHO+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $PROG_WHO in
  [\/]* | ?:[\/]*)
  ac_cv_path_PROG_WHO="$PROG_WHO"  #  Let  the  user override the
test with a path.
  ;;
  *)
  ac_save_IFS=$IFS; IFS=$ac_path_separator  ac_dummy="$PATH"  for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  if $as_executable_p "$ac_dir/$ac_word"; then
   ac_cv_path_PROG_WHO="$ac_dir/$ac_word"
   echo "$as_me:__oline__: found $ac_dir/$ac_word" >&5
   break fi done

  ;; esac fi PROG_WHO=$ac_cv_path_PROG_WHO

if test -n "$PROG_WHO"; then
  echo    "$as_me:__oline__:    result:   $PROG_WHO"   >&5   echo
"${ECHO_T}$PROG_WHO" >&6 else
  echo "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no"  >&6
fi

        if       test       -z       "$PROG_WHO"      ;      then
                PROG_WHO="undef"         fi

                 # Extract the first word of "last", so it can be
a  program  name  with  args.   set  dummy  last; ac_word=$2 echo
"$as_me:__oline__:  checking  for  $ac_word"  >&5  echo   $ECHO_N
"checking     for    $ac_word...    $ECHO_C"    >&6    if    test
"${ac_cv_path_PROG_LAST+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $PROG_LAST in
  [\/]* | ?:[\/]*)
  ac_cv_path_PROG_LAST="$PROG_LAST" # Let the user  override  the
test with a path.
  ;;
  *)
  ac_save_IFS=$IFS;  IFS=$ac_path_separator  ac_dummy="$PATH" for
ac_dir in $ac_dummy; do

        if      test      -z      "$PROG_LAST"       ;       then
                PROG_LAST="undef"         fi

                 # Extract the first word of "lastlog", so it can
be a program name with args.  set dummy lastlog; ac_word=$2  echo
"$as_me:__oline__:   checking  for  $ac_word"  >&5  echo  $ECHO_N
"checking    for    $ac_word...    $ECHO_C"    >&6    if     test
"${ac_cv_path_PROG_LASTLOG+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $PROG_LASTLOG in
  [\/]* | ?:[\/]*)
  ac_cv_path_PROG_LASTLOG="$PROG_LASTLOG" # Let the user override
the test with a path.
  ;;
  *)
  ac_save_IFS=$IFS; IFS=$ac_path_separator  ac_dummy="$PATH"  for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  if $as_executable_p "$ac_dir/$ac_word"; then
   ac_cv_path_PROG_LASTLOG="$ac_dir/$ac_word"
   echo "$as_me:__oline__: found $ac_dir/$ac_word" >&5
   break fi done

  ;; esac fi PROG_LASTLOG=$ac_cv_path_PROG_LASTLOG

if test -n "$PROG_LASTLOG"; then
  echo   "$as_me:__oline__:   result:   $PROG_LASTLOG"  >&5  echo
"${ECHO_T}$PROG_LASTLOG" >&6 else
  echo "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no"  >&6
fi

        if      test      -z      "$PROG_LASTLOG"      ;     then
                PROG_LASTLOG="undef"         fi

                 # Extract the first word of "df", so it can be a
program   name   with   args.   set  dummy  df;  ac_word=$2  echo
"$as_me:__oline__:  checking  for  $ac_word"  >&5  echo   $ECHO_N
"checking     for    $ac_word...    $ECHO_C"    >&6    if    test
"${ac_cv_path_PROG_DF+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $PROG_DF in
  [\/]* | ?:[\/]*)
  ac_cv_path_PROG_DF="$PROG_DF" # Let the user override the  test
with a path.
  ;;
  *)
  ac_save_IFS=$IFS;  IFS=$ac_path_separator  ac_dummy="$PATH" for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.

def"         fi

                  # Extract the first word of "vmstat", so it can
be a program name with args.  set dummy vmstat;  ac_word=$2  echo
"$as_me:__oline__:   checking  for  $ac_word"  >&5  echo  $ECHO_N
"checking    for    $ac_word...    $ECHO_C"    >&6    if     test
"${ac_cv_path_PROG_VMSTAT+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $PROG_VMSTAT in
  [\/]* | ?:[\/]*)
  ac_cv_path_PROG_VMSTAT="$PROG_VMSTAT"  #  Let the user override
the test with a path.
  ;;
  *)
  ac_save_IFS=$IFS; IFS=$ac_path_separator  ac_dummy="$PATH"  for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  if $as_executable_p "$ac_dir/$ac_word"; then
   ac_cv_path_PROG_VMSTAT="$ac_dir/$ac_word"
   echo "$as_me:__oline__: found $ac_dir/$ac_word" >&5
   break fi done

  ;; esac fi PROG_VMSTAT=$ac_cv_path_PROG_VMSTAT

if test -n "$PROG_VMSTAT"; then
  echo   "$as_me:__oline__:   result:   $PROG_VMSTAT"   >&5  echo
"${ECHO_T}$PROG_VMSTAT" >&6 else
  echo "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no"  >&6
fi

        if test -z "$PROG_VMSTAT" ; then                 PROG_VM-
STAT="undef"         fi

                 # Extract the first word of "uptime", so it  can
be  a  program name with args.  set dummy uptime; ac_word=$2 echo
"$as_me:__oline__:  checking  for  $ac_word"  >&5  echo   $ECHO_N
"checking     for    $ac_word...    $ECHO_C"    >&6    if    test
"${ac_cv_path_PROG_UPTIME+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $PROG_UPTIME in
  [\/]* | ?:[\/]*)
  ac_cv_path_PROG_UPTIME="$PROG_UPTIME" # Let the  user  override
the test with a path.
  ;;
  *)
  ac_save_IFS=$IFS;  IFS=$ac_path_separator  ac_dummy="$PATH" for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  if $as_executable_p "$ac_dir/$ac_word"; then
   ac_cv_path_PROG_UPTIME="$ac_dir/$ac_word"
                 # Extract the first word of "ipcs", so it can be
a program name  with  args.   set  dummy  ipcs;  ac_word=$2  echo
"$as_me:__oline__:   checking  for  $ac_word"  >&5  echo  $ECHO_N
"checking    for    $ac_word...    $ECHO_C"    >&6    if     test
"${ac_cv_path_PROG_IPCS+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $PROG_IPCS in
  [\/]* | ?:[\/]*)
  ac_cv_path_PROG_IPCS="$PROG_IPCS"  #  Let the user override the
test with a path.
  ;;
  *)
  ac_save_IFS=$IFS; IFS=$ac_path_separator  ac_dummy="$PATH"  for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  if $as_executable_p "$ac_dir/$ac_word"; then
   ac_cv_path_PROG_IPCS="$ac_dir/$ac_word"
   echo "$as_me:__oline__: found $ac_dir/$ac_word" >&5
   break fi done

  ;; esac fi PROG_IPCS=$ac_cv_path_PROG_IPCS

if test -n "$PROG_IPCS"; then
  echo    "$as_me:__oline__:   result:   $PROG_IPCS"   >&5   echo
"${ECHO_T}$PROG_IPCS" >&6 else
  echo "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no"  >&6
fi

        if       test       -z      "$PROG_IPCS"      ;      then
                PROG_IPCS="undef"         fi

                 # Extract the first word of "tail", so it can be
a  program  name  with  args.   set  dummy  tail; ac_word=$2 echo
"$as_me:__oline__:  checking  for  $ac_word"  >&5  echo   $ECHO_N
"checking     for    $ac_word...    $ECHO_C"    >&6    if    test
"${ac_cv_path_PROG_TAIL+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $PROG_TAIL in
  [\/]* | ?:[\/]*)
  ac_cv_path_PROG_TAIL="$PROG_TAIL" # Let the user  override  the
test with a path.
  ;;
  *)
  ac_save_IFS=$IFS;  IFS=$ac_path_separator  ac_dummy="$PATH" for
ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  if $as_executable_p "$ac_dir/$ac_word"; then
   ac_cv_path_PROG_TAIL="$ac_dir/$ac_word"
   echo "$as_me:__oline__: found $ac_dir/$ac_word" >&5
   break fi done




#  Check  whether  --with-mantype or --without-mantype was given.
if test "${with_mantype+set}" = set; then
  withval="$with_mantype"

                case "$withval"  in                  man|cat|doc)
                        MANTYPE=$withval
                        ;;                                     *)
                        {  {  echo  "$as_me:__oline__: error: in-
valid man type: $withval" >&5 echo "$as_me:  error:  invalid  man
type: $withval" >&2;}
   {   (exit   1);   exit   1;  };  }                          ;;
                esac

fi; if test -z "$MANTYPE"; then         for ac_prog in nroff  awf
do
  #  Extract the first word of "$ac_prog", so it can be a program
name  with   args.    set   dummy   $ac_prog;   ac_word=$2   echo
"$as_me:__oline__:   checking  for  $ac_word"  >&5  echo  $ECHO_N
"checking    for    $ac_word...    $ECHO_C"    >&6    if     test
"${ac_cv_path_NROFF+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6 else
  case $NROFF in
  [\/]* | ?:[\/]*)
  ac_cv_path_NROFF="$NROFF" # Let the user override the test with
a path.
  ;;
  *)
  ac_save_IFS=$IFS;        IFS=$ac_path_separator         ac_dum-
my="/usr/bin:/usr/ucb" for ac_dir in $ac_dummy; do
  IFS=$ac_save_IFS
  test -z "$ac_dir" && ac_dir=.
  if $as_executable_p "$ac_dir/$ac_word"; then
   ac_cv_path_NROFF="$ac_dir/$ac_word"
   echo "$as_me:__oline__: found $ac_dir/$ac_word" >&5
   break fi done

  ;; esac fi NROFF=$ac_cv_path_NROFF

if test -n "$NROFF"; then
  echo    "$as_me:__oline__:    result:    $NROFF"    >&5    echo
"${ECHO_T}$NROFF" >&6 else
  echo "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no"  >&6
fi

  test   -n   "$NROFF"   &&   break  done  test  -n  "$NROFF"  ||
NROFF="/bin/false"

        if ${NROFF} -mdoc ${srcdir}/ssh.1 >/dev/null  2>&1;  then
                if    test    "x$withval"   !=   "xno"   ;   then
                        cat  >>confdefs.h   <<_ACEOF   @%:@define
HAVE_MD5_PASSWORDS 1 _ACEOF

                        MD5_MSG="yes"                 fi

fi;

# Whether to disable shadow password support

# Check whether --with-shadow or --without-shadow was given.   if
test "${with_shadow+set}" = set; then
  withval="$with_shadow"

                if   test   "x$withval"   =  "xno"  ;  then
                        cat >>confdefs.h <<_ACEOF @%:@define DIS-
ABLE_SHADOW 1 _ACEOF

                        disable_shadow=yes                     fi


fi;

if   test    -z    "$disable_shadow"    ;    then            echo
"$as_me:__oline__:  checking if the systems has expire shadow in-
formation" >&5 echo $ECHO_N "checking if the systems  has  expire
shadow  information... $ECHO_C" >&6         cat >conftest.$ac_ext
<<_ACEOF #line __oline__ "configure" #include "confdefs.h"

#include <sys/types.h> #include  <shadow.h>          struct  spwd
sp;          #ifdef F77_DUMMY_MAIN #  ifdef __cplusplus
     extern "C" #  endif
   int F77_DUMMY_MAIN() { return 1; } #endif int main () {
 sp.sp_expire = sp.sp_lstchg = sp.sp_inact = 0;
  ;
  return  0;  }  _ACEOF rm -f conftest.$ac_objext if { (eval echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   sp_expire_available=yes else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5

         fi rm -f conftest.$ac_objext conftest.$ac_ext

--with-ipaddr-display  or --without-ipaddr-display was given.  if
test "${with_ipaddr_display+set}" = set; then
  withval="$with_ipaddr_display"

                        if test "x$withval" != "xno" ;  then
                                cat >>confdefs.h <<_ACEOF @%:@de-
fine IPADDR_IN_DISPLAY 1 _ACEOF

                                DISPLAY_HACK_MSG="yes"
                        fi                           fi; fi

#  Whether  to  mess  with the default path SERVER_PATH_MSG="(de-
fault)"

# Check whether --with-default-path or --without-default-path was
given.  if test "${with_default_path+set}" = set; then
  withval="$with_default_path"

                if   test   "x$withval"   !=  "xno"  ;  then
                        user_path="$withval"
                        SERVER_PATH_MSG="$withval"
                fi          else

        if test "$cross_compiling" = yes; then
   user_path="/usr/bin:/bin:/usr/sbin:/sbin"          else
  cat >conftest.$ac_ext <<_ACEOF #line __oline__ "configure" #in-
clude "confdefs.h"

/*  find  out  what  STDPATH  is  */  #include  <stdio.h>  #ifdef
HAVE_PATHS_H # include <paths.h> #endif #ifndef  _PATH_STDPATH  #
define  _PATH_STDPATH "/usr/bin:/bin:/usr/sbin:/sbin" #endif #in-
clude <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #de-
fine DATA "conftest.stdpath"

main()  {         FILE *fd;         int rc;                  fd =
fopen(DATA,"w");         if(fd == NULL)                  exit(1);
                  if ((rc = fprintf(fd,"%s", _PATH_STDPATH)) < 0)
                exit(1);

        exit(0); }                  _ACEOF rm -f conftest$ac_exe-
ext if { (eval echo "$as_me:__oline__:
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   user_path=`cat conftest.stdpath` else
  echo  "$as_me:  program exited with status $ac_status" >&5 echo
                                user_path=$user_path:$t_bindir
                                echo  "$as_me:__oline__:  result:
Adding  $t_bindir  to  USER_PATH  so  scp  will  work"  >&5  echo
"${ECHO_T}Adding $t_bindir to USER_PATH so  scp  will  work"  >&6
                        fi                 fi

fi;  cat  >>confdefs.h <<_ACEOF @%:@define USER_PATH "$user_path"
_ACEOF



# Whether to force IPv4 by default (needed on broken glibc Linux)
IPV4_HACK_MSG="no"

# Check whether --with-ipv4-default or --without-ipv4-default was
given.  if test "${with_ipv4_default+set}" = set; then
  withval="$with_ipv4_default"

                if  test  "x$withval"  !=   "xno"   ;   then
                        cat   >>confdefs.h   <<_ACEOF  @%:@define
IPV4_DEFAULT 1 _ACEOF

                        IPV4_HACK_MSG="yes"                    fi


fi;

echo  "$as_me:__oline__:  checking  if we need to convert IPv4 in
IPv6-mapped addresses" >&5 echo $ECHO_N "checking if we  need  to
convert   IPv4   in   IPv6-mapped   addresses...   $ECHO_C"   >&6
IPV4_IN6_HACK_MSG="no"

# Check whether --with-4in6 or --without-4in6 was given.  if test
"${with_4in6+set}" = set; then
  withval="$with_4in6"

                if    test    "x$withval"   !=   "xno"   ;   then
                        echo "$as_me:__oline__: result: yes"  >&5
echo  "${ECHO_T}yes" >&6                         cat >>confdefs.h
<<_ACEOF @%:@define IPV4_IN_IPV6 1 _ACEOF

                        IPV4_IN6_HACK_MSG="yes"
                else                                         echo
"$as_me:__oline__:  result:  no"  >&5  echo   "${ECHO_T}no"   >&6
                fi          else

                if  test  "x$inet6_default_4in6"  =  "xyes"; then
                        echo "$as_me:__oline__: result: yes  (de-
fault)"     >&5     echo     "${ECHO_T}yes     (default)"     >&6
                        cat  >>confdefs.h   <<_ACEOF   @%:@define
IPV4_IN_IPV6 1 _ACEOF

                        cat  >>confdefs.h   <<_ACEOF   @%:@define
BSD_AUTH 1 _ACEOF

                        bsd_auth=yes                 fi

fi;

echo  "$as_me:__oline__:  checking whether to install ssh as suid
root" >&5 echo $ECHO_N "checking whether to install ssh  as  suid
root...  $ECHO_C" >&6 # Check whether --enable-suid-ssh or --dis-
able-suid-ssh was given.  if test "${enable_suid_ssh+set}" = set;
then
  enableval="$enable_suid_ssh"
   case "$enableval" in
  no)
       echo "$as_me:__oline__: result: no" >&5 echo "${ECHO_T}no"
>&6
       SSHMODE=0711
       ;;
  *)     echo   "$as_me:__oline__:   result:   yes"   >&5    echo
"${ECHO_T}yes" >&6
       SSHMODE=4711
       ;;
  esac else
  echo  "$as_me:__oline__:  result:  yes" >&5 echo "${ECHO_T}yes"
>&6
  SSHMODE=4711

fi;



# Where to place sshd.pid piddir=/var/run

# Check whether --with-pid-dir or  --without-pid-dir  was  given.
if test "${with_pid_dir+set}" = set; then
  withval="$with_pid_dir"

                if   test   "x$withval"   !=  "xno"  ;  then
                        piddir=$withval                        fi


fi;

# make sure the directory exists if test ! -d $piddir ; then
        piddir=`eval echo ${sysconfdir}`         case $piddir in
                NONE/*)    piddir=`echo     $piddir     |     sed
"s~NONE~$ac_default_prefix~"` ;;         esac fi

cat  >>confdefs.h  <<_ACEOF @%:@define _PATH_SSH_PIDDIR "$piddir"
_ACEOF

fi; # Check whether --enable-utmpx or --disable-utmpx was  given.
if test "${enable_utmpx+set}" = set; then
  enableval="$enable_utmpx"
   cat >>confdefs.h <<_ACEOF @%:@define DISABLE_UTMPX 1 _ACEOF


fi;  #  Check  whether --enable-wtmp or --disable-wtmp was given.
if test "${enable_wtmp+set}" = set; then
  enableval="$enable_wtmp"
   cat >>confdefs.h <<_ACEOF @%:@define DISABLE_WTMP 1 _ACEOF


fi; # Check whether --enable-wtmpx or --disable-wtmpx was  given.
if test "${enable_wtmpx+set}" = set; then
  enableval="$enable_wtmpx"
   cat >>confdefs.h <<_ACEOF @%:@define DISABLE_WTMPX 1 _ACEOF


fi;  #  Check  whether  --enable-libutil or --disable-libutil was
given.  if test "${enable_libutil+set}" = set; then
  enableval="$enable_libutil"
   cat >>confdefs.h <<_ACEOF @%:@define DISABLE_LOGIN 1 _ACEOF


fi; # Check whether --enable-pututline or --disable-pututline was
given.  if test "${enable_pututline+set}" = set; then
  enableval="$enable_pututline"
   cat >>confdefs.h <<_ACEOF @%:@define DISABLE_PUTUTLINE 1 _ACE-
OF


fi; # Check whether --enable-pututxline  or  --disable-pututxline
was given.  if test "${enable_pututxline+set}" = set; then
  enableval="$enable_pututxline"
   cat  >>confdefs.h  <<_ACEOF  @%:@define  DISABLE_PUTUTXLINE  1
_ACEOF


fi;

# Check whether --with-lastlog or  --without-lastlog  was  given.
if test "${with_lastlog+set}" = set; then
  withval="$with_lastlog"

                if   test   "x$withval"   =  "xno"  ;  then
                        cat >>confdefs.h <<_ACEOF @%:@define DIS-
ABLE_LASTLOG 1 _ACEOF

                else                           conf_lastlog_loca-
tion=$withval                 fi

fi;
  ;
  return 0; } _ACEOF rm -f conftest.$ac_objext if  {  (eval  echo
"$as_me:__oline__:
  (eval $ac_compile) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); } &&
         { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:__oline__:
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:__oline__:  = $ac_status" >&5
  (exit $ac_status); }; }; then
   echo  "$as_me:__oline__:  result: yes" >&5 echo "${ECHO_T}yes"
>&6 else
  echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5

                echo  "$as_me:__oline__:  result:  no"  >&5  echo
"${ECHO_T}no" >&6                 echo "$as_me:__oline__:  check-
ing  if  your  system  defines  _PATH_LASTLOG"  >&5  echo $ECHO_N
"checking if your system defines  _PATH_LASTLOG...  $ECHO_C"  >&6
                cat  >conftest.$ac_ext  <<_ACEOF  #line __oline__
"configure" #include "confdefs.h"

#include <sys/types.h> #include <utmp.h> #ifdef HAVE_LASTLOG_H  #
include   <lastlog.h>   #endif  #ifdef  HAVE_PATHS_H  #   include
/dev/null 2>&1; then
  set -o posix fi

# Name of the executable.  as_me=`echo "$0" |sed 's,.*[\/],,'`

if expr a : '' >/dev/null 2>&1; then
  as_expr=expr else
  as_expr=false fi

rm -f conf$$ conf$$.exe conf$$.file echo >conf$$.file  if  ln  -s
conf$$.file conf$$ 2>/dev/null; then
  #  We  could just check for DJGPP; but this test a) works b) is
more generic
  # and c) will remain valid once DJGPP supports symlinks  (DJGPP
2.04).
  if test -f conf$$.exe; then
    # Don't use ln at all; we don't have any links
    as_ln_s='cp -p'

# NLS nuisances.  $as_unset LANG || test "${LANG+set}" != set  ||
{ LANG=C; export LANG; } $as_unset LC_ALL || test "${LC_ALL+set}"
!= set || { LC_ALL=C; export LC_ALL; } $as_unset LC_TIME ||  test
"${LC_TIME+set}" != set || { LC_TIME=C; export LC_TIME; } $as_un-
set LC_CTYPE || test "${LC_CTYPE+set}" != set  ||  {  LC_CTYPE=C;
export  LC_CTYPE;  } $as_unset LANGUAGE || test "${LANGUAGE+set}"
!= set || { LANGUAGE=C; export LANGUAGE; }  $as_unset  LC_COLLATE
||  test  "${LC_COLLATE+set}"  !=  set  || { LC_COLLATE=C; export
LC_COLLATE; } $as_unset LC_NUMERIC || test "${LC_NUMERIC+set}" !=
set || { LC_NUMERIC=C; export LC_NUMERIC; } $as_unset LC_MESSAGES
|| test "${LC_MESSAGES+set}" != set ||  {  LC_MESSAGES=C;  export
LC_MESSAGES; }

# IFS # We need space, tab and new line, in precisely that order.
as_nl=' IFS="   $as_nl"

# CDPATH.  $as_unset CDPATH || test "${CDPATH+set}" != set  ||  {
CDPATH=:; export CDPATH; }

exec 6>&1

# Open the log real soon, to keep  and so on meaningful, and to #
report actual input values of CONFIG_FILES etc. instead of  their
#  values  after options handling.  Logging --version etc. is OK.
exec 5>>config.log {
  echo
  sed  'h;s/./-/g;s/^.../@%:@@%:@  /;s/...$/   @%:@@%:@/;p;x;p;x'
<<_ASBOX  @%:@@%:@  Running  s_me.  @%:@@%:@ _ASBOX } >&5 cat >&5
<<_CSEOF

This file was extended by $as_me, which was generated by GNU  Au-
toconf 2.52d.  Invocation command line was

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

_CSEOF  echo  "on  `(hostname || uname -n) 2>/dev/null | sed 1q`"
>&5 echo >&5 _ACEOF

# Files that config.status was made for.  if  test  -n  "$ac_con-
fig_files"; then
  echo "config_files= fi

if test -n "$ac_config_headers"; then
  echo "config_headers= fi

if test -n "$ac_config_links"; then
  echo "config_links= fi
      --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 <bug-autoconf@gnu.org>."  _ACEOF

cat >>$CONFIG_STATUS <<_ACEOF ac_cs_version="\ config.status con-
figured by $0, generated by GNU Autoconf 2.52d,
  with    options    \"`echo    "$ac_configure_args"    |     sed
's/[\""`/\\&/g'`\"

Copyright  1992,  1993,  1994, 1995, 1996, 1998, 1999, 2000, 2001
Free Software Foundation, Inc.  This config.status script is free
software; the Free Software Foundation gives unlimited permission
to copy, distribute and modify it."  srcdir=$srcdir INSTALL="$IN-
STALL" _ACEOF

cat  >>$CONFIG_STATUS  <<_ACEOF # If no file are specified by the
user, then we need to provide default # value.   By  we  need  to
know  if  files  were  specified by the user.  ac_need_defaults=:
while test $# != 0 do
  case $1 in
  --*=*)
    ac_option=`expr "x$1" : 'x=]*='`
    ac_optarg=`expr "x$1" : 'x[^=]*='`
    shift
    set dummy "$ac_option" "$ac_optarg" ${1+"$@"}
    shift
    ;;
  -*);;
  *) # This is not an option, so the user has probably given  ex-
plicit
     # arguments.
     ac_need_defaults=false;;
  esac

  case $1 in
  # Handling of the options.  _ACEOF cat >>$CONFIG_STATUS <<_ACE-
OF
  -recheck | --recheck | --rechec | --reche | --rech  |  --rec  |
--re | --r)
    echo  "running  $SHELL  $0 " $ac_configure_args " --no-create
--no-recursion"
    exec $SHELL $0 $ac_configure_args --no-create  --no-recursion
;; _ACEOF cat >>$CONFIG_STATUS <<_ACEOF
    CONFIG_FILES="$CONFIG_FILES $1"
    ac_need_defaults=false;;
  --header | --heade | --head | --hea )
    shift
    CONFIG_HEADERS="$CONFIG_HEADERS $1"
    ac_need_defaults=false;;

  # This is an error.
  -*)  { { echo "$as_me:__oline__: error: unrecognized option: $1
Try `$0 --help' for more information." >&5 echo  "$as_me:  error:
unrecognized  option:  $1  Try `$0 --help' for more information."
>&2;}
   { (exit 1); exit 1; }; } ;;

  *) ac_config_targets="$ac_config_targets $1" ;;

  esac
  shift done

_ACEOF





cat >>$CONFIG_STATUS <<_ACEOF for  ac_config_target  in  $ac_con-
fig_targets do
  case "$ac_config_target" in
  # Handling of arguments.
  "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
  "openbsd-compat/Makefile"  ) CONFIG_FILES="$CONFIG_FILES openb-
sd-compat/Makefile" ;;
  "scard/Makefile" ) CONFIG_FILES="$CONFIG_FILES  scard/Makefile"
;;
  "ssh_prng_cmds" ) CONFIG_FILES="$CONFIG_FILES ssh_prng_cmds" ;;
  "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
  *)  {  {  echo  "$as_me:__oline__:  error:  invalid   argument:
$ac_config_target"  >&5  echo  "$as_me:  error: invalid argument:
$ac_config_target" >&2;}
   { (exit 1); exit 1; }; };;
  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=$con-
fig_headers fi

#  Create  a temporary directory, and hook for its removal unless
_ACEOF

cat >>$CONFIG_STATUS <<_ACEOF

# # CONFIG_FILES section.  #

#  No  need to generate the scripts if there are no CONFIG_FILES.
# This happens for instance when ./config.status config.h if test
-n "ONFIG_FILES"; then
  #  Protect  against  being  on the right side of a sed subst in
config.status.
  sed 's/,@/@@/; s/@,/@@/; s/,;t t@;t t/; /@;t ts/[\\&,]/\\&/g;
   s/@@/,@/;  s/@@/@,/;  s/@;t  t,;t  t/'  >mp/subs.sed   <<\CEOF
s,@SHELL@,$SHELL,;t  t  s,@exec_prefix@,$exec_prefix,;t t s,@pre-
fix@,$prefix,;t   t    s,@program_transform_name@,$program_trans-
form_name,;t  t s,@bindir@,$bindir,;t t s,@sbindir@,$sbindir,;t t
s,@libexecdir@,$libexecdir,;t   t    s,@datadir@,$datadir,;t    t
s,@sysconfdir@,$sysconfdir,;t  t s,@sharedstatedir@,$sharedstate-
dir,;t t s,@localstatedir@,$localstatedir,;t  t  s,@libdir@,$lib-
dir,;t  t s,@includedir@,$includedir,;t t s,@oldincludedir@,$old-
includedir,;t t s,@infodir@,$infodir,;t t s,@mandir@,$mandir,;t t
s,@PACKAGE_NAME@,$PACKAGE_NAME,;t   t  s,@PACKAGE_TARNAME@,$PACK-
AGE_TARNAME,;t   t   s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t    t
s,@PACKAGE_STRING@,$PACKAGE_STRING,;t     t     s,@PACKAGE_BUGRE-
PORT@,$PACKAGE_BUGREPORT,;t t  s,@build_alias@,$build_alias,;t  t
s,@host_alias@,$host_alias,;t t s,@target_alias@,$target_alias,;t
t     s,@ECHO_C@,$ECHO_C,;t     t     s,@ECHO_N@,$ECHO_N,;t     t
s,@ECHO_T@,$ECHO_T,;t  t  s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
s,@DEFS@,$DEFS,;t   t   s,@LIBS@,$LIBS,;t   t   s,@CC@,$CC,;t   t
s,@CFLAGS@,$CFLAGS,;t       t      s,@LDFLAGS@,$LDFLAGS,;t      t
s,@CPPFLAGS@,$CPPFLAGS,;t t s,@ac_ct_CC@,$ac_ct_CC,;t  t  s,@EXE-
EXT@,$EXEEXT,;t  t  s,@OBJEXT@,$OBJEXT,;t t s,@build@,$build,;t t
s,@build_cpu@,$build_cpu,;t t s,@build_vendor@,$build_vendor,;t t
s,@build_os@,$build_os,;t       t       s,@host@,$host,;t       t
s,@host_cpu@,$host_cpu,;t  t  s,@host_vendor@,$host_vendor,;t   t
s,@host_os@,$host_os,;t t s,@CPP@,$CPP,;t t s,@RANLIB@,$RANLIB,;t
t  s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t  t  s,@INSTALL_PROGRAM@,$IN-
STALL_PROGRAM,;t t s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t s,@IN-
STALL_DATA@,$INSTALL_DATA,;t t s,@AR@,$AR,;t t  s,@PERL@,$PERL,;t
t   s,@ENT@,$ENT,;t  t  s,@FILEPRIV@,$FILEPRIV,;t  t  s,@TEST_MI-
NUS_S_SH@,$TEST_MINUS_S_SH,;t  t  s,@LOGIN_PROGRAM_FALLBACK@,$LO-
GIN_PROGRAM_FALLBACK,;t t s,@LD@,$LD,;t t s,@NO_SFTP@,$NO_SFTP,;t
t  s,@rsh_path@,$rsh_path,;t  t  s,@xauth_path@,$xauth_path,;t  t
s,@XAUTH_PATH@,$XAUTH_PATH,;t t s,@RANDOM_POOL@,$RANDOM_POOL,;t t
s,@PROG_LS@,$PROG_LS,;t  t  s,@PROG_NETSTAT@,$PROG_NETSTAT,;t   t
s,@PROG_ARP@,$PROG_ARP,;t t s,@PROG_IFCONFIG@,$PROG_IFCONFIG,;t t
s,@PROG_JSTAT@,$PROG_JSTAT,;t   t    s,@PROG_PS@,$PROG_PS,;t    t
s,@PROG_SAR@,$PROG_SAR,;t      t      s,@PROG_W@,$PROG_W,;t     t
s,@PROG_WHO@,$PROG_WHO,;t   t    s,@PROG_LAST@,$PROG_LAST,;t    t
s,@PROG_LASTLOG@,$PROG_LASTLOG,;t   t  s,@PROG_DF@,$PROG_DF,;t  t
s,@PROG_VMSTAT@,$PROG_VMSTAT,;t t s,@PROG_UPTIME@,$PROG_UPTIME,;t
t  s,@PROG_IPCS@,$PROG_IPCS,;t  t  s,@PROG_TAIL@,$PROG_TAIL,;t  t
file.
  ac_more_lines=:
  ac_sed_cmds=
  while $ac_more_lines; do
    if test $ac_beg -gt 1; then
      sed      "1,${ac_beg}d;      ${ac_end}q"      $tmp/subs.sed
>$tmp/subs.frag
    else
      sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
    fi
    if test ! -s $tmp/subs.frag; then
      ac_more_lines=false
    else
      # The purpose of the label and of the  branching  condition
is to
      #  speed up the sed processing (if there are no `@' at all,
there
      # is no need to browse any of the substitutions).
      # These are the two extra sed commands mentioned above.
      (echo ':t
  /@[a-zA-Z_][a-zA-Z_0-9]*@/!b'    &&     cat     $tmp/subs.frag)
>$tmp/subs-$ac_sed_frag.sed
      if test -z "$ac_sed_cmds"; then
        ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
      else
        ac_sed_cmds="$ac_sed_cmds         |         sed        -f
$tmp/subs-$ac_sed_frag.sed"
      fi
      ac_sed_frag=`expr $ac_sed_frag + 1`
      ac_beg=$ac_end
      ac_end=`expr $ac_end + $ac_max_sed_lines`
    fi
  done
  if test -z "$ac_sed_cmds"; then
    ac_sed_cmds=cat
  fi fi # test -n "$CONFIG_FILES"

_ACEOF cat >>$CONFIG_STATUS  <<_ACEOF  for  ac_file  in  :  $CON-
FIG_FILES; do test "x$ac_file" = x: && continue
  #   Support   "outfile[:infile[:infile...]]",   defaulting  in-
file="outfile.in".
  case $ac_file in
  - | *:- | *:-:* ) # input from stdin
        cat >$tmp/stdin
        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
  * )   ac_file_in=$ac_file.in ;;
  esac

  # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirecto-

"$@"`; do
  case $as_mkdir_dir in
    # Skip DOS drivespec
    ?:) as_incr_dir=$as_mkdir_dir ;;
    *)
      as_incr_dir=$as_incr_dir/$as_mkdir_dir
      test -d "$as_incr_dir" ||
        mkdir    "$as_incr_dir"    ||            {     {     echo
"$as_me:__oline__: error: cannot create echo "$as_me: error: can-
not create
   { (exit 1); exit 1; }; }
    ;;
  esac done; }

  if test "$ac_dir" != .; then
  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^./,,'`
  # A "../" for each directory in $ac_dir_suffix.
  ac_top_builddir=`echo "$ac_dir_suffix" | sed  's,/[^/]*,../,g'`
else
  ac_dir_suffix= ac_top_builddir= fi

case $srcdir in
  .)  # No --srcdir option.  We are building in place.
    ac_srcdir=.
    if test -z "$ac_top_builddir"; then
       ac_top_srcdir=.
    else
       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
    fi ;;
  [\/]* | ?:[\/]* )  # Absolute path.
    ac_srcdir=$srcdir$ac_dir_suffix;
    ac_top_srcdir=$srcdir ;;
  *) # Relative path.
    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
    ac_top_srcdir=$ac_top_builddir$srcdir ;; esac


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

  if test x"$ac_file" != x-; then
    {   echo   "$as_me:__oline__:  creating  $ac_file"  >&5  echo
"$as_me: creating $ac_file" >&6;}
    rm -f "$ac_file"
  fi
  # 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 automatically by config.status.
*/
         test  -f "$f" || { { echo "$as_me:__oline__: error: can-
not find input file: $f" >&5 echo "$as_me: error: cannot find in-
put file: $f" >&2;}
   { (exit 1); exit 1; }; }
         echo $f;;
      *) # Relative
         if test -f "$f"; then
           # Build tree
           echo $f
         elif test -f "$srcdir/$f"; then
           # Source tree
           echo $srcdir/$f
         else
           # /dev/null tree
           {  {  echo "$as_me:__oline__: error: cannot find input
file: $f" >&5 echo "$as_me: error: cannot find  input  file:  $f"
>&2;}
   { (exit 1); exit 1; }; }
         fi;;
      esac
    done`  ||  {  (exit 1); exit 1; } _ACEOF cat >>$CONFIG_STATUS
<<_ACEOF
  sed "$ac_vpsub $extrasub _ACEOF cat  >>$CONFIG_STATUS  <<_ACEOF
:t    /@[a-zA-Z_][a-zA-Z_0-9]*@/!b   s,@configure_input@,$config-
ure_input,;t    t    s,@srcdir@,$ac_srcdir,;t    t     s,@top_sr-
cdir@,$ac_top_srcdir,;t    t   s,@INSTALL@,$ac_INSTALL,;t   t   "
$ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
  rm -f $tmp/stdin
  if test x"$ac_file" != x-; then
    mv $tmp/out $ac_file
  else
    cat $tmp/out
    rm -f $tmp/out
  fi

done _ACEOF cat >>$CONFIG_STATUS <<_ACEOF

# # CONFIG_HEADER section.  #

# These sed commands are passed to sed as "A NAME B NAME C  VALUE
D",  where # NAME is the cpp macro being defined and VALUE is the
value it is being given.  # # ac_d sets  the  value  in  "#define
NAME  VALUE"  lines.   ac_dA='s,^      ]*#     ]*define[       ][
     ]*' ac_dB='[        ].*$,1#2' ac_dC=' ' ac_dD=',;t'  #  ac_u
turns  "#undef  NAME"  without trailing blanks into "#define NAME
VALUE".        ac_uA='s,^      ]*#     ]*undef ][             ]*'
ac_uB='$,1#2define3' ac_uC=' ' ac_uD=',;t'

for  ac_file  in  :  $CONFIG_HEADERS; do test "x$ac_file" = x: &&
continue
  #  Support   "outfile[:infile[:infile...]]",   defaulting   in-
file="outfile.in".
in the
  # src tree.
  ac_file_inputs=`IFS=:
    for f in $ac_file_in; do
      case $f in
      -) echo $tmp/stdin ;;
      [\/$]*)
         # Absolute (can't be DOS-style, as IFS=:)
         test  -f "$f" || { { echo "$as_me:__oline__: error: can-
not find input file: $f" >&5 echo "$as_me: error: cannot find in-
put file: $f" >&2;}
   { (exit 1); exit 1; }; }
         echo $f;;
      *) # Relative
         if test -f "$f"; then
           # Build tree
           echo $f
         elif test -f "$srcdir/$f"; then
           # Source tree
           echo $srcdir/$f
         else
           # /dev/null tree
           {  {  echo "$as_me:__oline__: error: cannot find input
file: $f" >&5 echo "$as_me: error: cannot find  input  file:  $f"
>&2;}
   { (exit 1); exit 1; }; }
         fi;;
      esac
    done` || { (exit 1); exit 1; }
  # Remove the trailing spaces.
  sed 's/[      ]*$//' $ac_file_inputs >$tmp/in

_ACEOF

#  Transform  confdefs.h into two sed scripts, `conftest.defines'
and # `conftest.undefs', that substitutes the proper values  into
# config.h.in to produce config.h.  The first handles `#define' #
templates, and the second `#undef' templates.  # And first:  Pro-
tect  against  being  on  the right side of a sed subst in # con-
fig.status.  Protect against being in an unquoted here document #
in config.status.  rm -f conftest.defines conftest.undefs # Using
a here document instead of a string reduces  the  quoting  night-
mare.   #  Putting  comments in sed scripts is not portable.  # #
`end' is used to avoid that the second main  sed  command  (meant
for  #  0-ary  CPP macros) applies to n-ary macro definitions.  #
See the Autoconf documentation for `clear'.  cat >confdef2sed.sed
<<_ACEOF  s/[\&,]/\&/g  s,[\$`],\&,g t clear : clear s,^[    ]*#[
   ]*define[         ][         ]*[^       (][^       (]*([^)]*)[
    ]*$,${ac_dA}2${ac_dB}1${ac_dC}3${ac_dD},gp t end s,^[    ]*#[
   ]*define[            ][          ]*           ][^          ]*[
    ]*$,${ac_dA}1${ac_dB}1${ac_dC}2${ac_dD},gp  : end _ACEOF # If
some macros were called several  times  there  might  be  several
the  size # of here documents, and old seds have small limits too
(100 cmds).  echo '  # Handle all the #define templates  only  if
necessary.'   >>$CONFIG_STATUS  echo  '   if  egrep  "^[     ]*#[
   ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS echo '  #
If  there  are  no  defines,  we may have an empty if/fi' >>$CON-
FIG_STATUS echo '  :' >>$CONFIG_STATUS rm -f conftest.tail  while
grep . conftest.defines >/dev/null do
  # Write a limited-size here document to $tmp/defines.sed.
  echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
  # Speed up: don't consider the non `#define' lines.
  echo '/^[     ]*#[    ]*define/!b' >>$CONFIG_STATUS
  # Work around the forget-to-reset-the-flag bug.
  echo 't clr' >>$CONFIG_STATUS
  echo ': clr' >>$CONFIG_STATUS
  sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
  echo 'CEOF
  sed -f $tmp/defines.sed $tmp/in >$tmp/out
  rm -f $tmp/in
  mv $tmp/out $tmp/in
  sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
  rm -f conftest.defines
  mv  conftest.tail  conftest.defines done rm -f conftest.defines
echo '  fi # egrep' >>$CONFIG_STATUS echo >>$CONFIG_STATUS

# Break up conftest.undefs because some shells have  a  limit  on
the  size # of here documents, and old seds have small limits too
(100 cmds).  echo '  # Handle all the #undef  templates'  >>$CON-
FIG_STATUS  rm  -f  conftest.tail  while  grep  . conftest.undefs
>/dev/null do
  # Write a limited-size here document to $tmp/undefs.sed.
  echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
  # Speed up: don't consider the non `#undef'
  echo '/^[     ]*#[    ]*undef/!b' >>$CONFIG_STATUS
  # Work around the forget-to-reset-the-flag bug.
  echo 't clr' >>$CONFIG_STATUS
  echo ': clr' >>$CONFIG_STATUS
  sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
  echo 'CEOF
  sed -f $tmp/undefs.sed $tmp/in >$tmp/out
  rm -f $tmp/in
  mv $tmp/out $tmp/in
  sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
  rm -f conftest.undefs
  mv conftest.tail conftest.undefs done rm -f conftest.undefs

cat >>$CONFIG_STATUS <<_ACEOF
  # 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 automatically by config.status.
*/
  if test x"$ac_file" = x-; then

X"$ac_file"   :   'X[^/]'               X"$ac_file"   :   'X$'
X"$ac_file"  :  'X'             .      :  ''  2>/dev/null || echo
X"$ac_file" |
    sed '/^X[^/]*[^/][^/]**$/{ s//1/; q; }
          /^X[^/].*/{ s//1/; q; }
          /^X$/{ s//1/; q; }
          /^X.*/{ s//1/; q; }
          s/.*/./; q'`
      { case "$ac_dir" in
  [\/]* | ?:[\/]* ) as_incr_dir=;;
  *)                      as_incr_dir=.;; esac as_dummy="$ac_dir"
for  as_mkdir_dir  in  `IFS='/\';  set  X  $as_dummy; shift; echo
"$@"`; do
  case $as_mkdir_dir in
    # Skip DOS drivespec
    ?:) as_incr_dir=$as_mkdir_dir ;;
    *)
      as_incr_dir=$as_incr_dir/$as_mkdir_dir
      test -d "$as_incr_dir" ||
        mkdir    "$as_incr_dir"    ||            {     {     echo
"$as_me:__oline__: error: cannot create echo "$as_me: error: can-
not create
   { (exit 1); exit 1; }; }
    ;;
  esac done; }

      rm -f $ac_file
      mv $tmp/config.h $ac_file
    fi
  else
    cat $tmp/config.h
    rm -f $tmp/config.h
  fi done _ACEOF

cat >>$CONFIG_STATUS <<_ACEOF

{  (exit  0);  exit  0;  }   _ACEOF   chmod   +x   $CONFIG_STATUS
ac_clean_files=$ac_clean_files_save


#  configure is writing to config.log, and then calls config.sta-
tus.  # config.status does its own redirection, appending to con-
fig.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=:
  exec 5>/dev/null
  $SHELL $CONFIG_STATUS || ac_cs_success=false
        else                   RAND_MSG="Builtin   (timeout  $en-
tropy_timeout)"                 BUILTIN_RNG=1         fi fi

# Someone please show me a better way :) A=`eval echo  ${prefix}`
; A=`eval echo ${A}` B=`eval echo ${bindir}` ; B=`eval echo ${B}`
C=`eval echo  ${sbindir}`  ;  C=`eval  echo  ${C}`  D=`eval  echo
${sysconfdir}`   ;  D=`eval  echo  ${D}`  E=`eval  echo  ${libex-
ecdir}/ssh-askpass`   ;   E=`eval   echo   ${E}`   F=`eval   echo
${mandir}/${mansubdir}X` ; F=`eval echo ${F}` G=`eval echo ${pid-
dir}` ; G=`eval echo ${G}` H=`eval echo ${user_path}`  ;  H=`eval
echo ${H}`

echo  "" echo "OpenSSH has been configured with the following op-
tions:"  echo  "                  User  binaries:  $B"   echo   "
System  binaries:  $C"  echo "           Configuration files: $D"
echo   "                  Askpass    program:    $E"    echo    "
Manual  pages: $F" echo "                      PID file: $G" echo
"        sshd default user PATH: $H" echo  "       Random  number
collection:  $RAND_MSG"  echo  "                 Manpage  format:
$MANTYPE" echo "                   PAM support: ${PAM_MSG}"  echo
"               KerberosIV    support:    $KRB4_MSG"    echo    "
Smartcard support: $SCARD_MSG" echo "                   AFS  sup-
port:  $AFS_MSG" echo "                 S/KEY support: $SKEY_MSG"
echo  "           TCP  Wrappers  support:   $TCPW_MSG"   echo   "
MD5  password  support:  $MD5_MSG"  echo "   IP address in ISPLAY
hack: $DISPLAY_HACK_MSG" echo "      Use IPv4  by  default  hack:
$IPV4_HACK_MSG"   echo   "         Translate   v4   in  v6  hack:
$IPV4_IN6_HACK_MSG"

if test ! -z "$bsd_auth"; then          echo  "               BSD
Auth support: yes" fi

echo ""

echo  "               Host:  ${host}"  echo  "          Compiler:
${CC}" echo "    Compiler flags:  ${CFLAGS}"  echo  "Preprocessor
flags:  ${CPPFLAGS}" echo "      Linker flags: ${LDFLAGS}" echo "
Libraries: ${LIBS}"

echo ""

if test "x$PAM_MSG" = "xyes" ; then         echo "PAM is enabled.
You   may   need  to  install  a  PAM  control  file  for  sshd,"
        echo "otherwise password authentication may fail. Example
PAM  control  files"          echo  "can be found in the contrib/
subdirectory"         echo "" fi

if test ! -z "$BUILTIN_RNG" ; then         echo "WARNING: you are
using    the   builtin   random   number   collection   service."
        echo "Please read WARNING.RNG and request  that  your  OS
vendor  includes"         echo "/dev/random in future versions of
their OS."          echo "" fi

Man(1) output converted with man2html