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