mk-conf.sh

   1 #!/bin/sh -
   2 #@ Please see INSTALL and make.rc instead.
   3
   4 LC_ALL=C
   5 export LC_ALL
   6
   7 # The feature set, to be kept in sync with make.rc
   8 # If no documentation given, the option is used as such; if doc is a hyphen,
   9 # entry is suppressed when configuration overview is printed, and also in the
  10 # *features* string: most likely for obsolete features etc.
  11 XOPTIONS="\
  12    ICONV='Character set conversion using iconv(3)' \
  13    SOCKETS='Network support' \
  14       SSL='SSL/TLS (OpenSSL / LibreSSL)' \
  15          SSL_ALL_ALGORITHMS='Support of all digest and cipher algorithms' \
  16       SMTP='Simple Mail Transfer Protocol client' \
  17       POP3='Post Office Protocol Version 3 client' \
  18       GSSAPI='Generic Security Service authentication' \
  19       NETRC='.netrc file support' \
  20       AGENT='-' \
  21       MD5='MD5 message digest (APOP, CRAM-MD5)' \
  22    IDNA='Internationalized Domain Names for Applications (encode only)' \
  23    IMAP_SEARCH='IMAP-style search expressions' \
  24    REGEX='Regular expressions' \
  25    MLE='Mailx Line Editor' \
  26       HISTORY='Line editor history management' \
  27       KEY_BINDINGS='Configurable key bindings' \
  28    TERMCAP='Terminal capability queries (termcap(5))' \
  29       TERMCAP_VIA_TERMINFO='Terminal capability queries use terminfo(5)' \
  30    ERRORS='Error log message ring' \
  31    SPAM_SPAMC='Spam management via spamc(1) of spamassassin(1)' \
  32    SPAM_SPAMD='-' \
  33    SPAM_FILTER='Freely configurable *spam-filter-..*s' \
  34    DOCSTRINGS='Command documentation help strings' \
  35    QUOTE_FOLD='Extended *quote-fold*ing' \
  36    FILTER_HTML_TAGSOUP='Simple builtin HTML-to-text display filter' \
  37    COLOUR='Coloured message display' \
  38    DOTLOCK='Dotlock files and privilege-separated dotlock program' \
  39 "
  40
  41 # Options which are automatically deduced from host environment, i.e., these
  42 # need special treatment all around here to warp from/to OPT_ stuff
  43 # setlocale, C90AMEND1, NL_LANGINFO, wcwidth
  44 XOPTIONS_DETECT="\
  45    LOCALES='Locale support - printable characters etc. depend on environment' \
  46    MULTIBYTE_CHARSETS='Multibyte character sets' \
  47    TERMINAL_CHARSET='Automatic detection of terminal character set' \
  48    WIDE_GLYPHS='Wide glyph support' \
  49 "
  50
  51 # Rather special options, for custom building, or which always exist.
  52 # Mostly for generating the visual overview and the *features* string
  53 XOPTIONS_XTRA="\
  54    MIME='Multipurpose Internet Mail Extensions' \
  55    SMIME='S/MIME message signing, verification, en- and decryption' \
  56    CROSS_BUILD='Cross-compilation: trust any detected environment' \
  57    DEBUG='Debug enabled binary, not for end-users: THANKS!' \
  58    DEVEL='Computers do not blunder' \
  59 "
  60
  61 # The problem is that we don't have any tools we can use right now, so
  62 # encapsulate stuff in functions which get called in right order later on
  63
  64 option_reset() {
  65    set -- ${OPTIONS}
  66    for i
  67    do
  68       eval OPT_${i}=0
  69    done
  70 }
  71
  72 option_maximal() {
  73    set -- ${OPTIONS}
  74    for i
  75    do
  76       eval OPT_${i}=1
  77    done
  78    OPT_ICONV=require
  79    OPT_REGEX=require
  80    OPT_DOTLOCK=require
  81 }
  82
  83 option_setup() {
  84    option_parse OPTIONS_DETECT "${XOPTIONS_DETECT}"
  85    option_parse OPTIONS "${XOPTIONS}"
  86    option_parse OPTIONS_XTRA "${XOPTIONS_XTRA}"
  87    OPT_MIME=1
  88
  89    # Predefined CONFIG= urations take precedence over anything else
  90    if [ -n "${CONFIG}" ]; then
  91       case "${CONFIG}" in
  92       [nN][uU][lL][lL])
  93          option_reset
  94          ;;
  95       [nN][uU][lL][lL][iI])
  96          option_reset
  97          OPT_ICONV=require
  98          ;;
  99       [mM][iI][nN][iI][mM][aA][lL])
 100          option_reset
 101          OPT_ICONV=1
 102          OPT_REGEX=1
 103          OPT_DOTLOCK=require
 104          ;;
 105       [mM][eE][dD][iI][uU][mM])
 106          option_reset
 107          OPT_ICONV=require
 108          OPT_IDNA=1
 109          OPT_REGEX=1
 110          OPT_MLE=1
 111             OPT_HISTORY=1 OPT_KEY_BINDINGS=1
 112          OPT_ERRORS=1
 113          OPT_SPAM_FILTER=1
 114          OPT_DOCSTRINGS=1
 115          OPT_COLOUR=1
 116          OPT_DOTLOCK=require
 117          ;;
 118       [nN][eE][tT][sS][eE][nN][dD])
 119          option_reset
 120          OPT_ICONV=require
 121          OPT_SOCKETS=1
 122             OPT_SSL=require
 123             OPT_SMTP=require
 124             OPT_GSSAPI=1 OPT_NETRC=1 OPT_AGENT=1
 125          OPT_IDNA=1
 126          OPT_REGEX=1
 127          OPT_MLE=1
 128             OPT_HISTORY=1 OPT_KEY_BINDINGS=1
 129          OPT_DOCSTRINGS=1
 130          OPT_COLOUR=1
 131          OPT_DOTLOCK=require
 132          ;;
 133       [mM][aA][xX][iI][mM][aA][lL])
 134          option_reset
 135          option_maximal
 136          ;;
 137       [dD][eE][vV][eE][lL])
 138          OPT_DEVEL=1 OPT_DEBUG=1 OPT_NYD2=1
 139          option_maximal
 140          ;;
 141       [oO][dD][eE][vV][eE][lL])
 142          OPT_DEVEL=1
 143          option_maximal
 144          ;;
 145       *)
 146          echo >&2 "Unknown CONFIG= setting: ${CONFIG}"
 147          echo >&2 '   NULL, NULLI, MINIMAL, MEDIUM, NETSEND, MAXIMAL'
 148          exit 1
 149          ;;
 150       esac
 151    fi
 152 }
 153
 154 # Inter-relationships
 155 option_update() {
 156    if feat_no SMTP && feat_no POP3; then
 157       OPT_SOCKETS=0
 158    fi
 159    if feat_no SOCKETS; then
 160       if feat_require SMTP; then
 161          msg 'ERROR: need SOCKETS for required feature SMTP'
 162          config_exit 13
 163       fi
 164       if feat_require POP3; then
 165          msg 'ERROR: need SOCKETS for required feature POP3'
 166          config_exit 13
 167       fi
 168       OPT_SSL=0 OPT_SSL_ALL_ALGORITHMS=0
 169       OPT_SMTP=0 OPT_POP3=0
 170       OPT_GSSAPI=0 OPT_NETRC=0 OPT_AGENT=0
 171    fi
 172    if feat_no SMTP; then
 173       OPT_GSSAPI=0
 174    fi
 175
 176    if feat_no MLE; then
 177       OPT_HISTORY=0 OPT_KEY_BINDINGS=0
 178    fi
 179
 180    # If we don't need MD5 leave it alone
 181    if feat_no SOCKETS; then
 182       OPT_MD5=0
 183    fi
 184
 185    if feat_yes DEVEL; then
 186       OPT_DEBUG=1
 187    fi
 188 }
 189
 190 rc=./make.rc
 191 lst=./config.lst
 192 ev=./config.ev
 193 h=./config.h h_name=config.h
 194 mk=./mk.mk
 195
 196 newlst=./config.lst-new
 197 newmk=./config.mk-new
 198 newev=./config.ev-new
 199 newh=./config.h-new
 200 tmp0=___tmp
 201 tmp=./${tmp0}1$$
 202 tmp2=./${tmp0}2$$
 203
 204 ##  --  >8  - << OPTIONS | OS/CC >> -  8<  --  ##
 205
 206 # Note that potential duplicates in PATH, C_INCLUDE_PATH etc. will be cleaned
 207 # via path_check() later on once possible
 208
 209 # TODO cc_maxopt is brute simple, we should compile test program and dig real
 210 # compiler versions for known compilers, then be more specific
 211 cc_maxopt=100
 212 _CFLAGS= _LDFLAGS=
 213
 214 os_early_setup() {
 215    # We don't "have any utility": only path adjustments and such in here!
 216    i="${OS:-`uname -s`}"
 217
 218    if [ ${i} = SunOS ]; then
 219       msg 'SunOS / Solaris?  Applying some "early setup" rules ...'
 220       _os_early_setup_sunos
 221    fi
 222 }
 223
 224 _os_early_setup_sunos() {
 225    # According to standards(5), this is what we need to do
 226    if [ -d /usr/xpg4 ]; then :; else
 227       msg 'ERROR: On SunOS / Solaris we need /usr/xpg4 environment!  Sorry.'
 228       config_exit 1
 229    fi
 230    PATH="/usr/xpg4/bin:/usr/ccs/bin:/usr/bin:${PATH}"
 231    [ -d /usr/xpg6 ] && PATH="/usr/xpg6/bin:${PATH}"
 232    export PATH
 233 }
 234
 235 os_setup() {
 236    # OSFULLSPEC is used to recognize changes (i.e., machine type, updates etc.)
 237    OSFULLSPEC="${OS:-`uname -a | ${tr} '[A-Z]' '[a-z]'`}"
 238    OS="${OS:-`uname -s | ${tr} '[A-Z]' '[a-z]'`}"
 239    msg 'Operating system is %s' ${OS}
 240
 241    if [ ${OS} = sunos ]; then
 242       msg ' . have special SunOS / Solaris "setup" rules ...'
 243       _os_setup_sunos
 244    elif [ ${OS} = unixware ]; then
 245       msg ' . have special UnixWare environmental rules ...'
 246       if feat_yes AUTOCC && command -v cc >/dev/null 2>&1; then
 247          CC=cc
 248          feat_yes DEBUG && _CFLAGS='-v -Xa -g' || _CFLAGS='-Xa -O'
 249
 250          CFLAGS="${_CFLAGS} ${EXTRA_CFLAGS}"
 251          LDFLAGS="${_LDFLAGS} ${EXTRA_LDFLAGS}"
 252          export CC CFLAGS LDFLAGS
 253          OPT_AUTOCC=0 had_want_autocc=1 need_R_ldflags=-R
 254       fi
 255    elif [ -n "${VERBOSE}" ]; then
 256       msg ' . no special treatment for this system necessary or known'
 257    fi
 258
 259    # Sledgehammer: better set _GNU_SOURCE
 260    # And in general: oh, boy!
 261    OS_DEFINES="${OS_DEFINES}#define _GNU_SOURCE\n"
 262    #OS_DEFINES="${OS_DEFINES}#define _POSIX_C_SOURCE 200809L\n"
 263    #OS_DEFINES="${OS_DEFINES}#define _XOPEN_SOURCE 700\n"
 264    #[ ${OS} = darwin ] && OS_DEFINES="${OS_DEFINES}#define _DARWIN_C_SOURCE\n"
 265
 266    # On pkgsrc(7) systems automatically add /usr/pkg/*
 267    if [ -d /usr/pkg ]; then
 268       C_INCLUDE_PATH="${C_INCLUDE_PATH}:/usr/pkg/include"
 269       LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:/usr/pkg/lib"
 270    fi
 271 }
 272
 273 _os_setup_sunos() {
 274    C_INCLUDE_PATH="/usr/xpg4/include:${C_INCLUDE_PATH}"
 275    LD_LIBRARY_PATH="/usr/xpg4/lib:${LD_LIBRARY_PATH}"
 276
 277    # Include packages
 278    if [ -d /opt/csw ]; then
 279       C_INCLUDE_PATH="${C_INCLUDE_PATH}:/opt/csw/include"
 280       LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:/opt/csw/lib"
 281    fi
 282
 283    OS_DEFINES="${OS_DEFINES}#define __EXTENSIONS__\n"
 284    #OS_DEFINES="${OS_DEFINES}#define _POSIX_C_SOURCE 200112L\n"
 285
 286    [ -n "${cksum}" ] || cksum=/opt/csw/gnu/cksum
 287    if [ -x "${cksum}" ]; then :; else
 288       msg 'ERROR: Not an executable program: %s' "${cksum}"
 289       msg 'ERROR:   We need a CRC-32 cksum(1), as specified in POSIX.'
 290       msg 'ERROR:   However, we do so only for tests.'
 291       msg 'ERROR:   If that is ok, set "cksum=/usr/bin/true", then rerun'
 292       config_exit 1
 293    fi
 294
 295    if feat_yes AUTOCC; then
 296       if command -v cc >/dev/null 2>&1; then
 297          CC=cc
 298          feat_yes DEBUG && _CFLAGS="-v -Xa -g" || _CFLAGS="-Xa -O"
 299
 300          CFLAGS="${_CFLAGS} ${EXTRA_CFLAGS}"
 301          LDFLAGS="${_LDFLAGS} ${EXTRA_LDFLAGS}"
 302          export CC CFLAGS LDFLAGS
 303          OPT_AUTOCC=0 had_want_autocc=1 need_R_ldflags=-R
 304       else
 305          # Assume gcc(1), which supports -R for compat
 306          cc_maxopt=2 force_no_stackprot=1 need_R_ldflags=-Wl,-R
 307       fi
 308    fi
 309 }
 310
 311 # Check out compiler ($CC) and -flags ($CFLAGS)
 312 cc_setup() {
 313    # Even though it belongs into cc_flags we will try to compile and link
 314    # something, so ensure we have a clean state regarding CFLAGS/LDFLAGS or
 315    # EXTRA_CFLAGS/EXTRA_LDFLAGS
 316    if feat_no AUTOCC; then
 317       _cc_default
 318       # Ensure those don't do any harm
 319       EXTRA_CFLAGS= EXTRA_LDFLAGS=
 320       export EXTRA_CFLAGS EXTRA_LDFLAGS
 321       return
 322    else
 323       CFLAGS= LDFLAGS=
 324       export CFLAGS LDFLAGS
 325    fi
 326
 327    [ -n "${CC}" ] && [ "${CC}" != cc ] && { _cc_default; return; }
 328
 329    msg_nonl 'Searching for a usable C compiler .. $CC='
 330    if { i="`command -v clang`"; }; then
 331       CC=${i}
 332    elif { i="`command -v gcc`"; }; then
 333       CC=${i}
 334    elif { i="`command -v c99`"; }; then
 335       CC=${i}
 336    elif { i="`command -v tcc`"; }; then
 337       CC=${i}
 338    elif { i="`command -v pcc`"; }; then
 339       CC=${i}
 340    else
 341       if [ "${CC}" = cc ]; then
 342          :
 343       elif { i="`command -v c89`"; }; then
 344          CC=${i}
 345       else
 346          msg 'boing booom tschak'
 347          msg 'ERROR: I cannot find a compiler!'
 348          msg ' Neither of clang(1), gcc(1), tcc(1), pcc(1), c89(1) and c99(1).'
 349          msg ' Please set ${CC} environment variable, maybe ${CFLAGS}, rerun.'
 350          config_exit 1
 351       fi
 352    fi
 353    msg '%s' "${CC}"
 354    export CC
 355 }
 356
 357 _cc_default() {
 358    if [ -z "${CC}" ]; then
 359       msg 'To go on like you have chosen, please set $CC, rerun.'
 360       config_exit 1
 361    fi
 362
 363    if [ -z "${VERBOSE}" ] && [ -f ${lst} ] && feat_no DEBUG; then
 364       :
 365    else
 366       msg 'Using C compiler ${CC}=%s' "${CC}"
 367    fi
 368 }
 369
 370 cc_flags() {
 371    if feat_yes AUTOCC; then
 372       if [ -f ${lst} ] && feat_no DEBUG && [ -z "${VERBOSE}" ]; then
 373          cc_check_silent=1
 374          msg 'Detecting ${CFLAGS}/${LDFLAGS} for ${CC}=%s, just a second..' \
 375             "${CC}"
 376       else
 377          cc_check_silent=
 378          msg 'Testing usable ${CFLAGS}/${LDFLAGS} for ${CC}=%s' "${CC}"
 379       fi
 380
 381       i=`echo "${CC}" | ${awk} 'BEGIN{FS="/"}{print $NF}'`
 382       if { echo "${i}" | ${grep} tcc; } >/dev/null 2>&1; then
 383          msg ' . have special tcc(1) environmental rules ...'
 384          _cc_flags_tcc
 385       else
 386          # As of pcc CVS 2016-04-02, stack protection support is announced but
 387          # will break if used on Linux
 388          if { echo "${i}" | ${grep} pcc; } >/dev/null 2>&1; then
 389             force_no_stackprot=1
 390          fi
 391          _cc_flags_generic
 392       fi
 393
 394       feat_no DEBUG && _CFLAGS="-DNDEBUG ${_CFLAGS}"
 395       CFLAGS="${_CFLAGS} ${EXTRA_CFLAGS}"
 396       LDFLAGS="${_LDFLAGS} ${EXTRA_LDFLAGS}"
 397    else
 398       if feat_no DEBUG; then
 399          CFLAGS="-DNDEBUG ${CFLAGS}"
 400       fi
 401    fi
 402    msg ''
 403    export CFLAGS LDFLAGS
 404 }
 405
 406 _cc_flags_tcc() {
 407    __cflags=${_CFLAGS} __ldflags=${_LDFLAGS}
 408    _CFLAGS= _LDFLAGS=
 409
 410    cc_check -Wall
 411    cc_check -Wextra
 412    cc_check -pedantic
 413
 414    if feat_yes DEBUG; then
 415       # May have problems to find libtcc cc_check -b
 416       cc_check -g
 417    fi
 418
 419    if ld_check -Wl,-rpath =./ no; then
 420       need_R_ldflags=-Wl,-rpath=
 421       ld_check -Wl,--enable-new-dtags
 422       ld_runtime_flags # update!
 423    fi
 424
 425    _CFLAGS="${_CFLAGS} ${__cflags}" _LDFLAGS="${_LDFLAGS} ${__ldflags}"
 426    unset __cflags __ldflags
 427 }
 428
 429 _cc_flags_generic() {
 430    __cflags=${_CFLAGS} __ldflags=${_LDFLAGS}
 431    _CFLAGS= _LDFLAGS=
 432    feat_yes DEVEL && cc_check -std=c89 || cc_check -std=c99
 433
 434    # Check -g first since some others may rely upon -g / optim. level
 435    if feat_yes DEBUG; then
 436       cc_check -O
 437       cc_check -g
 438    elif [ ${cc_maxopt} -gt 2 ] && cc_check -O3; then
 439       :
 440    elif [ ${cc_maxopt} -gt 1 ] && cc_check -O2; then
 441       :
 442    elif [ ${cc_maxopt} -gt 0 ] && cc_check -O1; then
 443       :
 444    else
 445       cc_check -O
 446    fi
 447
 448    #if feat_yes DEVEL && cc_check -Weverything; then
 449    #   :
 450    #else
 451       cc_check -Wall
 452       cc_check -Wextra
 453       cc_check -Wbad-function-cast
 454       cc_check -Wcast-align
 455       cc_check -Wcast-qual
 456       cc_check -Winit-self
 457       cc_check -Wmissing-prototypes
 458       cc_check -Wshadow
 459       cc_check -Wunused
 460       cc_check -Wwrite-strings
 461       cc_check -Wno-long-long
 462    #fi
 463    cc_check -pedantic
 464
 465    if feat_yes AMALGAMATION && feat_no DEVEL; then
 466       cc_check -Wno-unused-function
 467    fi
 468    feat_no DEVEL && cc_check -Wno-unused-result # XXX do right way (pragma too)
 469
 470    cc_check -fno-unwind-tables
 471    cc_check -fno-asynchronous-unwind-tables
 472    cc_check -fstrict-aliasing
 473    if cc_check -fstrict-overflow && feat_yes DEVEL; then
 474       cc_check -Wstrict-overflow=5
 475    fi
 476
 477    if feat_yes DEBUG || feat_yes FORCED_STACKPROT; then
 478       if [ -z "${force_no_stackprot}" ]; then
 479          if cc_check -fstack-protector-strong ||
 480                cc_check -fstack-protector-all; then
 481             cc_check -D_FORTIFY_SOURCE=2
 482          fi
 483       else
 484          msg 'Not checking for -fstack-protector compiler option,'
 485          msg 'since that caused errors in a "similar" configuration.'
 486          msg 'You may turn off OPT_AUTOCC and use your own settings, rerun'
 487       fi
 488    fi
 489
 490    if feat_yes AMALGAMATION; then
 491       cc_check -pipe
 492    fi
 493
 494    # LD (+ dependend CC)
 495
 496    if feat_yes DEVEL; then
 497       _ccfg=${_CFLAGS}
 498       # -fsanitize=address
 499       #if cc_check -fsanitize=memory &&
 500       #      ld_check -fsanitize=memory &&
 501       #      cc_check -fsanitize-memory-track-origins=2 &&
 502       #      ld_check -fsanitize-memory-track-origins=2; then
 503       #   :
 504       #else
 505       #   _CFLAGS=${_ccfg}
 506       #fi
 507    fi
 508
 509    ld_check -Wl,-z,relro
 510    ld_check -Wl,-z,now
 511    ld_check -Wl,-z,noexecstack
 512    if ld_check -Wl,-rpath =./ no; then
 513       need_R_ldflags=-Wl,-rpath=
 514       # Choose DT_RUNPATH (after $LD_LIBRARY_PATH) over DT_RPATH (before)
 515       ld_check -Wl,--enable-new-dtags
 516       ld_runtime_flags # update!
 517    elif ld_check -Wl,-R ./ no; then
 518       need_R_ldflags=-Wl,-R
 519       ld_check -Wl,--enable-new-dtags
 520       ld_runtime_flags # update!
 521    fi
 522
 523    # Address randomization
 524    _ccfg=${_CFLAGS}
 525    if cc_check -fPIE || cc_check -fpie; then
 526       ld_check -pie || _CFLAGS=${_ccfg}
 527    fi
 528    unset _ccfg
 529
 530    _CFLAGS="${_CFLAGS} ${__cflags}" _LDFLAGS="${_LDFLAGS} ${__ldflags}"
 531    unset __cflags __ldflags
 532 }
 533
 534 ##  --  >8  - <<OS/CC | SUPPORT FUNS>> -  8<  --  ##
 535
 536 ## Notes:
 537 ## - Heirloom sh(1) (and same origin) have _sometimes_ problems with ': >'
 538 ##   redirection, so use "printf '' >" instead
 539
 540 ## Very first: we undergo several states regarding I/O redirection etc.,
 541 ## but need to deal with option updates from within all.  Since all the
 542 ## option stuff should be above the scissor line, define utility functions
 543 ## and redefine them as necessary.
 544 ## And, since we have those functions, simply use them for whatever
 545
 546 config_exit() {
 547    exit ${1}
 548 }
 549
 550 msg() {
 551    fmt=${1}
 552    shift
 553    printf >&2 -- "${fmt}\\n" "${@}"
 554 }
 555
 556 msg_nonl() {
 557    fmt=${1}
 558    shift
 559    printf >&2 -- "${fmt}" "${@}"
 560 }
 561
 562 t1=ten10one1ten10one1
 563 if ( [ ${t1##*ten10} = one1 ] && [ ${t1#*ten10} = one1ten10one1 ] &&
 564       [ ${t1%%one1*} = ten10 ] && [ ${t1%one1*} = ten10one1ten10 ]
 565       ) > /dev/null 2>&1; then
 566    good_shell=1
 567 else
 568    unset good_shell
 569 fi
 570 unset t1
 571
 572 # We need some standard utilities
 573 unset -f command
 574 check_tool() {
 575    n=${1} i=${2} opt=${3:-0}
 576    # Evaluate, just in case user comes in with shell snippets (..well..)
 577    eval i="${i}"
 578    if type "${i}" >/dev/null 2>&1; then # XXX why have i type not command -v?
 579       [ -n "${VERBOSE}" ] && msg ' . ${%s} ... %s' "${n}" "${i}"
 580       eval ${n}=${i}
 581       return 0
 582    fi
 583    if [ ${opt} -eq 0 ]; then
 584       msg 'ERROR: no trace of utility %s' "${n}"
 585       config_exit 1
 586    fi
 587    return 1
 588 }
 589
 590 # Our feature check environment
 591 feat_val_no() {
 592    [ "x${1}" = x0 ] || [ "x${1}" = xn ] ||
 593    [ "x${1}" = xfalse ] || [ "x${1}" = xno ] || [ "x${1}" = xoff ]
 594 }
 595
 596 feat_val_yes() {
 597    [ "x${1}" = x1 ] || [ "x${1}" = xy ] ||
 598    [ "x${1}" = xtrue ] || [ "x${1}" = xyes ] || [ "x${1}" = xon ] ||
 599          [ "x${1}" = xrequire ]
 600 }
 601
 602 feat_val_require() {
 603    [ "x${1}" = xrequire ]
 604 }
 605
 606 _feat_check() {
 607    eval i=\$OPT_${1}
 608    i="`echo ${i} | ${tr} '[A-Z]' '[a-z]'`"
 609    if feat_val_no "${i}"; then
 610       return 1
 611    elif feat_val_yes "${i}"; then
 612       return 0
 613    else
 614       msg "ERROR: %s: 0/n/false/no/off or 1/y/true/yes/on/require, got: %s" \
 615          "${1}" "${i}"
 616       config_exit 11
 617    fi
 618 }
 619
 620 feat_yes() {
 621    _feat_check ${1}
 622 }
 623
 624 feat_no() {
 625    _feat_check ${1} && return 1
 626    return 0
 627 }
 628
 629 feat_require() {
 630    eval i=\$OPT_${1}
 631    i="`echo ${i} | ${tr} '[A-Z]' '[a-z]'`"
 632    [ "x${i}" = xrequire ] || [ "x${i}" = xrequired ]
 633 }
 634
 635 feat_bail_required() {
 636    if feat_require ${1}; then
 637       msg 'ERROR: feature OPT_%s is required but not available' "${1}"
 638       config_exit 13
 639    fi
 640    eval OPT_${1}=0
 641    option_update # XXX this is rather useless here (dependency chain..)
 642 }
 643
 644 option_parse() {
 645    # Parse one of our XOPTIONS* in $2 and assign the sh(1) compatible list of
 646    # options, without documentation, to $1
 647    j=\'
 648    i="`${awk} -v input=\"${2}\" '
 649       BEGIN{
 650          for(i = 0;;){
 651             voff = match(input, /[[:alnum:]_]+(='${j}'[^'${j}']+)?/)
 652             if(voff == 0)
 653                break
 654             v = substr(input, voff, RLENGTH)
 655             input = substr(input, voff + RLENGTH)
 656             doff = index(v, "=")
 657             if(doff > 0){
 658                d = substr(v, doff + 2, length(v) - doff - 1)
 659                v = substr(v, 1, doff - 1)
 660             }
 661             print v
 662          }
 663       }
 664       '`"
 665    eval ${1}=\"${i}\"
 666 }
 667
 668 option_doc_of() {
 669    # Return the "documentation string" for option $1, itself if none such
 670    j=\'
 671    ${awk} -v want="${1}" \
 672       -v input="${XOPTIONS_DETECT}${XOPTIONS}${XOPTIONS_XTRA}" '
 673    BEGIN{
 674       for(;;){
 675          voff = match(input, /[[:alnum:]_]+(='${j}'[^'${j}']+)?/)
 676          if(voff == 0)
 677             break
 678          v = substr(input, voff, RLENGTH)
 679          input = substr(input, voff + RLENGTH)
 680          doff = index(v, "=")
 681          if(doff > 0){
 682             d = substr(v, doff + 2, length(v) - doff - 1)
 683             v = substr(v, 1, doff - 1)
 684          }else
 685             d = v
 686          if(v == want){
 687             if(d != "-")
 688                print d
 689             exit
 690          }
 691       }
 692    }
 693    '
 694 }
 695
 696 option_join_rc() {
 697    # Join the values from make.rc into what currently is defined, not
 698    # overwriting yet existing settings
 699    ${rm} -f ${tmp}
 700    # We want read(1) to perform reverse solidus escaping in order to be able to
 701    # use multiline values in make.rc; the resulting sh(1)/sed(1) code was very
 702    # slow in VMs (see [fa2e248]), Aharon Robbins suggested the following
 703    < ${rc} ${awk} 'BEGIN{line = ""}{
 704       gsub(/^[[:space:]]+/, "", $0)
 705       gsub(/[[:space:]]+$/, "", $0)
 706       if(gsub(/\\$/, "", $0)){
 707          line = line $0
 708          next
 709       }else
 710          line = line $0
 711       if(index(line, "#") == 1){
 712          line = ""
 713       }else if(length(line)){
 714          print line
 715          line = ""
 716       }
 717    }' |
 718    while read line; do
 719       if [ -n "${good_shell}" ]; then
 720          i=${line%%=*}
 721       else
 722          i=`${awk} -v LINE="${line}" 'BEGIN{
 723             gsub(/=.*$/, "", LINE)
 724             print LINE
 725          }'`
 726       fi
 727       if [ "${i}" = "${line}" ]; then
 728          msg 'ERROR: invalid syntax in: %s' "${line}"
 729          continue
 730       fi
 731
 732       eval j="\$${i}" jx="\${${i}+x}"
 733       if [ -n "${j}" ] || [ "${jx}" = x ]; then
 734          : # Yet present
 735       else
 736          j=`${awk} -v LINE="${line}" 'BEGIN{
 737             gsub(/^[^=]*=/, "", LINE)
 738             gsub(/^\"*/, "", LINE)
 739             gsub(/\"*$/, "", LINE)
 740             print LINE
 741          }'`
 742       fi
 743       [ "${i}" = "DESTDIR" ] && continue
 744       echo "${i}=\"${j}\""
 745    done > ${tmp}
 746    # Reread the mixed version right now
 747    . ./${tmp}
 748 }
 749
 750 option_evaluate() {
 751    # Expand the option values, which may contain shell snippets
 752    ${rm} -f ${newlst} ${newmk} ${newh}
 753    exec 5<&0 6>&1 <${tmp} >${newlst}
 754    while read line; do
 755       z=
 756       if [ -n "${good_shell}" ]; then
 757          i=${line%%=*}
 758          [ "${i}" != "${i#OPT_}" ] && z=1
 759       else
 760          i=`${awk} -v LINE="${line}" 'BEGIN{
 761             gsub(/=.*$/, "", LINE);\
 762             print LINE
 763          }'`
 764          if echo "${i}" | ${grep} '^OPT_' >/dev/null 2>&1; then
 765             z=1
 766          fi
 767       fi
 768
 769       eval j=\$${i}
 770       if [ -n "${z}" ]; then
 771          j="`echo ${j} | ${tr} '[A-Z]' '[a-z]'`"
 772          if [ -z "${j}" ] || feat_val_no "${j}"; then
 773             j=0
 774             printf "   /* #undef ${i} */\n" >> ${newh}
 775          elif feat_val_yes "${j}"; then
 776             if feat_val_require "${j}"; then
 777                j=require
 778             else
 779                j=1
 780             fi
 781             printf "   /* #define ${i} */\n" >> ${newh}
 782          else
 783             msg 'ERROR: cannot parse <%s>' "${line}"
 784             config_exit 1
 785          fi
 786       else
 787          printf "#define ${i} \"${j}\"\n" >> ${newh}
 788       fi
 789       printf "${i} = ${j}\n" >> ${newmk}
 790       printf "${i}=${j}\n"
 791       eval "${i}=\"${j}\""
 792    done
 793    exec 0<&5 1>&6 5<&- 6<&-
 794 }
 795
 796 path_check() {
 797    # "path_check VARNAME" or "path_check VARNAME FLAG VARNAME"
 798    varname=${1} addflag=${2} flagvarname=${3}
 799    j=${IFS}
 800    IFS=:
 801    eval "set -- \$${1}"
 802    IFS=${j}
 803    j= k= y= z=
 804    for i
 805    do
 806       [ -z "${i}" ] && continue
 807       [ -d "${i}" ] || continue
 808       # Skip any fakeroot packager environment
 809       case "${i}" in *fakeroot*) continue;; esac
 810       if [ -n "${j}" ]; then
 811          if { z=${y}; echo "${z}"; } | ${grep} ":${i}:" >/dev/null 2>&1; then
 812             :
 813          else
 814             y="${y} :${i}:"
 815             j="${j}:${i}"
 816             [ -n "${addflag}" ] && k="${k} ${addflag}${i}"
 817          fi
 818       else
 819          y=" :${i}:"
 820          j="${i}"
 821          [ -n "${addflag}" ] && k="${addflag}${i}"
 822       fi
 823    done
 824    eval "${varname}=\"${j}\""
 825    [ -n "${addflag}" ] && eval "${flagvarname}=\"${k}\""
 826    unset varname
 827 }
 828
 829 ld_runtime_flags() {
 830    if [ -n "${need_R_ldflags}" ]; then
 831       i=${IFS}
 832       IFS=:
 833       set -- ${LD_LIBRARY_PATH}
 834       IFS=${i}
 835       for i
 836       do
 837          LDFLAGS="${LDFLAGS} ${need_R_ldflags}${i}"
 838          _LDFLAGS="${_LDFLAGS} ${need_R_ldflags}${i}"
 839       done
 840       export LDFLAGS
 841    fi
 842    # Disable it for a possible second run.
 843    need_R_ldflags=
 844 }
 845
 846 cc_check() {
 847    [ -n "${cc_check_silent}" ] || msg_nonl ' . CC %s .. ' "${1}"
 848    if "${CC}" ${INCS} \
 849          ${_CFLAGS} ${1} ${EXTRA_CFLAGS} ${_LDFLAGS} ${EXTRA_LDFLAGS} \
 850          -o ${tmp2} ${tmp}.c ${LIBS} >/dev/null 2>&1; then
 851       _CFLAGS="${_CFLAGS} ${1}"
 852       [ -n "${cc_check_silent}" ] || msg 'yes'
 853       return 0
 854    fi
 855    [ -n "${cc_check_silent}" ] || msg 'no'
 856    return 1
 857 }
 858
 859 ld_check() {
 860    # $1=option [$2=option argument] [$3=if set, shall NOT be added to _LDFLAGS]
 861    [ -n "${cc_check_silent}" ] || msg_nonl ' . LD %s .. ' "${1}"
 862    if "${CC}" ${INCS} ${_CFLAGS} ${_LDFLAGS} ${1}${2} ${EXTRA_LDFLAGS} \
 863          -o ${tmp2} ${tmp}.c ${LIBS} >/dev/null 2>&1; then
 864       [ -n "${3}" ] || _LDFLAGS="${_LDFLAGS} ${1}"
 865       [ -n "${cc_check_silent}" ] || msg 'yes'
 866       return 0
 867    fi
 868    [ -n "${cc_check_silent}" ] || msg 'no'
 869    return 1
 870 }
 871
 872 _check_preface() {
 873    variable=$1 topic=$2 define=$3
 874
 875    echo '**********'
 876    msg_nonl ' . %s ... ' "${topic}"
 877    echo "/* checked ${topic} */" >> ${h}
 878    ${rm} -f ${tmp} ${tmp}.o
 879    echo '*** test program is'
 880    { echo '#include <'"${h_name}"'>'; cat; } | ${tee} ${tmp}.c
 881    #echo '*** the preprocessor generates'
 882    #${make} -f ${makefile} ${tmp}.x
 883    #${cat} ${tmp}.x
 884    echo '*** results are'
 885 }
 886
 887 without_check() {
 888    yesno=$1 variable=$2 topic=$3 define=$4 libs=$5 incs=$6
 889
 890    echo '**********'
 891    msg_nonl ' . %s ... ' "${topic}"
 892
 893    echo '*** enforced unchecked results are'
 894    if feat_val_yes ${yesno}; then
 895       if [ -n "${incs}" ] || [ -n "${libs}" ]; then
 896          echo "*** adding INCS<${incs}> LIBS<${libs}>"
 897          LIBS="${LIBS} ${libs}"
 898          echo "${libs}" >> ${lib}
 899          INCS="${INCS} ${incs}"
 900          echo "${incs}" >> ${inc}
 901       fi
 902       msg 'yes (deduced)'
 903       echo "${define}" >> ${h}
 904       eval have_${variable}=yes
 905       return 0
 906    else
 907       echo "/* ${define} */" >> ${h}
 908       msg 'no (deduced)'
 909       eval unset have_${variable}
 910       return 1
 911    fi
 912 }
 913
 914 compile_check() {
 915    variable=$1 topic=$2 define=$3
 916
 917    _check_preface "${variable}" "${topic}" "${define}"
 918
 919    if ${make} -f ${makefile} XINCS="${INCS}" \
 920             CFLAGS="${CFLAGS}" LDFLAGS="${LDFLAGS}" \
 921             ./${tmp}.o &&
 922          [ -f ./${tmp}.o ]; then
 923       msg 'yes'
 924       echo "${define}" >> ${h}
 925       eval have_${variable}=yes
 926       return 0
 927    else
 928       echo "/* ${define} */" >> ${h}
 929       msg 'no'
 930       eval unset have_${variable}
 931       return 1
 932    fi
 933 }
 934
 935 _link_mayrun() {
 936    run=$1 variable=$2 topic=$3 define=$4 libs=$5 incs=$6
 937
 938    _check_preface "${variable}" "${topic}" "${define}"
 939
 940    if feat_yes CROSS_BUILD; then
 941       if [ ${run} = 1 ]; then
 942          run=0
 943       fi
 944    fi
 945
 946    if ${make} -f ${makefile} XINCS="${INCS} ${incs}" \
 947             CFLAGS="${CFLAGS}" LDFLAGS="${LDFLAGS}" \
 948             XLIBS="${LIBS} ${libs}" \
 949             ./${tmp} &&
 950          [ -f ./${tmp} ] &&
 951          { [ ${run} -eq 0 ] || ./${tmp}; }; then
 952       echo "*** adding INCS<${incs}> LIBS<${libs}>; executed: ${run}"
 953       msg 'yes'
 954       echo "${define}" >> ${h}
 955       LIBS="${LIBS} ${libs}"
 956       echo "${libs}" >> ${lib}
 957       INCS="${INCS} ${incs}"
 958       echo "${incs}" >> ${inc}
 959       eval have_${variable}=yes
 960       return 0
 961    else
 962       msg 'no'
 963       echo "/* ${define} */" >> ${h}
 964       eval unset have_${variable}
 965       return 1
 966    fi
 967 }
 968
 969 link_check() {
 970    _link_mayrun 0 "${1}" "${2}" "${3}" "${4}" "${5}"
 971 }
 972
 973 run_check() {
 974    _link_mayrun 1 "${1}" "${2}" "${3}" "${4}" "${5}"
 975 }
 976
 977 xrun_check() {
 978    _link_mayrun 2 "${1}" "${2}" "${3}" "${4}" "${5}"
 979 }
 980
 981 feat_def() {
 982    if feat_yes ${1}; then
 983       echo '#define HAVE_'${1}'' >> ${h}
 984       return 0
 985    else
 986       echo '/* OPT_'${1}'=0 */' >> ${h}
 987       return 1
 988    fi
 989 }
 990
 991 squeeze_em() {
 992    < "${1}" > "${2}" ${awk} \
 993    'BEGIN {ORS = " "} /^[^#]/ {print} {next} END {ORS = ""; print "\n"}'
 994 }
 995
 996 ##  --  >8  - <<SUPPORT FUNS | RUNNING>> -  8<  --  ##
 997
 998 # First of all, create new configuration and check whether it changed
 999
