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