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