configure

   1 #!/bin/sh
   2
   3 die() {
   4         printf "$1\n" >&2
   5         exit 1
   6 }
   7
   8 usage() {
   9         cat <<EOF
  10 usage: configure [options] [settings]
  11
  12   --prefix=PREFIX        installation prefix [/usr]
  13   --exec-prefix=EPREFIX  installation prefix for executable files [PREFIX]
  14   --bindir=DIR           user executables [PREFIX/bin]
  15   --datadir=DIR          architecture-independent data files [PREFIX/share]
  16   --mandir=DIR           manual pages [DATADIR/man]
  17   --sysconfdir=DIR       directory for configuration files [/etc]
  18   --pamdir=DIR           PAM directory [SYSCONFDIR/pam.d]
  19
  20   --build=build-alias    a cpu-vendor-opsys for the system where the application will be built
  21   --host=host-alias      a cpu-vendor-opsys for the system where the application will run
  22   --target=target-alias  the machine that CC will produce code for
  23
  24   --enable-debug         enable debugging
  25   --enable-seccomp       enable seccomp
  26   --enable-static        prepare for static build
  27
  28   --help, -h             display this help and exit
  29 EOF
  30         exit 0
  31 }
  32
  33 for x; do
  34         opt=${x%%=*}
  35         var=${x#*=}
  36         case "$opt" in
  37         --prefix) PREFIX=$var;;
  38         --exec-prefix) EPREFIX=$var;;
  39         --bindir) BINDIR=$var;;
  40         --datadir) SHAREDIR=$var;;
  41         --mandir) MANDIR=$var;;
  42         --sysconfdir) SYSCONFDIR=$var;;
  43         --pamdir) PAMDIR=$var;;
  44         --build) BUILD=$var;;
  45         --host) HOST=$var;;
  46         --target) TARGET=$var;;
  47         --enable-debug) DEBUG=yes;;
  48         --enable-seccomp) BUILD_SECCOMP=yes;;
  49         --enable-static) BUILD_STATIC=yes;;
  50         --help|-h) usage;;
  51         *) die "Error: unknown option $opt";;
  52         esac
  53 done
  54
  55 CONFIG_MK=config.mk
  56 rm -f "$CONFIG_MK"
  57
  58 : ${VERSION:="$(git describe --dirty --tags --long --always)"}
  59
  60 cat <<EOF >>$CONFIG_MK
  61 DESTDIR  ?=     /
  62 PREFIX   ?=     ${PREFIX:="/usr"}
  63 EPREFIX  ?=     ${EPREFIX:="${PREFIX}"}
  64 BINDIR   ?=     ${BINDIR:="${PREFIX}/bin"}
  65 SHAREDIR ?=     ${SHAREDIR:="${PREFIX}/share"}
  66 MANDIR   ?=     ${MANDIR:="${SHAREDIR}/man"}
  67 SYSCONFDIR?=    ${SYSCONFDIR:="/etc"}
  68 PAMDIR   ?=     ${PAMDIR:="${SYSCONFDIR}/pam.d"}
  69 CFLAGS   +=     -DVERSION="\"${VERSION}\""
  70 EOF
  71
  72 if [ -z "$BUILD" ]; then
  73         BUILD="$(uname -m)-unknown-$(uname -s | tr '[:upper:]' '[:lower:]')"
  74 fi
  75 if [ -z "$HOST" ]; then
  76         [ -z "$TARGET" ] && TARGET=$BUILD
  77         HOST=$TARGET
  78 fi
  79 if [ -z "$TARGET" ]; then
  80         [ -z "$HOST" ] && HOST=$BUILD
  81         TARGET=$HOST
  82 fi
  83
  84 if [ -z "$OS" ]; then
  85         # Derive OS from cpu-manufacturer-os-kernel
  86         CPU=${TARGET%%-*}
  87         REST=${TARGET#*-}
  88         MANU=${REST%%-*}
  89         REST=${REST#*-}
  90         OS=${REST%%-*}
  91         REST=${REST#*-}
  92         KERNEL=${REST%%-*}
  93 fi
  94
  95 case "$OS" in
  96         linux)
  97                 OS_CFLAGS="-D_DEFAULT_SOURCE -D_GNU_SOURCE -DUID_MAX=60000 -DGID_MAX=60000"
  98                 printf 'CURDIR   :=     .\n' >>$CONFIG_MK
  99                 printf 'PAM_DOAS  =     pam.d__doas__linux\n' >>$CONFIG_MK
 100                 ;;
 101 esac
 102
 103 [ -n "$OS_CFLAGS" ] && \
 104         printf 'CFLAGS   +=     %s\n' "$OS_CFLAGS" >>$CONFIG_MK
 105
 106 [ -n "$DEBUG" ] && \
 107         printf 'CFLAGS   +=     -O0 -g\n' >>$CONFIG_MK
 108
 109 [ -n "$BUILD_STATIC" ] && \
 110         printf 'CFLAGS   +=     -static\n' >>$CONFIG_MK
 111
 112 # Add CPPFLAGS/CFLAGS/LDFLAGS to CC for testing features
 113 XCC="${CC:=clang} $CFLAGS $OS_CFLAGS $CPPFLAGS $LDFLAGS"
 114 # Make sure to disable --as-needed for CC tests.
 115 XCC="$XCC -Wl,--no-as-needed"
 116
 117 check_func() {
 118         func="$1"; src="$2"; shift 2
 119         printf 'Checking for %-14s\t\t' "$func ..."
 120         printf '%s\n' "$src" >"_$func.c"
 121         $XCC "_$func.c" -o "_$func" 2>/dev/null
 122         ret=$?
 123         rm -f "_$func.c" "_$func"
 124         if [ $ret -eq 0 ]; then
 125                 printf 'yes.\n'
 126                 upperfunc="$(printf '%s\n' "$func" | tr '[[:lower:]]' '[[:upper:]]')"
 127                 printf 'CFLAGS   +=     -DHAVE_%s\n' "$upperfunc" >>$CONFIG_MK
 128                 return 0
 129         else
 130                 printf 'no.\n'
 131                 return 1
 132         fi
 133 }
 134
 135 src='
 136 #include <string.h>
 137 int main(void) {
 138         explicit_bzero(NULL, 0);
 139         return 0;
 140 }'
 141 check_func "explicit_bzero" "$src" || {
 142         printf 'OPENBSD  +=     explicit_bzero.c\n' >>$CONFIG_MK
 143 }
 144
 145
 146 #
 147 # Check for strlcat().
 148 #
 149 src='
 150 #include <string.h>
 151 int main(void) {
 152         const char s1[] = "foo";
 153         char s2[10];
 154         strlcat(s2, s1, sizeof(s2));
 155         return 0;
 156 }'
 157 check_func "strlcat" "$src" || {
 158         printf 'OPENBSD  +=     strlcat.c\n' >>$CONFIG_MK
 159 }
 160
 161 #
 162 # Check for strlcpy().
 163 #
 164 src='
 165 #include <string.h>
 166 int main(void) {
 167         const char s1[] = "foo";
 168         char s2[10];
 169         strlcpy(s2, s1, sizeof(s2));
 170         return 0;
 171 }'
 172 check_func "strlcpy" "$src" || {
 173         printf 'OPENBSD  +=     strlcpy.c\n' >>$CONFIG_MK
 174 }
 175
 176 #
 177 # Check for errc().
 178 #
 179 src='
 180 #include <err.h>
 181 int main(void) {
 182         errc(0, 0, "");
 183         return 0;
 184 }'
 185 check_func "errc" "$src" || {
 186         printf 'OPENBSD  +=     errc.c\n' >>$CONFIG_MK
 187 }
 188
 189 #
 190 # Check for verrc().
 191 #
 192 src='
 193 #include <err.h>
 194 int main(void) {
 195         verrc(0, 0, "");
 196         return 0;
 197 }'
 198 check_func "verrc" "$src" || {
 199         printf 'OPENBSD  +=     verrc.c\n' >>$CONFIG_MK
 200 }
 201
 202 #
 203 # Check for setprogname().
 204 #
 205 src='
 206 #include <stdlib.h>
 207 int main(void) {
 208         setprogname("");
 209         return 0;
 210 }'
 211 check_func "setprogname" "$src" || {
 212         printf 'OPENBSD  +=     progname.c\n' >>$CONFIG_MK
 213 }
 214
 215 #
 216 # Check for readpassphrase().
 217 #
 218 src='
 219 #include <readpassphrase.h>
 220 int main(void) {
 221         char buf[12];
 222         readpassphrase("", buf, sizeof(buf), 0);
 223         return 0;
 224 }'
 225 check_func "readpassphrase" "$src" || {
 226         printf 'OPENBSD  +=     readpassphrase.c\n' >>$CONFIG_MK
 227 }
 228
 229 #
 230 # Check for strtonum().
 231 #
 232 src='
 233 #include <stdlib.h>
 234 int main(void) {
 235         const char *errstr;
 236         strtonum("", 1, 64, &errstr);
 237         return 0;
 238 }'
 239 check_func "strtonum" "$src" || {
 240         printf 'OPENBSD  +=     strtonum.c\n' >>$CONFIG_MK
 241 }
 242
 243 #
 244 # Check for reallocarray().
 245 #
 246 src='
 247 #include <stdlib.h>
 248 int main(void) {
 249         reallocarray(NULL, 0, 0);
 250         return 0;
 251 }'
 252 check_func "reallocarray" "$src" || {
 253         printf 'OPENBSD  +=     reallocarray.c\n' >>$CONFIG_MK
 254 }
 255
 256 #
 257 # Check for bsd_auth.h.
 258 #
 259 src='
 260 #include <bsd_auth.h>
 261 int main(void) {
 262         return 0;
 263 }'
 264 check_func "bsd_auth_h" "$src" && \
 265         have_bsd_auth_h=1
 266
 267 #
 268 # Check for pam_appl.h.
 269 #
 270 src='
 271 #include <security/pam_appl.h>
 272 int main(void) {
 273         return 0;
 274 }'
 275 [ -z "$have_bsd_auth_h" ] && \
 276         check_func "pam_appl_h" "$src" && {
 277                 printf 'SRCS     +=     doas_pam.c\n' >>$CONFIG_MK
 278         }
 279
 280 #
 281 # Check for login_cap.h.
 282 #
 283 src='
 284 #include <login_cap.h>
 285 int main(void) {
 286         return 0;
 287 }'
 288 check_func "login_cap_h" "$src" || {
 289         printf 'OPENBSD  +=     setusercontext.c\n' >>$CONFIG_MK
 290 }
 291
 292 #
 293 # Check for execvpe().
 294 #
 295 src='
 296 #include <unistd.h>
 297 int main(void) {
 298         const char *p = { "", NULL };
 299         execvpe("", p, p);
 300         return 0;
 301 }'
 302 check_func "execvpe" "$src" || {
 303         printf 'OPENBSD  +=     execvpe.c\n' >>$CONFIG_MK
 304 }
 305
 306 #
 307 # Check for setresuid().
 308 #
 309 src='
 310 #include <unistd.h>
 311 int main(void) {
 312         setresuid(0, 0, 0);
 313         return 0;
 314 }'
 315 check_func "setresuid" "$src" || {
 316         printf 'OPENBSD  +=     setresuid.c\n' >>$CONFIG_MK
 317 }
 318
 319 #
 320 # Check for pledge().
 321 #
 322 src='
 323 #include <unistd.h>
 324 int main(void) {
 325         pledge("", NULL);
 326         return 0;
 327 }'
 328 check_func "pledge" "$src" && {
 329         have_pledge=1
 330 }
 331
 332 #
 333 # Check for seccomp.h
 334 #
 335 src='
 336 #include <linux/seccomp.h>
 337 #include <sys/prctl.h>
 338 #include <unistd.h>
 339 int main(void) {
 340         prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, NULL);
 341         return 0;
 342 }'
 343 [ -z "$have_pledge" -a -n "$BUILD_SECCOMP" ] && \
 344         check_func "seccomp_h" "$src" && \
 345         {
 346                 have_pledge=1
 347                 printf 'OPENBSD  +=     pledge-seccomp.c\n' >>$CONFIG_MK
 348         }
 349
 350 [ -z "$have_pledge" ] && \
 351         printf 'OPENBSD  +=     pledge-noop.c\n' >>$CONFIG_MK