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