1000 # Very easy checks for the operating system in order to be able to adjust paths
1001 # or similar very basic things which we need to be able to go at all
1002 os_early_setup
1003
1004 # Check those tools right now that we need before including $rc
1005 msg 'Checking for basic utility set'
1006 check_tool awk "${awk:-`command -v awk`}"
1007 check_tool rm "${rm:-`command -v rm`}"
1008 check_tool tr "${tr:-`command -v tr`}"
1009
1010 # Initialize the option set
1011 msg_nonl 'Setting up configuration options ... '
1012 option_setup
1013 msg 'done'
1014
1015 # Include $rc, but only take from it what wasn't overwritten by the user from
1016 # within the command line or from a chosen fixed CONFIG=
1017 # Note we leave alone the values
1018 trap "exit 1" HUP INT TERM
1019 trap "${rm} -f ${tmp}" EXIT
1020
1021 msg_nonl 'Joining in %s ... ' ${rc}
1022 option_join_rc
1023 msg 'done'
1024
1025 # We need to know about that now, in order to provide utility overwrites etc.
1026 os_setup
1027
1028 msg 'Checking for remaining set of utilities'
1029 check_tool grep "${grep:-`command -v grep`}"
1030
1031 # Before we step ahead with the other utilities perform a path cleanup first.
1032 path_check PATH
1033
1034 # awk(1) above
1035 check_tool cat "${cat:-`command -v cat`}"
1036 check_tool chmod "${chmod:-`command -v chmod`}"
1037 check_tool cp "${cp:-`command -v cp`}"
1038 check_tool cmp "${cmp:-`command -v cmp`}"
1039 # grep(1) above
1040 check_tool mkdir "${mkdir:-`command -v mkdir`}"
1041 check_tool mv "${mv:-`command -v mv`}"
1042 # rm(1) above
1043 check_tool sed "${sed:-`command -v sed`}"
1044 check_tool sort "${sort:-`command -v sort`}"
1045 check_tool tee "${tee:-`command -v tee`}"
1046
1047 check_tool chown "${chown:-`command -v chown`}" 1 ||
1048    check_tool chown "/sbin/chown" 1 ||
1049    check_tool chown "/usr/sbin/chown"
1050
1051 check_tool make "${MAKE:-`command -v make`}"
1052 MAKE=${make}
1053 check_tool strip "${STRIP:-`command -v strip`}" 1 &&
1054    HAVE_STRIP=1 || HAVE_STRIP=0
1055
1056 # For ./cc-test.sh only
1057 check_tool cksum "${cksum:-`command -v cksum`}"
1058
1059 # Update OPT_ options now, in order to get possible inter-dependencies right
1060 option_update
1061
1062 # (No functions since some shells loose non-exported variables in traps)
1063 trap "trap \"\" HUP INT TERM; exit 1" HUP INT TERM
1064 trap "trap \"\" HUP INT TERM EXIT;\
1065    ${rm} -rf ${newlst} ${tmp0}.* ${tmp0}* ${newmk} ${newev} ${newh}" EXIT
1066
1067 # Our configuration options may at this point still contain shell snippets,
1068 # we need to evaluate them in order to get them expanded, and we need those
1069 # evaluated values not only in our new configuration file, but also at hand..
1070 msg_nonl 'Evaluating all configuration items ... '
1071 option_evaluate
1072 msg 'done'
1073
1074 # Add the known utility and some other variables
1075 printf "#define VAL_UAGENT \"${VAL_SID}${VAL_NAIL}\"\n" >> ${newh}
1076 printf "VAL_UAGENT = ${VAL_SID}${VAL_NAIL}\n" >> ${newmk}
1077
1078 printf "#define VAL_PRIVSEP \"${VAL_SID}${VAL_NAIL}-privsep\"\n" >> ${newh}
1079 printf "VAL_PRIVSEP = \$(VAL_UAGENT)-privsep\n" >> ${newmk}
1080 if feat_yes DOTLOCK; then
1081    printf "OPTIONAL_PRIVSEP = \$(VAL_PRIVSEP)\n" >> ${newmk}
1082 else
1083    printf "OPTIONAL_PRIVSEP =\n" >> ${newmk}
1084 fi
1085
1086 for i in \
1087       awk cat chmod chown cp cmp grep mkdir mv rm sed sort tee tr \
1088       MAKE MAKEFLAGS make SHELL strip \
1089       cksum; do
1090    eval j=\$${i}
1091    printf "${i} = ${j}\n" >> ${newmk}
1092    printf "${i}=${j}\n" >> ${newlst}
1093    printf "${i}=\"${j}\";export ${i}; " >> ${newev}
1094 done
1095 printf "\n" >> ${newev}
1096
1097 # Build a basic set of INCS and LIBS according to user environment.
1098 path_check C_INCLUDE_PATH -I _INCS
1099 INCS="${INCS} ${_INCS}"
1100 path_check LD_LIBRARY_PATH -L _LIBS
1101 LIBS="${LIBS} ${_LIBS}"
1102 unset _INCS _LIBS
1103 export C_INCLUDE_PATH LD_LIBRARY_PATH
1104
1105 # Some environments need runtime path flags to be able to go at all
1106 ld_runtime_flags
1107
1108 ## Detect CC, whether we can use it, and possibly which CFLAGS we can use
1109
1110 cc_setup
1111
1112 ${cat} > ${tmp}.c << \!
1113 #include <stdio.h>
1114 #include <string.h>
1115 static void doit(char const *s);
1116 int
1117 main(int argc, char **argv){
1118    (void)argc;
1119    (void)argv;
1120    doit("Hello world");
1121    return 0;
1122 }
1123 static void
1124 doit(char const *s){
1125    char buf[12];
1126    memcpy(buf, s, strlen(s) +1);
1127    puts(s);
1128 }
1129 !
1130
1131 if "${CC}" ${INCS} ${CFLAGS} ${EXTRA_CFLAGS} ${LDFLAGS} ${EXTRA_LDFLAGS} \
1132       -o ${tmp2} ${tmp}.c ${LIBS}; then
1133    :
1134 else
1135    msg 'ERROR: i cannot compile a "Hello world" via'
1136    msg '   %s' \
1137    "${CC} ${INCS} ${CFLAGS} ${EXTRA_CFLAGS} ${LDFLAGS} ${EXTRA_LDFLAGS} ${LIBS}"
1138    msg 'ERROR:   Please read INSTALL, rerun'
1139    config_exit 1
1140 fi
1141
1142 # This may also update ld_runtime_flags() (again)
1143 cc_flags
1144
1145 for i in \
1146       INCS LIBS \
1147       ; do
1148    eval j=\$${i}
1149    printf -- "${i}=${j}\n" >> ${newlst}
1150 done
1151 for i in \
1152       CC \
1153       CFLAGS \
1154       LDFLAGS \
1155       PATH C_INCLUDE_PATH LD_LIBRARY_PATH \
1156       OSFULLSPEC \
1157       ; do
1158    eval j=\$${i}
1159    printf -- "${i} = ${j}\n" >> ${newmk}
1160    printf -- "${i}=${j}\n" >> ${newlst}
1161 done
1162
1163 # Now finally check whether we already have a configuration and if so, whether
1164 # all those parameters are still the same.. or something has actually changed
1165 if [ -f ${lst} ] && ${cmp} ${newlst} ${lst} >/dev/null 2>&1; then
1166    echo 'Configuration is up-to-date'
1167    exit 0
1168 elif [ -f ${lst} ]; then
1169    echo 'Configuration has been updated..'
1170    ( eval "${MAKE} -f ./mk.mk clean" )
1171    echo
1172 else
1173    echo 'Shiny configuration..'
1174 fi
1175
1176 # Time to redefine helper 1
1177 config_exit() {
1178    ${rm} -f ${lst} ${h} ${mk}
1179    exit ${1}
1180 }
1181
1182 ${mv} -f ${newlst} ${lst}
1183 ${mv} -f ${newev} ${ev}
1184 ${mv} -f ${newh} ${h}
1185 ${mv} -f ${newmk} ${mk}
1186
1187 if [ -z "${VERBOSE}" ]; then
1188    printf -- "ECHO_CC = @echo '  'CC \$(@);\n" >> ${mk}
1189    printf -- "ECHO_LINK = @echo '  'LINK \$(@);\n" >> ${mk}
1190    printf -- "ECHO_GEN = @echo '  'GEN \$(@);\n" >> ${mk}
1191    printf -- "ECHO_TEST = @\n" >> ${mk}
1192    printf -- "ECHO_CMD = @echo '  CMD';\n" >> ${mk}
1193    printf -- "ECHO_BLOCK_BEGIN = @( \n" >> ${mk}
1194    printf -- "ECHO_BLOCK_END = ) >/dev/null\n" >> ${mk}
1195 fi
1196
1197 ## Compile and link checking
1198
1199 tmp3=./${tmp0}3$$
1200 log=./config.log
1201 lib=./config.lib
1202 inc=./config.inc
1203 makefile=./config.mk
1204
1205 # (No function since some shells loose non-exported variables in traps)
1206 trap "trap \"\" HUP INT TERM;\
1207    ${rm} -f ${lst} ${h} ${mk} ${lib} ${inc}; exit 1" HUP INT TERM
1208 trap "trap \"\" HUP INT TERM EXIT;\
1209    ${rm} -rf ${tmp0}.* ${tmp0}* ${makefile}" EXIT
1210
1211 # Time to redefine helper 2
1212 msg() {
1213    fmt=${1}
1214    shift
1215    printf "*** ${fmt}\\n" "${@}"
1216    printf -- "${fmt}\\n" "${@}" >&5
1217 }
1218 msg_nonl() {
1219    fmt=${1}
1220    shift
1221    printf "*** ${fmt}\\n" "${@}"
1222    printf -- "${fmt}" "${@}" >&5
1223 }
1224
1225 # !!
1226 exec 5>&2 > ${log} 2>&1
1227
1228 echo "${LIBS}" > ${lib}
1229 echo "${INCS}" > ${inc}
1230 ${cat} > ${makefile} << \!
1231 .SUFFIXES: .o .c .x .y
1232 .c.o:
1233         $(CC) -I./ $(XINCS) $(CFLAGS) -c $(<)
1234 .c.x:
1235         $(CC) -I./ $(XINCS) -E $(<) > $(@)
1236 .c:
1237         $(CC) -I./ $(XINCS) $(CFLAGS) $(LDFLAGS) -o $(@) $(<) $(XLIBS)
1238 !
1239
1240 ## Generics
1241
1242 # May be multiline..
1243 [ -n "${OS_DEFINES}" ] && printf -- "${OS_DEFINES}" >> ${h}
1244
1245 feat_def ALWAYS_UNICODE_LOCALE
1246 feat_def AMALGAMATION
1247 feat_def CROSS_BUILD
1248 feat_def DEBUG
1249 feat_def DEVEL
1250 feat_def DOCSTRINGS
1251 feat_def ERRORS
1252 feat_def NYD2
1253 feat_def NOMEMDBG
1254
1255 if xrun_check inline 'inline functions' \
1256    '#define HAVE_INLINE
1257    #define n_INLINE static inline' << \!
1258 static inline int ilf(int i){return ++i;}
1259 int main(void){return ilf(-1);}
1260 !
1261 then
1262    :
1263 elif xrun_check inline 'inline functions (via __inline)' \
1264    '#define HAVE_INLINE
1265    #define n_INLINE static __inline' << \!
1266 static __inline int ilf(int i){return ++i;}
1267 int main(void){return ilf(-1);}
1268 !
1269 then
1270    :
1271 fi
1272
1273 ## Test for "basic" system-calls / functionality that is used by all parts
1274 ## of our program.  Once this is done fork away BASE_LIBS and other BASE_*
1275 ## macros to be used by only the subprograms (potentially).
1276
1277 if run_check clock_gettime 'clock_gettime(2)' \
1278    '#define HAVE_CLOCK_GETTIME' << \!
1279 #include <time.h>
1280 # include <errno.h>
1281 int main(void){
1282    struct timespec ts;
1283
1284    if(!clock_gettime(CLOCK_REALTIME, &ts) || errno != ENOSYS)
1285       return 0;
1286    return 1;
1287 }
1288 !
1289 then
1290    :
1291 elif run_check clock_gettime 'clock_gettime(2) (via -lrt)' \
1292    '#define HAVE_CLOCK_GETTIME' '-lrt' << \!
1293 #include <time.h>
1294 # include <errno.h>
1295 int main(void){
1296    struct timespec ts;
1297
1298    if(!clock_gettime(CLOCK_REALTIME, &ts) || errno != ENOSYS)
1299       return 0;
1300    return 1;
1301 }
1302 !
1303 then
1304    :
1305 elif run_check gettimeofday 'gettimeofday(2)' \
1306    '#define HAVE_GETTIMEOFDAY' << \!
1307 #include <stdio.h> /* For C89 NULL */
1308 #include <sys/time.h>
1309 # include <errno.h>
1310 int main(void){
1311    struct timeval tv;
1312
1313    if(!gettimeofday(&tv, NULL) || errno != ENOSYS)
1314       return 0;
1315    return 1;
1316 }
1317 !
1318 then
1319    :
1320 else
1321    have_no_subsecond_time=1
1322 fi
1323
1324 if run_check nanosleep 'nanosleep(2)' \
1325    '#define HAVE_NANOSLEEP' << \!
1326 #include <time.h>
1327 # include <errno.h>
1328 int main(void){
1329    struct timespec ts;
1330
1331    ts.tv_sec = 1;
1332    ts.tv_nsec = 100000;
1333    if(!nanosleep(&ts, NULL) || errno != ENOSYS)
1334       return 0;
1335    return 1;
1336 }
1337 !
1338 then
1339    :
1340 elif run_check nanosleep 'nanosleep(2) (via -lrt)' \
1341    '#define HAVE_NANOSLEEP' '-lrt' << \!
1342 #include <time.h>
1343 # include <errno.h>
1344 int main(void){
1345    struct timespec ts;
1346
1347    ts.tv_sec = 1;
1348    ts.tv_nsec = 100000;
1349    if(!nanosleep(&ts, NULL) || errno != ENOSYS)
1350       return 0;
1351    return 1;
1352 }
1353 !
1354 then
1355    :
1356 # link_check is enough for this, that function is so old, trust the proto
1357 elif link_check sleep 'sleep(3)' \
1358    '#define HAVE_SLEEP' << \!
1359 #include <unistd.h>
1360 # include <errno.h>
1361 int main(void){
1362    if(!sleep(1) || errno != ENOSYS)
1363       return 0;
1364    return 1;
1365 }
1366 !
1367 then
1368    :
1369 else
1370    msg 'ERROR: we require one of nanosleep(2) and sleep(3).'
1371    config_exit 1
1372 fi
1373
1374 if run_check userdb 'gete?[gu]id(2), getpwuid(3), getpwnam(3)' << \!
1375 #include <pwd.h>
1376 #include <unistd.h>
1377 # include <errno.h>
1378 int main(void){
1379    struct passwd *pw;
1380    gid_t gid;
1381    uid_t uid;
1382
1383    if((gid = getgid()) != 0)
1384       gid = getegid();
1385    if((uid = getuid()) != 0)
1386       uid = geteuid();
1387    if((pw = getpwuid(uid)) == NULL && errno == ENOSYS)
1388       return 1;
1389    if((pw = getpwnam("root")) == NULL && errno == ENOSYS)
1390       return 1;
1391    return 0;
1392 }
1393 !
1394 then
1395    :
1396 else
1397    msg 'ERROR: we require user and group info / database searches.'
1398    msg 'That much Unix we indulge ourselfs.'
1399    config_exit 1
1400 fi
1401
1402 if link_check ftruncate 'ftruncate(2)' \
1403    '#define HAVE_FTRUNCATE' << \!
1404 #include <unistd.h>
1405 #include <sys/types.h>
1406 int main(void){
1407    return (ftruncate(0, 0) != 0);
1408 }
1409 !
1410 then
1411    :
1412 else
1413    msg 'ERROR: we require the ftruncate(2) system call.'
1414    config_exit 1
1415 fi
1416
1417 if run_check sa_restart 'SA_RESTART (for sigaction(2))' << \!
1418 #include <signal.h>
1419 # include <errno.h>
1420 int main(void){
1421    struct sigaction nact, oact;
1422
1423    nact.sa_handler = SIG_DFL;
1424    sigemptyset(&nact.sa_mask);
1425    nact.sa_flags = SA_RESTART;
1426    return !(!sigaction(SIGCHLD, &nact, &oact) || errno != ENOSYS);
1427 }
1428 !
1429 then
1430    :
1431 else
1432    msg 'ERROR: we (yet) require the SA_RESTART flag for sigaction(2).'
1433    config_exit 1
1434 fi
1435
1436 if link_check snprintf 'snprintf(3)' << \!
1437 #include <stdio.h>
1438 int main(void){
1439    char b[20];
1440
1441    snprintf(b, sizeof b, "%s", "string");
1442    return 0;
1443 }
1444 !
1445 then
1446    :
1447 else
1448    msg 'ERROR: we require the snprintf(3) function.'
1449    config_exit 1
1450 fi
1451
1452 if link_check environ 'environ(3)' << \!
1453 #include <stdio.h> /* For C89 NULL */
1454 int main(void){
1455    extern char **environ;
1456
1457    return environ[0] == NULL;
1458 }
1459 !
1460 then
1461    :
1462 else
1463    msg 'ERROR: we require the environ(3) array for subprocess control.'
1464    config_exit 1
1465 fi
1466
1467 if link_check setenv '(un)?setenv(3)' '#define HAVE_SETENV' << \!
1468 #include <stdlib.h>
1469 int main(void){
1470    setenv("s-mailx", "i want to see it cute!", 1);
1471    unsetenv("s-mailx");
1472    return 0;
1473 }
1474 !
1475 then
1476    :
1477 elif link_check setenv 'putenv(3)' '#define HAVE_PUTENV' << \!
1478 #include <stdlib.h>
1479 int main(void){
1480    putenv("s-mailx=i want to see it cute!");
1481    return 0;
1482 }
1483 !
1484 then
1485    :
1486 else
1487    msg 'ERROR: we require either the setenv(3) or putenv(3) functions.'
1488    config_exit 1
1489 fi
1490
1491 if link_check termios 'termios.h and tc*(3) family' << \!
1492 #include <termios.h>
1493 int main(void){
1494    struct termios tios;
1495
1496    tcgetattr(0, &tios);
1497    tcsetattr(0, TCSANOW | TCSADRAIN | TCSAFLUSH, &tios);
1498    return 0;
1499 }
1500 !
1501 then
1502    :
1503 else
1504    msg 'ERROR: we require termios.h and the tc*() family of functions.'
1505    msg 'That much Unix we indulge ourselfs.'
1506    config_exit 1
1507 fi
1508
1509 ## optional stuff
1510
1511 if link_check vsnprintf 'vsnprintf(3)' << \!
1512 #include <stdarg.h>
1513 #include <stdio.h>
1514 static void dome(char *buf, size_t blen, ...){
1515    va_list ap;
1516
1517    va_start(ap, blen);
1518    vsnprintf(buf, blen, "%s", ap);
1519    va_end(ap);
1520 }
1521 int main(void){
1522    char b[20];
1523
1524    dome(b, sizeof b, "string");
1525    return 0;
1526 }
1527 !
1528 then
1529    :
1530 else
1531    feat_bail_required ERRORS
1532 fi
1533
1534 if [ "${have_vsnprintf}" = yes ]; then
1535    __va_copy() {
1536       link_check va_copy "va_copy(3) (as ${2})" \
1537          "#define HAVE_N_VA_COPY
1538 #define n_va_copy ${2}" <<_EOT
1539 #include <stdarg.h>
1540 #include <stdio.h>
1541 #if ${1}
1542 # if defined __va_copy && !defined va_copy
1543 #  define va_copy __va_copy
1544 # endif
1545 #endif
1546 static void dome2(char *buf, size_t blen, va_list src){
1547    va_list ap;
1548
1549    va_copy(ap, src);
1550    vsnprintf(buf, blen, "%s", ap);
1551    va_end(ap);
1552 }
1553 static void dome(char *buf, size_t blen, ...){
1554    va_list ap;
1555
1556    va_start(ap, blen);
1557    dome2(buf, blen, ap);
1558    va_end(ap);
1559 }
1560 int main(void){
1561    char b[20];
1562
1563    dome(b, sizeof b, "string");
1564    return 0;
1565 }
1566 _EOT
1567    }
1568    __va_copy 0 va_copy || __va_copy 1 __va_copy
1569 fi
1570
1571 run_check pathconf 'f?pathconf(2)' '#define HAVE_PATHCONF' << \!
1572 #include <unistd.h>
1573 #include <errno.h>
1574 int main(void){
1575    int rv = 0;
1576
1577    errno = 0;
1578    rv |= !(pathconf(".", _PC_NAME_MAX) >= 0 || errno == 0 || errno != ENOSYS);
1579    errno = 0;
1580    rv |= !(pathconf(".", _PC_PATH_MAX) >= 0 || errno == 0 || errno != ENOSYS);
1581
1582    /* Only link check */
1583    fpathconf(0, _PC_NAME_MAX);
1584
1585    return rv;
1586 }
1587 !
1588
1589 run_check pipe2 'pipe2(2)' '#define HAVE_PIPE2' << \!
1590 #include <fcntl.h>
1591 #include <unistd.h>
1592 # include <errno.h>
1593 int main(void){
1594    int fds[2];
1595
1596    if(!pipe2(fds, O_CLOEXEC) || errno != ENOSYS)
1597       return 0;
1598    return 1;
1599 }
1600 !
1601
1602 # We use this only then for now (need NOW+1)
1603 run_check utimensat 'utimensat(2)' '#define HAVE_UTIMENSAT' << \!
1604 #include <fcntl.h> /* For AT_* */
1605 #include <sys/stat.h>
1606 # include <errno.h>
1607 int main(void){
1608    struct timespec ts[2];
1609
1610    ts[0].tv_nsec = UTIME_NOW;
1611    ts[1].tv_nsec = UTIME_OMIT;
1612    if(!utimensat(AT_FDCWD, "", ts, 0) || errno != ENOSYS)
1613       return 0;
1614    return 1;
1615 }
1616 !
1617
1618 ##
1619
1620 # XXX Add POSIX check once standardized
1621 if link_check posix_random 'arc4random(3)' '#define HAVE_POSIX_RANDOM 0' << \!
1622 #include <stdlib.h>
1623 int main(void){
1624    arc4random();
1625    return 0;
1626 }
1627 !
1628 then
1629    :
1630 elif link_check getrandom 'getrandom(2) (in sys/random.h)' \
1631       '#define HAVE_GETRANDOM(B,S) getrandom(B, S, 0)
1632       #define HAVE_GETRANDOM_HEADER <sys/random.h>' <<\!
1633 #include <sys/random.h>
1634 int main(void){
1635    char buf[256];
1636    getrandom(buf, sizeof buf, 0);
1637    return 0;
1638 }
1639 !
1640 then
1641    :
1642 elif link_check getrandom 'getrandom(2) (via syscall(2))' \
1643       '#define HAVE_GETRANDOM(B,S) syscall(SYS_getrandom, B, S, 0)
1644       #define HAVE_GETRANDOM_HEADER <sys/syscall.h>' <<\!
1645 #include <sys/syscall.h>
1646 int main(void){
1647    char buf[256];
1648    syscall(SYS_getrandom, buf, sizeof buf, 0);
1649    return 0;
1650 }
1651 !
1652 then
1653    :
1654 elif [ -n "${have_no_subsecond_time}" ]; then
1655    msg 'ERROR: %s %s' 'without a native random' \
1656       'one of clock_gettime(2) and gettimeofday(2) is required.'
1657    config_exit 1
1658 fi
1659
1660
1661 link_check putc_unlocked 'putc_unlocked(3)' '#define HAVE_PUTC_UNLOCKED' <<\!
1662 #include <stdio.h>
1663 int main(void){
1664    putc_unlocked('@', stdout);
1665    return 0;
1666 }
1667 !
1668
1669 link_check fchdir 'fchdir(3)' '#define HAVE_FCHDIR' << \!
1670 #include <unistd.h>
1671 int main(void){
1672    fchdir(0);
1673    return 0;
1674 }
1675 !
1676
1677 if run_check realpath 'realpath(3)' '#define HAVE_REALPATH' << \!
1678 #include <stdlib.h>
1679 int main(void){
1680    char x_buf[4096], *x = realpath(".", x_buf);
1681
1682    return (x != NULL) ? 0 : 1;
1683 }
1684 !
1685 then
1686    if run_check realpath_malloc 'realpath(3) takes NULL' \
1687          '#define HAVE_REALPATH_NULL' << \!
1688 #include <stdlib.h>
1689 int main(void){
1690    char *x = realpath(".", NULL);
1691
1692    if(x != NULL)
1693       free(x);
1694    return (x != NULL) ? 0 : 1;
1695 }
1696 !
1697    then
1698       :
1699    fi
1700 fi
1701
1702 ## optional and selectable
1703
1704 if feat_yes DOTLOCK; then
1705    if run_check readlink 'readlink(2)' << \!
1706 #include <unistd.h>
1707 # include <errno.h>
1708 int main(void){
1709    char buf[128];
1710
1711    if(!readlink("here", buf, sizeof buf) || errno != ENOSYS)
1712       return 0;
1713    return 1;
1714 }
1715 !
1716    then
1717       :
1718    else
1719       feat_bail_required DOTLOCK
1720    fi
1721 fi
1722
1723 if feat_yes DOTLOCK; then
1724    if run_check fchown 'fchown(2)' << \!
1725 #include <unistd.h>
1726 # include <errno.h>
1727 int main(void){
1728    if(!fchown(0, 0, 0) || errno != ENOSYS)
1729       return 0;
1730    return 1;
1731 }
1732 !
1733    then
1734       :
1735    else
1736       feat_bail_required DOTLOCK
1737    fi
1738 fi
1739
1740 ## Now it is the time to fork away the BASE_ series
1741
1742 ${rm} -f ${tmp}
1743 squeeze_em ${inc} ${tmp}
1744 ${mv} ${tmp} ${inc}
1745 squeeze_em ${lib} ${tmp}
1746 ${mv} ${tmp} ${lib}
1747
1748 echo "BASE_LIBS = `${cat} ${lib}`" >> ${mk}
1749 echo "BASE_INCS = `${cat} ${inc}`" >> ${mk}
1750
1751 ## The remains are expected to be used only by the main MUA binary!
1752
1753 OPT_LOCALES=0
1754 link_check setlocale 'setlocale(3)' '#define HAVE_SETLOCALE' << \!
1755 #include <locale.h>
1756 int main(void){
1757    setlocale(LC_ALL, "");
1758    return 0;
1759 }
1760 !
1761 [ -n "${have_setlocale}" ] && OPT_LOCALES=1
1762
1763 OPT_MULTIBYTE_CHARSETS=0
1764 OPT_WIDE_GLYPHS=0
1765 OPT_TERMINAL_CHARSET=0
1766 if [ -n "${have_setlocale}" ]; then
1767    link_check c90amend1 'ISO/IEC 9899:1990/Amendment 1:1995' \
1768       '#define HAVE_C90AMEND1' << \!
1769 #include <limits.h>
1770 #include <stdlib.h>
1771 #include <wchar.h>
1772 #include <wctype.h>
1773 int main(void){
1774    char mbb[MB_LEN_MAX + 1];
1775    wchar_t wc;
1776
1777    iswprint(L'c');
1778    towupper(L'c');
1779    mbtowc(&wc, "x", 1);
1780    mbrtowc(&wc, "x", 1, NULL);
1781    wctomb(mbb, wc);
1782    return (mblen("\0", 1) == 0);
1783 }
1784 !
1785    [ -n "${have_c90amend1}" ] && OPT_MULTIBYTE_CHARSETS=1
1786
1787    if [ -n "${have_c90amend1}" ]; then
1788       link_check wcwidth 'wcwidth(3)' '#define HAVE_WCWIDTH' << \!
1789 #include <wchar.h>
1790 int main(void){
1791    wcwidth(L'c');
1792    return 0;
1793 }
1794 !
1795       [ -n "${have_wcwidth}" ] && OPT_WIDE_GLYPHS=1
1796    fi
1797
1798    link_check nl_langinfo 'nl_langinfo(3)' '#define HAVE_NL_LANGINFO' << \!
1799 #include <langinfo.h>
1800 #include <stdlib.h>
1801 int main(void){
1802    nl_langinfo(DAY_1);
1803    return (nl_langinfo(CODESET) == NULL);
1804 }
1805 !
1806    [ -n "${have_nl_langinfo}" ] && OPT_TERMINAL_CHARSET=1
1807 fi # have_setlocale
1808
1809 link_check fnmatch 'fnmatch(3)' '#define HAVE_FNMATCH' << \!
1810 #include <fnmatch.h>
1811 int main(void){
1812    return (fnmatch("*", ".", FNM_PATHNAME | FNM_PERIOD) == FNM_NOMATCH);
1813 }
1814 !
1815
1816 link_check dirent_d_type 'struct dirent.d_type' '#define HAVE_DIRENT_TYPE' << \!
1817 #include <dirent.h>
1818 int main(void){
1819    struct dirent de;
1820    return !(de.d_type == DT_UNKNOWN ||
1821       de.d_type == DT_DIR || de.d_type == DT_LNK);
1822 }
1823 !
1824
1825 ## optional and selectable
1826
1827 if feat_yes ICONV; then
1828    ${cat} > ${tmp2}.c << \!
1829 #include <stdio.h> /* For C89 NULL */
1830 #include <iconv.h>
1831 int main(void){
1832    iconv_t id;
1833
1834    id = iconv_open("foo", "bar");
1835    iconv(id, NULL, NULL, NULL, NULL);
1836    iconv_close(id);
1837    return 0;
1838 }
1839 !
1840    < ${tmp2}.c link_check iconv 'iconv(3) functionality' \
1841          '#define HAVE_ICONV' ||
1842       < ${tmp2}.c link_check iconv 'iconv(3) functionality (via -liconv)' \
1843          '#define HAVE_ICONV' '-liconv' ||
1844       feat_bail_required ICONV
1845 else
1846    echo '/* OPT_ICONV=0 */' >> ${h}
1847 fi # feat_yes ICONV
1848
1849 if feat_yes SOCKETS || feat_yes SPAM_SPAMD; then
1850    ${cat} > ${tmp2}.c << \!
1851 #include <sys/types.h>
1852 #include <sys/socket.h>
1853 #include <sys/un.h>
1854 # include <errno.h>
1855 int main(void){
1856    struct sockaddr_un soun;
1857
1858    if(socket(AF_UNIX, SOCK_STREAM, 0) == -1 && errno == ENOSYS)
1859       return 1;
1860    if(connect(0, (struct sockaddr*)&soun, 0) == -1 && errno == ENOSYS)
1861       return 1;
1862    if(shutdown(0, SHUT_RD | SHUT_WR | SHUT_RDWR) == -1 && errno == ENOSYS)
1863       return 1;
1864    return 0;
1865 }
1866 !
1867
1868    < ${tmp2}.c run_check af_unix 'AF_UNIX sockets' \
1869          '#define HAVE_UNIX_SOCKETS' ||
1870       < ${tmp2}.c run_check af_unix 'AF_UNIX sockets (via -lnsl)' \
1871          '#define HAVE_UNIX_SOCKETS' '-lnsl' ||
1872       < ${tmp2}.c run_check af_unix 'AF_UNIX sockets (via -lsocket -lnsl)' \
1873          '#define HAVE_UNIX_SOCKETS' '-lsocket -lnsl'
1874 fi
1875
1876 if feat_yes SOCKETS; then
1877    ${cat} > ${tmp2}.c << \!
1878 #include "config.h"
1879 #include <sys/types.h>
1880 #include <sys/socket.h>
1881 #include <netinet/in.h>
1882 # include <errno.h>
1883 int main(void){
1884    struct sockaddr s;
1885
1886    if(socket(AF_INET, SOCK_STREAM, 0) == -1 && errno == ENOSYS)
1887       return 1;
1888    if(connect(0, &s, 0) == -1 && errno == ENOSYS)
1889       return 1;
1890    return 0;
1891 }
1892 !
1893
1894    < ${tmp2}.c run_check sockets 'sockets' \
1895          '#define HAVE_SOCKETS' ||
1896       < ${tmp2}.c run_check sockets 'sockets (via -lnsl)' \
1897          '#define HAVE_SOCKETS' '-lnsl' ||
1898       < ${tmp2}.c run_check sockets 'sockets (via -lsocket -lnsl)' \
1899          '#define HAVE_SOCKETS' '-lsocket -lnsl' ||
1900       feat_bail_required SOCKETS
1901 else
1902    echo '/* OPT_SOCKETS=0 */' >> ${h}
1903 fi # feat_yes SOCKETS
1904
1905 if feat_yes SOCKETS; then
1906    link_check getaddrinfo 'getaddrinfo(3)' \
1907       '#define HAVE_GETADDRINFO' << \!
1908 #include "config.h"
1909 #include <sys/types.h>
1910 #include <sys/socket.h>
1911 #include <stdio.h>
1912 #include <netdb.h>
1913 int main(void){
1914    struct addrinfo a, *ap;
1915    int lrv;
1916
1917    switch((lrv = getaddrinfo("foo", "0", &a, &ap))){
1918    case EAI_NONAME:
1919    case EAI_SERVICE:
1920    default:
1921       fprintf(stderr, "%s\n", gai_strerror(lrv));
1922    case 0:
1923       break;
1924    }
1925    return 0;
1926 }
1927 !
1928 fi
1929
1930 if feat_yes SOCKETS && [ -z "${have_getaddrinfo}" ]; then
1931    compile_check arpa_inet_h '<arpa/inet.h>' \
1932       '#define HAVE_ARPA_INET_H' << \!
1933 #include "config.h"
1934 #include <sys/types.h>
1935 #include <sys/socket.h>
1936 #include <netdb.h>
1937 #include <netinet/in.h>
1938 #include <arpa/inet.h>
1939 !
1940
1941    ${cat} > ${tmp2}.c << \!
1942 #include "config.h"
1943 #include <sys/types.h>
1944 #include <sys/socket.h>
1945 #include <stdio.h>
1946 #include <string.h>
1947 #include <netdb.h>
1948 #include <netinet/in.h>
1949 #ifdef HAVE_ARPA_INET_H
1950 #include <arpa/inet.h>
1951 #endif
1952 int main(void){
1953    struct sockaddr_in servaddr;
1954    unsigned short portno;
1955    struct servent *ep;
1956    struct hostent *hp;
1957    struct in_addr **pptr;
1958
1959    portno = 0;
1960    if((ep = getservbyname("POPPY-PORT", "tcp")) != NULL)
1961       portno = (unsigned short)ep->s_port;
1962
1963    if((hp = gethostbyname("POPPY-HOST")) != NULL){
1964       pptr = (struct in_addr**)hp->h_addr_list;
1965       if(hp->h_addrtype != AF_INET)
1966          fprintf(stderr, "au\n");
1967    }else{
1968       switch(h_errno){
1969       case HOST_NOT_FOUND:
1970       case TRY_AGAIN:
1971       case NO_RECOVERY:
1972       case NO_DATA:
1973          break;
1974       default:
1975          fprintf(stderr, "au\n");
1976          break;
1977       }
1978    }
1979
1980    memset(&servaddr, 0, sizeof servaddr);
1981    servaddr.sin_family = AF_INET;
1982    servaddr.sin_port = htons(portno);
1983    memcpy(&servaddr.sin_addr, *pptr, sizeof(struct in_addr));
1984    fprintf(stderr, "Would connect to %s:%d ...\n",
1985       inet_ntoa(**pptr), (int)portno);
1986    return 0;
1987 }
1988 !
1989
1990    < ${tmp2}.c link_check gethostbyname 'get(serv|host)byname(3)' ||
1991       < ${tmp2}.c link_check gethostbyname \
1992          'get(serv|host)byname(3) (via -nsl)' '' '-lnsl' ||
1993       < ${tmp2}.c link_check gethostbyname \
1994          'get(serv|host)byname(3) (via -lsocket -nsl)' \
1995          '' '-lsocket -lnsl' ||
1996       feat_bail_required SOCKETS
1997 fi
1998
1999 feat_yes SOCKETS &&
2000 run_check setsockopt 'setsockopt(2)' '#define HAVE_SETSOCKOPT' << \!
2001 #include <sys/socket.h>
2002 #include <stdlib.h>
2003 # include <errno.h>
2004 int main(void){
2005    int sockfd = 3;
2006
2007    if(setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, NULL, 0) == -1 &&
2008          errno == ENOSYS)
2009       return 1;
2010    return 0;
2011 }
2012 !
2013
2014 feat_yes SOCKETS && [ -n "${have_setsockopt}" ] &&
2015 link_check so_sndtimeo 'SO_SNDTIMEO' '#define HAVE_SO_SNDTIMEO' << \!
2016 #include <sys/socket.h>
2017 #include <stdlib.h>
2018 int main(void){
2019    struct timeval tv;
2020    int sockfd = 3;
2021
2022    tv.tv_sec = 42;
2023    tv.tv_usec = 21;
2024    setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof tv);
2025    setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof tv);
2026    return 0;
2027 }
2028 !
2029
2030 feat_yes SOCKETS && [ -n "${have_setsockopt}" ] &&
2031 link_check so_linger 'SO_LINGER' '#define HAVE_SO_LINGER' << \!
2032 #include <sys/socket.h>
2033 #include <stdlib.h>
2034 int main(void){
2035    struct linger li;
2036    int sockfd = 3;
2037
2038    li.l_onoff = 1;
2039    li.l_linger = 42;
2040    setsockopt(sockfd, SOL_SOCKET, SO_LINGER, &li, sizeof li);
2041    return 0;
2042 }
2043 !
2044
2045 if feat_yes SSL; then # {{{
2046    # {{{ LibreSSL decided to define OPENSSL_VERSION_NUMBER with a useless value
2047    # instead of keeping it at the one that corresponds to the OpenSSL at fork
2048    # time: we need to test it first in order to get things right
2049    if compile_check _xssl 'TLS/SSL (LibreSSL)' \
2050       '#define HAVE_SSL
2051       #define HAVE_XSSL
2052       #define HAVE_XSSL_RESSL
2053       #define HAVE_XSSL_OPENSSL 0' << \!
2054 #include <openssl/opensslv.h>
2055 #ifdef LIBRESSL_VERSION_NUMBER
2056 #else
2057 # error nope
2058 #endif
2059 !
2060    then
2061       ossl_v1_1=
2062    # TODO OPENSSL_IS_BORINGSSL, but never tried that one!
2063    elif compile_check _xssl 'TLS/SSL (OpenSSL >= v1.1.0)' \
2064       '#define HAVE_SSL
2065       #define HAVE_XSSL
2066       #define HAVE_XSSL_OPENSSL 0x10100' << \!
2067 #include <openssl/opensslv.h>
2068 #if OPENSSL_VERSION_NUMBER + 0 >= 0x10100000L
2069 #else
2070 # error nope
2071 #endif
2072 !
2073    then
2074       ossl_v1_1=1
2075    elif compile_check _xssl 'TLS/SSL (OpenSSL)' \
2076       '#define HAVE_SSL
2077       #define HAVE_XSSL
2078       #define HAVE_XSSL_OPENSSL 0x10000' << \!
2079 #include <openssl/opensslv.h>
2080 #ifdef OPENSSL_VERSION_NUMBER
2081 #else
2082 # error nope
2083 #endif
2084 !
2085    then
2086       ossl_v1_1=
2087    else
2088       feat_bail_required SSL
2089    fi # }}}
2090
2091    if feat_yes SSL; then # {{{
2092       if [ -n "${ossl_v1_1}" ]; then
2093          without_check yes xssl 'TLS/SSL (new style *_client_method(3ssl))' \
2094             '#define n_XSSL_CLIENT_METHOD TLS_client_method' \
2095             '-lssl -lcrypto'
2096       elif link_check xssl 'TLS/SSL (new style *_client_method(3ssl))' \
2097             '#define n_XSSL_CLIENT_METHOD TLS_client_method' \
2098             '-lssl -lcrypto' << \!
2099 #include <openssl/ssl.h>
2100 #include <openssl/err.h>
2101 #include <openssl/x509v3.h>
2102 #include <openssl/x509.h>
2103 #include <openssl/rand.h>
2104 #ifdef OPENSSL_NO_TLS1 /* TODO only deduced from OPENSSL_NO_SSL[23]! */
2105 # error We need TLSv1.
2106 #endif
2107 int main(void){
2108    SSL_CTX *ctx = SSL_CTX_new(TLS_client_method());
2109
2110    SSL_CTX_free(ctx);
2111    PEM_read_PrivateKey(0, 0, 0, 0);
2112    return 0;
2113 }
2114 !
2115       then
2116          :
2117       elif link_check xssl 'TLS/SSL (old style *_client_method(3ssl))' \
2118             '#define n_XSSL_CLIENT_METHOD SSLv23_client_method' \
2119             '-lssl -lcrypto' << \!
2120 #include <openssl/ssl.h>
2121 #include <openssl/err.h>
2122 #include <openssl/x509v3.h>
2123 #include <openssl/x509.h>
2124 #include <openssl/rand.h>
2125 #if defined OPENSSL_NO_SSL3 &&\
2126       defined OPENSSL_NO_TLS1 /* TODO only deduced from OPENSSL_NO_SSL[23]! */
2127 # error We need one of SSLv3 and TLSv1.
2128 #endif
2129 int main(void){
2130    SSL_CTX *ctx = SSL_CTX_new(SSLv23_client_method());
2131
2132    SSL_CTX_free(ctx);
2133    PEM_read_PrivateKey(0, 0, 0, 0);
2134    return 0;
2135 }
2136 !
2137       then
2138          :
2139       else
2140          feat_bail_required SSL
2141       fi
2142    fi # }}}
2143
2144    if feat_yes SSL; then # {{{
2145       if [ -n "${ossl_v1_1}" ]; then
2146          without_check yes xssl_stack_of 'TLS/SSL STACK_OF()' \
2147             '#define HAVE_XSSL_STACK_OF'
2148       elif compile_check xssl_stack_of 'TLS/SSL STACK_OF()' \
2149             '#define HAVE_XSSL_STACK_OF' << \!
2150 #include <stdio.h> /* For C89 NULL */
2151 #include <openssl/ssl.h>
2152 #include <openssl/err.h>
2153 #include <openssl/x509v3.h>
2154 #include <openssl/x509.h>
2155 #include <openssl/rand.h>
2156 int main(void){
2157    STACK_OF(GENERAL_NAME) *gens = NULL;
2158
2159    printf("%p", gens); /* to use it */
2160    return 0;
2161 }
2162 !
2163       then
2164          :
2165       fi
2166
2167       if [ -n "${ossl_v1_1}" ]; then
2168          without_check yes xssl_conf 'TLS/SSL OpenSSL_modules_load_file()' \
2169             '#define HAVE_XSSL_CONFIG'
2170       elif link_check xssl_conf 'TLS/SSL OpenSSL_modules_load_file() support' \
2171             '#define HAVE_XSSL_CONFIG' << \!
2172 #include <stdio.h> /* For C89 NULL */
2173 #include <openssl/conf.h>
2174 int main(void){
2175    CONF_modules_load_file(NULL, NULL, CONF_MFLAGS_IGNORE_MISSING_FILE);
2176    CONF_modules_free();
2177    return 0;
2178 }
2179 !
2180       then
2181          :
2182       fi
2183
2184       if [ -n "${ossl_v1_1}" ]; then
2185          without_check yes xssl_conf_ctx 'TLS/SSL SSL_CONF_CTX support' \
2186             '#define HAVE_XSSL_CONF_CTX'
2187       elif link_check xssl_conf_ctx 'TLS/SSL SSL_CONF_CTX support' \
2188          '#define HAVE_XSSL_CONF_CTX' << \!
2189 #include "config.h"
2190 #include <openssl/ssl.h>
2191 #include <openssl/err.h>
2192 int main(void){
2193    SSL_CTX *ctx = SSL_CTX_new(n_XSSL_CLIENT_METHOD());
2194    SSL_CONF_CTX *cctx = SSL_CONF_CTX_new();
2195
2196    SSL_CONF_CTX_set_flags(cctx,
2197       SSL_CONF_FLAG_FILE | SSL_CONF_FLAG_CLIENT |
2198       SSL_CONF_FLAG_CERTIFICATE | SSL_CONF_FLAG_SHOW_ERRORS);
2199    SSL_CONF_CTX_set_ssl_ctx(cctx, ctx);
2200    SSL_CONF_cmd(cctx, "Protocol", "ALL");
2201    SSL_CONF_CTX_finish(cctx);
2202    SSL_CONF_CTX_free(cctx);
2203    SSL_CTX_free(ctx);
2204    return 0;
2205 }
2206 !
2207       then
2208          :
2209       fi
2210
2211       if [ -n "${ossl_v1_1}" ]; then
2212          without_check no xssl_rand_egd 'TLS/SSL RAND_egd(3ssl)' \
2213             '#define HAVE_XSSL_RAND_EGD'
2214       elif link_check xssl_rand_egd 'TLS/SSL RAND_egd(3ssl)' \
2215             '#define HAVE_XSSL_RAND_EGD' << \!
2216 #include <openssl/rand.h>
2217 int main(void){
2218    return RAND_egd("some.where") > 0;
2219 }
2220 !
2221       then
2222          :
2223       fi
2224
2225       if feat_yes SSL_ALL_ALGORITHMS; then
2226          if [ -n "${ossl_v1_1}" ]; then
2227             without_check yes ssl_all_algo 'TLS/SSL all-algorithms support' \
2228                '#define HAVE_SSL_ALL_ALGORITHMS'
2229          elif link_check ssl_all_algo 'TLS/SSL all-algorithms support' \
2230             '#define HAVE_SSL_ALL_ALGORITHMS' << \!
2231 #include <openssl/evp.h>
2232 int main(void){
2233    OpenSSL_add_all_algorithms();
2234    EVP_get_cipherbyname("two cents i never exist");
2235    EVP_cleanup();
2236    return 0;
2237 }
2238 !
2239          then
2240             :
2241          else
2242             feat_bail_required SSL_ALL_ALGORITHMS
2243          fi
2244       fi
2245    fi # feat_yes SSL }}}
2246
2247    if feat_yes SSL && feat_yes MD5 && feat_no NOEXTMD5; then # {{{
2248       run_check ssl_md5 'MD5 digest in the used crypto library' \
2249             '#define HAVE_XSSL_MD5' << \!
2250 #include <stdlib.h>
2251 #include <string.h>
2252 #include <openssl/md5.h>
2253 int main(void){
2254    char const dat[] = "abrakadabrafidibus";
2255    char dig[16], hex[16 * 2];
2256    MD5_CTX ctx;
2257    size_t i, j;
2258
2259    memset(dig, 0, sizeof(dig));
2260    memset(hex, 0, sizeof(hex));
2261    MD5_Init(&ctx);
2262    MD5_Update(&ctx, dat, sizeof(dat) - 1);
2263    MD5_Final(dig, &ctx);
2264
2265 #define hexchar(n) ((n) > 9 ? (n) - 10 + 'a' : (n) + '0')
2266    for(i = 0; i < sizeof(hex) / 2; i++){
2267       j = i << 1;
2268       hex[j] = hexchar((dig[i] & 0xf0) >> 4);
2269       hex[++j] = hexchar(dig[i] & 0x0f);
2270    }
2271    return !!memcmp("6d7d0a3d949da2e96f2aa010f65d8326", hex, sizeof(hex));
2272 }
2273 !
2274    fi # }}}
2275 else
2276    echo '/* OPT_SSL=0 */' >> ${h}
2277 fi # }}} feat_yes SSL
2278
2279 if [ "${have_xssl}" = yes ]; then
2280    OPT_SMIME=1
2281 else
2282    OPT_SMIME=0
2283 fi
2284 feat_def SMIME
2285
2286 feat_def SMTP
2287 feat_def POP3
2288
2289 if feat_yes GSSAPI; then
2290    ${cat} > ${tmp2}.c << \!
2291 #include <gssapi/gssapi.h>
2292 int main(void){
2293    gss_import_name(0, 0, GSS_C_NT_HOSTBASED_SERVICE, 0);
2294    gss_init_sec_context(0,0,0,0,0,0,0,0,0,0,0,0,0);
2295    return 0;
2296 }
2297 !
2298    ${sed} -e '1s/gssapi\///' < ${tmp2}.c > ${tmp3}.c
2299
2300    if command -v krb5-config >/dev/null 2>&1; then
2301       i=`command -v krb5-config`
2302       GSS_LIBS="`CFLAGS= ${i} --libs gssapi`"
2303       GSS_INCS="`CFLAGS= ${i} --cflags`"
2304       i='GSS-API via krb5-config(1)'
2305    else
2306       GSS_LIBS='-lgssapi'
2307       GSS_INCS=
2308       i='GSS-API in gssapi/gssapi.h, libgssapi'
2309    fi
2310    if < ${tmp2}.c link_check gss \
2311          "${i}" '#define HAVE_GSSAPI' "${GSS_LIBS}" "${GSS_INCS}" ||\
2312       < ${tmp3}.c link_check gss \
2313          'GSS-API in gssapi.h, libgssapi' \
2314          '#define HAVE_GSSAPI
2315          #define GSSAPI_REG_INCLUDE' \
2316          '-lgssapi' ||\
2317       < ${tmp2}.c link_check gss 'GSS-API in libgssapi_krb5' \
2318          '#define HAVE_GSSAPI' \
2319          '-lgssapi_krb5' ||\
2320       < ${tmp3}.c link_check gss \
2321          'GSS-API in libgssapi, OpenBSD-style (pre 5.3)' \
2322          '#define HAVE_GSSAPI
2323          #define GSS_REG_INCLUDE' \
2324          '-lgssapi -lkrb5 -lcrypto' \
2325          '-I/usr/include/kerberosV' ||\
2326       < ${tmp2}.c link_check gss 'GSS-API in libgss' \
2327          '#define HAVE_GSSAPI' \
2328          '-lgss' ||\
2329       link_check gss 'GSS-API in libgssapi_krb5, old-style' \
2330          '#define HAVE_GSSAPI
2331          #define GSSAPI_OLD_STYLE' \
2332          '-lgssapi_krb5' << \!
2333 #include <gssapi/gssapi.h>
2334 #include <gssapi/gssapi_generic.h>
2335 int main(void){
2336    gss_import_name(0, 0, gss_nt_service_name, 0);
2337    gss_init_sec_context(0,0,0,0,0,0,0,0,0,0,0,0,0);
2338    return 0;
2339 }
2340 !
2341    then
2342       :
2343    else
2344       feat_bail_required GSSAPI
2345    fi
2346 else
2347    echo '/* OPT_GSSAPI=0 */' >> ${h}
2348 fi # feat_yes GSSAPI
2349
2350 feat_def NETRC
2351 feat_def AGENT
2352
2353 if feat_yes IDNA; then
2354    if link_check idna 'GNU Libidn' '#define HAVE_IDNA HAVE_IDNA_LIBIDNA' \
2355          '-lidn' << \!
2356 #include <idna.h>
2357 #include <idn-free.h>
2358 #include <stringprep.h>
2359 int main(void){
2360    char *utf8, *idna_ascii, *idna_utf8;
2361
2362    utf8 = stringprep_locale_to_utf8("does.this.work");
2363    if (idna_to_ascii_8z(utf8, &idna_ascii, IDNA_USE_STD3_ASCII_RULES)
2364          != IDNA_SUCCESS)
2365       return 1;
2366    idn_free(idna_ascii);
2367    /* (Rather link check only here) */
2368    idna_utf8 = stringprep_convert(idna_ascii, "UTF-8", "de_DE");
2369    return 0;
2370 }
2371 !
2372    then
2373       :
2374    elif link_check idna 'idnkit' '#define HAVE_IDNA HAVE_IDNA_IDNKIT' \
2375          '-lidnkit' << \!
2376 #include <stdio.h>
2377 #include <idn/api.h>
2378 #include <idn/result.h>
2379 int main(void){
2380    idn_result_t r;
2381    char ace_name[256];
2382    char local_name[256];
2383
2384    r = idn_encodename(IDN_ENCODE_APP, "does.this.work", ace_name,
2385          sizeof(ace_name));
2386    if (r != idn_success) {
2387       fprintf(stderr, "idn_encodename failed: %s\n", idn_result_tostring(r));
2388       return 1;
2389    }
2390    r = idn_decodename(IDN_DECODE_APP, ace_name, local_name, sizeof(local_name));
2391    if (r != idn_success) {
2392       fprintf(stderr, "idn_decodename failed: %s\n", idn_result_tostring(r));
2393       return 1;
2394    }
2395    return 0;
2396 }
2397 !
2398    then
2399       :
2400    else
2401       feat_bail_required IDNA
2402    fi
2403
2404    if [ -n "${have_idna}" ]; then
2405       echo '#define HAVE_IDNA_LIBIDNA 0' >> ${h}
2406       echo '#define HAVE_IDNA_IDNKIT 1' >> ${h}
2407    fi
2408 else
2409    echo '/* OPT_IDNA=0 */' >> ${h}
2410 fi
2411
2412 feat_def IMAP_SEARCH
2413
2414 if feat_yes REGEX; then
2415    if link_check regex 'regular expressions' '#define HAVE_REGEX' << \!
2416 #include <regex.h>
2417 #include <stdlib.h>
2418 int main(void){
2419    size_t xret;
2420    int status;
2421    regex_t re;
2422
2423    status = regcomp(&re, ".*bsd", REG_EXTENDED | REG_ICASE | REG_NOSUB);
2424    xret = regerror(status, &re, NULL, 0);
2425    status = regexec(&re, "plan9", 0,NULL, 0);
2426    regfree(&re);
2427    return !(status == REG_NOMATCH);
2428 }
2429 !
2430    then
2431       :
2432    else
2433       feat_bail_required REGEX
2434    fi
2435 else
2436    echo '/* OPT_REGEX=0 */' >> ${h}
2437 fi
2438
2439 if feat_yes MLE && [ -n "${have_c90amend1}" ]; then
2440    have_mle=1
2441    echo '#define HAVE_MLE' >> ${h}
2442 else
2443    feat_bail_required MLE
2444    echo '/* OPT_MLE=0 */' >> ${h}
2445 fi
2446
2447 # Generic have-a-line-editor switch for those who need it below
2448 if [ -n "${have_mle}" ]; then
2449    have_cle=1
2450 fi
2451
2452 if [ -n "${have_cle}" ] && feat_yes HISTORY; then
2453    echo '#define HAVE_HISTORY' >> ${h}
2454 else
2455    echo '/* OPT_HISTORY=0 */' >> ${h}
2456 fi
2457
2458 if [ -n "${have_mle}" ] && feat_yes KEY_BINDINGS; then
2459    echo '#define HAVE_KEY_BINDINGS' >> ${h}
2460 else
2461    echo '/* OPT_KEY_BINDINGS=0 */' >> ${h}
2462 fi
2463
2464 if feat_yes TERMCAP; then
2465    __termcaplib() {
2466       link_check termcap "termcap(5) (via ${4})" \
2467          "#define HAVE_TERMCAP${3}" "${1}" << _EOT
2468 #include <stdio.h>
2469 #include <stdlib.h>
2470 ${2}
2471 #include <term.h>
2472 #define UNCONST(P) ((void*)(unsigned long)(void const*)(P))
2473 static int my_putc(int c){return putchar(c);}
2474 int main(void){
2475    char buf[1024+512], cmdbuf[2048], *cpb, *r1;
2476    int r2 = OK, r3 = ERR;
2477
2478    tgetent(buf, getenv("TERM"));
2479    cpb = cmdbuf;
2480    r1 = tgetstr(UNCONST("cm"), &cpb);
2481    tgoto(r1, 1, 1);
2482    r2 = tgetnum(UNCONST("Co"));
2483    r3 = tgetflag(UNCONST("ut"));
2484    tputs("cr", 1, &my_putc);
2485    return (r1 == NULL || r2 == -1 || r3 == 0);
2486 }
2487 _EOT
2488    }
2489
2490    __terminfolib() {
2491       link_check terminfo "terminfo(5) (via ${2})" \
2492          '#define HAVE_TERMCAP
2493          #define HAVE_TERMCAP_CURSES
2494          #define HAVE_TERMINFO' "${1}" << _EOT
2495 #include <stdio.h>
2496 #include <curses.h>
2497 #include <term.h>
2498 #define UNCONST(P) ((void*)(unsigned long)(void const*)(P))
2499 static int my_putc(int c){return putchar(c);}
2500 int main(void){
2501    int er, r0, r1, r2;
2502    char *r3, *tp;
2503
2504    er = OK;
2505    r0 = setupterm(NULL, 1, &er);
2506    r1 = tigetflag(UNCONST("bce"));
2507    r2 = tigetnum(UNCONST("colors"));
2508    r3 = tigetstr(UNCONST("cr"));
2509    tp = tparm(r3, NULL, NULL, 0,0,0,0,0,0,0);
2510    tputs(tp, 1, &my_putc);
2511    return (r0 == ERR || r1 == -1 || r2 == -2 || r2 == -1 ||
2512       r3 == (char*)-1 || r3 == NULL);
2513 }
2514 _EOT
2515    }
2516
2517    if feat_yes TERMCAP_VIA_TERMINFO; then
2518       __terminfolib -ltinfo -ltinfo ||
2519          __terminfolib -lcurses -lcurses ||
2520          __terminfolib -lcursesw -lcursesw ||
2521          feat_bail_required TERMCAP_VIA_TERMINFO
2522    fi
2523
2524    if [ -z "${have_terminfo}" ]; then
2525       __termcaplib -ltermcap '' '' '-ltermcap' ||
2526          __termcaplib -ltermcap '#include <curses.h>' '
2527             #define HAVE_TERMCAP_CURSES' \
2528             'curses.h / -ltermcap' ||
2529          __termcaplib -lcurses '#include <curses.h>' '
2530             #define HAVE_TERMCAP_CURSES' \
2531             'curses.h / -lcurses' ||
2532          __termcaplib -lcursesw '#include <curses.h>' '
2533             #define HAVE_TERMCAP_CURSES' \
2534             'curses.h / -lcursesw' ||
2535          feat_bail_required TERMCAP
2536
2537       if [ -n "${have_termcap}" ]; then
2538          run_check tgetent_null \
2539             "tgetent(3) of termcap(5) takes NULL buffer" \
2540             "#define HAVE_TGETENT_NULL_BUF" << _EOT
2541 #include <stdio.h> /* For C89 NULL */
2542 #include <stdlib.h>
2543 #ifdef HAVE_TERMCAP_CURSES
2544 # include <curses.h>
2545 #endif
2546 #include <term.h>
2547 int main(void){
2548    tgetent(NULL, getenv("TERM"));
2549    return 0;
2550 }
2551 _EOT
2552       fi
2553    fi
2554 else
2555    echo '/* OPT_TERMCAP=0 */' >> ${h}
2556    echo '/* OPT_TERMCAP_VIA_TERMINFO=0 */' >> ${h}
2557 fi
2558
2559 if feat_def SPAM_SPAMC; then
2560    if command -v spamc >/dev/null 2>&1; then
2561       echo "#define SPAM_SPAMC_PATH \"`command -v spamc`\"" >> ${h}
2562    fi
2563 fi
2564
2565 if feat_yes SPAM_SPAMD && [ -n "${have_af_unix}" ]; then
2566    echo '#define HAVE_SPAM_SPAMD' >> ${h}
2567 else
2568    feat_bail_required SPAM_SPAMD
2569    echo '/* OPT_SPAM_SPAMD=0 */' >> ${h}
2570 fi
2571
2572 feat_def SPAM_FILTER
2573
2574 if feat_yes SPAM_SPAMC || feat_yes SPAM_SPAMD || feat_yes SPAM_FILTER; then
2575    echo '#define HAVE_SPAM' >> ${h}
2576 else
2577    echo '/* HAVE_SPAM */' >> ${h}
2578 fi
2579
2580 if feat_yes QUOTE_FOLD &&\
2581       [ -n "${have_c90amend1}" ] && [ -n "${have_wcwidth}" ]; then
2582    echo '#define HAVE_QUOTE_FOLD' >> ${h}
2583 else
2584    feat_bail_required QUOTE_FOLD
2585    echo '/* OPT_QUOTE_FOLD=0 */' >> ${h}
2586 fi
2587
2588 feat_def FILTER_HTML_TAGSOUP
2589 feat_def COLOUR
2590 feat_def DOTLOCK
2591 feat_def MD5
2592 feat_def NOMEMDBG
2593
2594 ## Summarizing
2595
2596 ${rm} -f ${tmp}
2597 squeeze_em ${inc} ${tmp}
2598 ${mv} ${tmp} ${inc}
2599 squeeze_em ${lib} ${tmp}
2600 ${mv} ${tmp} ${lib}
2601
2602 # config.h
2603 ${mv} ${h} ${tmp}
2604 printf '#ifndef n_CONFIG_H\n# define n_CONFIG_H 1\n' > ${h}
2605 ${cat} ${tmp} >> ${h}
2606 ${rm} -f ${tmp}
2607 printf '\n' >> ${h}
2608
2609 # Create the real mk.mk
2610 # Note we cannout use explicit ./ filename prefix for source and object
2611 # pathnames because of a bug in bmake(1)
2612 ${rm} -rf ${tmp0}.* ${tmp0}*
2613 printf 'OBJ_SRC = ' >> ${mk}
2614 if feat_no AMALGAMATION; then
2615    for i in `printf '%s\n' *.c | ${sort}`; do
2616       if [ "${i}" = privsep.c ]; then
2617          continue
2618       fi
2619       printf "${i} " >> ${mk}
2620    done
2621    printf '\nAMALGAM_TARGET =\nAMALGAM_DEP =\n' >> ${mk}
2622 else
2623    printf 'main.c\nAMALGAM_TARGET = main.o\nAMALGAM_DEP = ' >> ${mk}
2624
2625    printf '\n/* HAVE_AMALGAMATION: include sources */\n' >> ${h}
2626    printf '#elif _CONFIG_H + 0 == 1\n' >> ${h}
2627    printf '# undef _CONFIG_H\n' >> ${h}
2628    printf '# define _CONFIG_H 2\n' >> ${h}
2629    for i in `printf '%s\n' *.c | ${sort}`; do
2630       if [ "${i}" = "${j}" ] || [ "${i}" = main.c ] || \
2631             [ "${i}" = privsep.c ]; then
2632          continue
2633       fi
2634       printf "${i} " >> ${mk}
2635       printf "# include \"${i}\"\n" >> ${h}
2636    done
2637    echo >> ${mk}
2638    # tcc(1) fails on 2015-11-13 unless this #else clause existed
2639    echo '#else' >> ${h}
2640 fi
2641
2642 # Finally, create the string that is used by *features* and `version'.
2643 # Take this nice opportunity and generate a visual listing of included and
2644 # non-included features for the person who runs the configuration
2645 msg '\nThe following features are included (+) or not (-):'
2646 set -- ${OPTIONS_DETECT} ${OPTIONS} ${OPTIONS_XTRA}
2647 printf '/* The "feature string" */\n' >> ${h}
2648 # Because + is expanded by *folder* if first in "echo $features", put something
2649 printf '#define VAL_FEATURES_CNT '${#}'\n#define VAL_FEATURES "#' >> ${h}
2650 sep=
2651 for opt
2652 do
2653    sdoc=`option_doc_of ${opt}`
2654    [ -z "${sdoc}" ] && continue
2655    sopt="`echo ${opt} | ${tr} '[A-Z]_' '[a-z]-'`"
2656    feat_yes ${opt} && sign=+ || sign=-
2657    printf -- "${sep}${sign}${sopt}" >> ${h}
2658    sep=','
2659    msg " %s %s: %s" ${sign} ${sopt} "${sdoc}"
2660 done
2661 # TODO instead of using sh+tr+awk+printf, use awk, drop option_doc_of, inc here
2662 #exec 5>&1 >>${h}
2663 #${awk} -v opts="${OPTIONS_DETECT} ${OPTIONS} ${OPTIONS_XTRA}" \
2664 #   -v xopts="${XOPTIONS_DETECT} ${XOPTIONS} ${XOPTIONS_XTRA}" \
2665 #
2666 printf '"\n#endif /* n_CONFIG_H */\n' >> ${h}
2667
2668 echo "LIBS = `${cat} ${lib}`" >> ${mk}
2669 echo "INCS = `${cat} ${inc}`" >> ${mk}
2670 echo >> ${mk}
2671 ${cat} ./mk-mk.in >> ${mk}
2672
2673 ## Finished!
2674
2675 msg '\nSetup:'
2676 msg ' . System-wide resource file: %s/%s' "${VAL_SYSCONFDIR}" "${VAL_SYSCONFRC}"
2677 msg ' . bindir: %s' "${VAL_BINDIR}"
2678 if feat_yes DOTLOCK; then
2679    msg ' . libexecdir: %s' "${VAL_LIBEXECDIR}"
2680 fi
2681 msg ' . mandir: %s' "${VAL_MANDIR}"
2682 msg ' . M(ail)T(ransfer)A(gent): %s (argv0 %s)' "${VAL_MTA}" "${VAL_MTA_ARGV0}"
2683 msg ' . $MAIL spool directory: %s' "${VAL_MAIL}"
2684 msg ''
2685
2686 if [ -n "${have_fnmatch}" ] && [ -n "${have_fchdir}" ]; then
2687    exit 0
2688 fi
2689 msg 'Remarks:'
2690 if [ -z "${have_fnmatch}" ]; then
2691    msg ' . The function fnmatch(3) could not be found.'
2692    msg '   Filename patterns like wildcard are not supported on your system'
2693 fi
2694 if [ -z "${have_fchdir}" ]; then
2695    msg ' . The function fchdir(2) could not be found.'
2696    msg '   We will use chdir(2) instead.'
2697    msg '   This is a problem only if the current working directory is changed'
2698    msg '   while this program is inside of it'
2699 fi
2700 msg ''
2701
2702 # s-it-mode