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