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