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]
  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-static        prepare for static build
  26
  27   --without-pam          disable pam support
  28   --without-shadow       disable shadow support
  29
  30   --without-timestamp    disable timestamp support
  31
  32   --help, -h             display this help and exit
  33 EOF
  34         exit 0
  35 }
  36
  37 # defaults
  38 WITHOUT_TIMESTAMP=yes
  39
  40 for x; do
  41         opt=${x%%=*}
  42         var=${x#*=}
  43         case "$opt" in
  44         --prefix) PREFIX=$var ;;
  45         --exec-prefix) EPREFIX=$var ;;
  46         --bindir) BINDIR=$var ;;
  47         --datadir) SHAREDIR=$var ;;
  48         --mandir) MANDIR=$var ;;
  49         --sysconfdir) SYSCONFDIR=$var ;;
  50         --pamdir) PAMDIR=$var ;;
  51         --build) BUILD=$var ;;
  52         --host) HOST=$var ;;
  53         --target) TARGET=$var ;;
  54         --enable-debug) DEBUG=yes ;;
  55         --enable-static) BUILD_STATIC=yes ;;
  56         --with-pam) WITHOUT_PAM=; WITHOUT_SHADOW=yes ;;
  57         --with-shadow) WITHOUT_SHADOW=; WITHOUT_PAM=yes ;;
  58         --without-pam) WITHOUT_PAM=yes ;;
  59         --without-shadow) WITHOUT_SHADOW=yes ;;
  60         --with-timestamp) WITHOUT_TIMESTAMP= ;;
  61         --without-timestamp) WITHOUT_TIMESTAMP=yes ;;
  62         --help|-h) usage ;;
  63         *) die "Error: unknown option $opt" ;;
  64         esac
  65 done
  66
  67 CONFIG_MK=config.mk
  68 rm -f "$CONFIG_MK"
  69
  70 # : ${VERSION:="$(git describe --dirty --tags --long --always)"}
  71 : ${VERSION:="6.2"}
  72
  73 cat <<EOF >>$CONFIG_MK
  74 PREFIX   ?=     ${PREFIX:="/usr"}
  75 EPREFIX  ?=     ${EPREFIX:="${PREFIX}"}
  76 BINDIR   ?=     ${BINDIR:="${PREFIX}/bin"}
  77 SHAREDIR ?=     ${SHAREDIR:="${PREFIX}/share"}
  78 MANDIR   ?=     ${MANDIR:="${SHAREDIR}/man"}
  79 SYSCONFDIR?=    ${SYSCONFDIR:="/etc"}
  80 PAMDIR   ?=     ${PAMDIR:="${SYSCONFDIR}/pam.d"}
  81 CFLAGS   +=     -DVERSION="\"${VERSION}\""
  82 EOF
  83
  84 if [ -z "$BUILD" ]; then
  85         BUILD="$(uname -m)-unknown-$(uname -s | tr '[:upper:]' '[:lower:]')"
  86 fi
  87 if [ -z "$HOST" ]; then
  88         [ -z "$TARGET" ] && TARGET=$BUILD
  89         HOST=$TARGET
  90 fi
  91 if [ -z "$TARGET" ]; then
  92         [ -z "$HOST" ] && HOST=$BUILD
  93         TARGET=$HOST
  94 fi
  95
  96 if [ -z "$OS" ]; then
  97         # Derive OS from cpu-manufacturer-os-kernel
  98         CPU=${TARGET%%-*}
  99         REST=${TARGET#*-}
 100         MANU=${REST%%-*}
 101         REST=${REST#*-}
 102         OS=${REST%%-*}
 103         REST=${REST#*-}
 104         KERNEL=${REST%%-*}
 105 fi
 106
 107 OS_CFLAGS="-D__${OS}__"
 108
 109 case "$OS" in
 110         linux)
 111                 OS_CFLAGS="$OS_CFLAGS -D_DEFAULT_SOURCE -D_GNU_SOURCE -DUID_MAX=60000 -DGID_MAX=60000"
 112                 printf 'CURDIR   :=     .\n' >>$CONFIG_MK
 113                 [ -z "$WITHOUT_PAM" ] && \
 114                         printf 'PAM_DOAS  =     pam.d__doas__linux\n' >>$CONFIG_MK
 115                 ;;
 116 esac
 117
 118 [ -n "$OS_CFLAGS" ] && \
 119         printf 'CFLAGS   +=     %s\n' "$OS_CFLAGS" >>$CONFIG_MK
 120
 121 [ -n "$DEBUG" ] && \
 122         printf 'CFLAGS   +=     -O0 -g\n' >>$CONFIG_MK
 123
 124 [ -n "$BUILD_STATIC" ] && \
 125         printf 'CFLAGS   +=     -static\n' >>$CONFIG_MK
 126
 127 # Add CPPFLAGS/CFLAGS/LDFLAGS to CC for testing features
 128 XCC="${CC:=cc} $CFLAGS $OS_CFLAGS $CPPFLAGS $LDFLAGS"
 129 # Make sure to disable --as-needed for CC tests.
 130 XCC="$XCC -Wl,--no-as-needed"
 131
 132 check_func() {
 133         func="$1"; src="$2"; shift 2
 134         printf 'Checking for %-14s\t\t' "$func ..." >&2
 135         printf '%s\n' "$src" >"_$func.c"
 136         $XCC "_$func.c" -o "_$func" 2>/dev/null
 137         ret=$?
 138         rm -f "_$func.c" "_$func"
 139         if [ $ret -eq 0 ]; then
 140                 printf 'yes.\n' >&2
 141                 upperfunc="$(printf '%s\n' "$func" | tr '[[:lower:]]' '[[:upper:]]')"
 142                 printf 'CFLAGS   +=     -DHAVE_%s\n' "$upperfunc" >>$CONFIG_MK
 143                 return 0
 144         else
 145                 printf 'no.\n' >&2
 146                 return 1
 147         fi
 148 }
 149
 150 authmethod() {
 151         #
 152         # Check for bsd_auth.h.
 153         #
 154         src='
 155 #include <bsd_auth.h>
 156 int main(void) {
 157         return 0;
 158 }'
 159         check_func "bsd_auth_h" "$src" && {
 160                 have_bsd_auth_h=1
 161                 printf 'bsd\n'
 162                 return 0
 163         }
 164
 165         #
 166         # Check for pam_appl.h.
 167         #
 168         src='
 169 #include <security/pam_appl.h>
 170 int main(void) {
 171         return 0;
 172 }'
 173         [ -z "$WITHOUT_PAM" ] && check_func "pam_appl_h" "$src" && {
 174                 printf 'SRCS     +=     pam.c\n' >>$CONFIG_MK
 175                 printf 'LDFLAGS  +=     -lpam\n' >>$CONFIG_MK
 176                 printf 'pam\n'
 177                 return 0
 178         }
 179
 180         #
 181         # Check for shadow.h.
 182         #
 183         src='
 184 #include <shadow.h>
 185 int main(void) {
 186         return 0;
 187 }'
 188         [ -z "$WITHOUT_SHADOW" ] && check_func "shadow_h" "$src" && {
 189                 printf 'LDFLAGS  +=     -lcrypt\n' >>$CONFIG_MK
 190                 printf 'shadow\n'
 191                 return 0
 192         }
 193
 194         return 1
 195 }
 196
 197 persistmethod() {
 198         [ -z "$WITHOUT_TIMESTAMP" ] && {
 199                 printf 'CFLAGS  += -DPERSIST_TIMESTAMP\n' >>$CONFIG_MK
 200                 printf 'SRCS    += persist_timestamp.c\n' >>$CONFIG_MK
 201                 printf 'timestamp\n'
 202                 return 0
 203         }
 204         return 1
 205 }
 206
 207 #
 208 # Check for explicit_bzero().
 209 #
 210 src='
 211 #include <string.h>
 212 int main(void) {
 213         explicit_bzero(NULL, 0);
 214         return 0;
 215 }'
 216 check_func "explicit_bzero" "$src" || {
 217         printf 'OPENBSD  +=     explicit_bzero.o\n' >>$CONFIG_MK
 218 }
 219
 220 #
 221 # Check for strlcat().
 222 #
 223 src='
 224 #include <string.h>
 225 int main(void) {
 226         const char s1[] = "foo";
 227         char s2[10];
 228         strlcat(s2, s1, sizeof(s2));
 229         return 0;
 230 }'
 231 check_func "strlcat" "$src" || {
 232         printf 'OPENBSD  +=     strlcat.o\n' >>$CONFIG_MK
 233 }
 234
 235 #
 236 # Check for strlcpy().
 237 #
 238 src='
 239 #include <string.h>
 240 int main(void) {
 241         const char s1[] = "foo";
 242         char s2[10];
 243         strlcpy(s2, s1, sizeof(s2));
 244         return 0;
 245 }'
 246 check_func "strlcpy" "$src" || {
 247         printf 'OPENBSD  +=     strlcpy.o\n' >>$CONFIG_MK
 248 }
 249
 250 #
 251 # Check for errc().
 252 #
 253 src='
 254 #include <err.h>
 255 int main(void) {
 256         errc(0, 0, "");
 257         return 0;
 258 }'
 259 check_func "errc" "$src" || {
 260         printf 'OPENBSD  +=     errc.o\n' >>$CONFIG_MK
 261 }
 262
 263 #
 264 # Check for verrc().
 265 #
 266 src='
 267 #include <err.h>
 268 int main(void) {
 269         verrc(0, 0, "");
 270         return 0;
 271 }'
 272 check_func "verrc" "$src" || {
 273         printf 'OPENBSD  +=     verrc.o\n' >>$CONFIG_MK
 274 }
 275
 276 #
 277 # Check for setprogname().
 278 #
 279 src='
 280 #include <stdlib.h>
 281 int main(void) {
 282         setprogname("");
 283         return 0;
 284 }'
 285 check_func "setprogname" "$src" || {
 286         printf 'OPENBSD  +=     progname.o\n' >>$CONFIG_MK
 287 }
 288
 289 #
 290 # Check for readpassphrase().
 291 #
 292 src='
 293 #include <readpassphrase.h>
 294 int main(void) {
 295         char buf[12];
 296         readpassphrase("", buf, sizeof(buf), 0);
 297         return 0;
 298 }'
 299 check_func "readpassphrase" "$src" || {
 300         printf 'OPENBSD  +=     readpassphrase.o\n' >>$CONFIG_MK
 301 }
 302
 303 #
 304 # Check for strtonum().
 305 #
 306 src='
 307 #include <stdlib.h>
 308 int main(void) {
 309         const char *errstr;
 310         strtonum("", 1, 64, &errstr);
 311         return 0;
 312 }'
 313 check_func "strtonum" "$src" || {
 314         printf 'OPENBSD  +=     strtonum.o\n' >>$CONFIG_MK
 315 }
 316
 317 #
 318 # Check for reallocarray().
 319 #
 320 src='
 321 #include <stdlib.h>
 322 int main(void) {
 323         reallocarray(NULL, 0, 0);
 324         return 0;
 325 }'
 326 check_func "reallocarray" "$src" || {
 327         printf 'OPENBSD  +=     reallocarray.o\n' >>$CONFIG_MK
 328 }
 329
 330 #
 331 # Check for execvpe().
 332 #
 333 src='
 334 #include <unistd.h>
 335 int main(void) {
 336         const char *p = { "", NULL };
 337         execvpe("", p, p);
 338         return 0;
 339 }'
 340 check_func "execvpe" "$src" || {
 341         printf 'OPENBSD  +=     execvpe.o\n' >>$CONFIG_MK
 342 }
 343
 344 #
 345 # Check for setresuid().
 346 #
 347 src='
 348 #include <unistd.h>
 349 int main(void) {
 350         setresuid(0, 0, 0);
 351         return 0;
 352 }'
 353 check_func "setresuid" "$src" || {
 354         printf 'OPENBSD  +=     setresuid.o\n' >>$CONFIG_MK
 355 }
 356
 357 #
 358 # Check for pledge().
 359 #
 360 src='
 361 #include <unistd.h>
 362 int main(void) {
 363         pledge("", NULL);
 364         return 0;
 365 }'
 366 check_func "pledge" "$src" || {
 367         printf 'OPENBSD  +=     pledge-noop.o\n' >>$CONFIG_MK
 368 }
 369
 370 #
 371 # Check for closefrom().
 372 #
 373 src='
 374 #include <unistd.h>
 375 int main(void) {
 376         closefrom(0);
 377         return 0;
 378 }'
 379 check_func "closefrom" "$src" || {
 380         printf 'OPENBSD  +=     closefrom.o\n' >>$CONFIG_MK
 381 }
 382
 383 #
 384 # Check for sysconf().
 385 #
 386 src='
 387 #include <unistd.h>
 388 int main(void) {
 389         (void)sysconf(0);
 390         return 0;
 391 }'
 392 check_func "sysconf" "$src"
 393
 394 #
 395 # Check for /proc/$PID.
 396 #
 397 printf 'Checking for %-14s\t\t' "/proc/\$PID ..." >&2
 398 if test -d /proc/$$; then
 399         printf 'yes.\n' >&2
 400         printf 'CFLAGS   +=     -DHAVE_%s\n' "PROC_PID" >>$CONFIG_MK
 401 else
 402         printf 'no.\n' >&2
 403 fi
 404
 405 #
 406 # Check for dirfd().
 407 #
 408 src='
 409 #include <dirent.h>
 410 int main(void) {
 411         (void)dirfd(0);
 412         return 0;
 413 }'
 414 check_func "dirfd" "$src"
 415
 416 #
 417 # Check for fcntl.h.
 418 #
 419 src='
 420 #include <fcntl.h>
 421 int main(void) {
 422         return 0;
 423 }'
 424 check_func "fcntl_h" "$src"
 425
 426 #
 427 # Check for F_CLOSEM.
 428 #
 429 src='
 430 #include <fcntl.h>
 431 #ifndef F_CLOSEM
 432 #error no F_CLOSEM
 433 #endif
 434 int main(void) {
 435         return 0;
 436 }'
 437 check_func "F_CLOSEM" "$src"
 438
 439 #
 440 # Check for dirent.h.
 441 #
 442 src='
 443 #include <dirent.h>
 444 int main(void) {
 445         return 0;
 446 }'
 447 check_func "dirent_h" "$src"
 448
 449 #
 450 # Check for sys/ndir.h.
 451 #
 452 src='
 453 #include <sys/ndir.h>
 454 int main(void) {
 455         return 0;
 456 }'
 457 check_func "sys_ndir_h" "$src"
 458
 459 #
 460 # Check for sys/dir.h.
 461 #
 462 src='
 463 #include <sys/dir.h>
 464 int main(void) {
 465         return 0;
 466 }'
 467 check_func "sys_dir_h" "$src"
 468
 469 #
 470 # Check for ndir.h.
 471 #
 472 src='
 473 #include <ndir.h>
 474 int main(void) {
 475         return 0;
 476 }'
 477 check_func "ndir_h" "$src"
 478
 479 #
 480 #
 481 #
 482 src='
 483 #include <stdlib.h>
 484 int main(void){return 0;}
 485 __attribute__((__unused__)) static void foo(void){return;}
 486 '
 487 check_func "__attribute__" "$src" || {
 488         printf 'CFLAGS  +=      -DNO_ATTRIBUTE_ON_RETURN_TYPE=1\n' >>$CONFIG_MK
 489 }
 490
 491 auth=$(authmethod)
 492 if [ $? -eq 0 ]; then
 493         printf 'Using auth method\t\t\t%s.\n' "$auth" >&2
 494 else
 495         printf 'Error auth method\t\t\n' >&2
 496         exit 1
 497 fi
 498
 499 persist=$(persistmethod)
 500 if [ $? -eq 0 ]; then
 501         printf 'Using persist method\t\t\t%s.\n' "$persist" >&2
 502 else
 503         printf 'Using persist method\t\t\tnone.\n' >&2
 504 fi