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 CONFIG_H=config.h
  76 rm -f "$CONFIG_MK" "$CONFIG_H"
  77
  78 cat <<! >$CONFIG_H
  79 #ifndef CONFIG_H
  80 #define CONFIG_H
  81
  82 !
  83
  84 cat <<EOF >>$CONFIG_MK
  85 PREFIX   ?=     ${PREFIX:="/usr"}
  86 EPREFIX  ?=     ${EPREFIX:="${PREFIX}"}
  87 BINDIR   ?=     ${BINDIR:="${PREFIX}/bin"}
  88 SHAREDIR ?=     ${SHAREDIR:="${PREFIX}/share"}
  89 MANDIR   ?=     ${MANDIR:="${SHAREDIR}/man"}
  90 SYSCONFDIR?=    ${SYSCONFDIR:="/etc"}
  91 PAMDIR   ?=     ${PAMDIR:="${SYSCONFDIR}/pam.d"}
  92 EOF
  93
  94 if [ -z "$BUILD" ]; then
  95         BUILD="$(uname -m)-unknown-$(uname -s | tr '[:upper:]' '[:lower:]')"
  96 fi
  97 if [ -z "$HOST" ]; then
  98         [ -z "$TARGET" ] && TARGET=$BUILD
  99         HOST=$TARGET
 100 fi
 101 if [ -z "$TARGET" ]; then
 102         [ -z "$HOST" ] && HOST=$BUILD
 103         TARGET=$HOST
 104 fi
 105
 106 if [ -z "$OS" ]; then
 107         # Derive OS from cpu-manufacturer-os-kernel
 108         CPU=${TARGET%%-*}
 109         REST=${TARGET#*-}
 110         MANU=${REST%%-*}
 111         REST=${REST#*-}
 112         OS=${REST%%-*}
 113         REST=${REST#*-}
 114         KERNEL=${REST%%-*}
 115 fi
 116
 117 OS_CFLAGS="-D__${OS}__"
 118
 119 case "$OS" in
 120         linux)
 121                 printf 'Setting UID_MAX\t\t\t\t%d.\n' "$UID_MAX" >&2
 122                 printf '#define UID_MAX %s\n' "$UID_MAX" >>$CONFIG_H
 123                 printf 'Setting GID_MAX\t\t\t\t%d.\n' "$GID_MAX" >&2
 124                 printf '#define GID_MAX %s\n' "$GID_MAX" >>$CONFIG_H
 125                 OS_CFLAGS="$OS_CFLAGS -D_DEFAULT_SOURCE -D_GNU_SOURCE"
 126                 printf 'CURDIR   :=     .\n' >>$CONFIG_MK
 127                 ;;
 128 esac
 129
 130 [ -n "$OS_CFLAGS" ] && \
 131         printf 'CFLAGS   +=     %s\n' "$OS_CFLAGS" >>$CONFIG_MK
 132
 133 [ -n "$DEBUG" ] && \
 134         printf 'CFLAGS   +=     -O0 -g\n' >>$CONFIG_MK
 135
 136 [ -n "$BUILD_STATIC" ] && \
 137         printf 'CFLAGS   +=     -static\n' >>$CONFIG_MK
 138
 139 # Add CPPFLAGS/CFLAGS/LDFLAGS to CC for testing features
 140 XCC="${CC:=cc} $CFLAGS $OS_CFLAGS $CPPFLAGS $LDFLAGS"
 141 # Make sure to disable --as-needed for CC tests.
 142 XCC="$XCC -Wl,--no-as-needed"
 143
 144 check_func() {
 145         func="$1"; src="$2"; shift 2
 146         printf 'Checking for %-14s\t\t' "$func ..." >&2
 147         printf '%s\n' "$src" >"_$func.c"
 148         $XCC "_$func.c" -o "_$func" 2>/dev/null
 149         ret=$?
 150         rm -f "_$func.c" "_$func"
 151         upperfunc="$(printf '%s\n' "$func" | tr '[[:lower:]]' '[[:upper:]]')"
 152         if [ $ret -eq 0 ]; then
 153                 printf 'yes.\n' >&2
 154                 printf '#define HAVE_%s\n' "$upperfunc" >>$CONFIG_H
 155                 return 0
 156         else
 157                 printf '/* #define HAVE_%s */\n' "$upperfunc" >>$CONFIG_H
 158                 printf 'no.\n' >&2
 159                 return 1
 160         fi
 161 }
 162
 163 authmethod() {
 164         #
 165         # Check for pam_appl.h.
 166         #
 167         src='
 168 #include <security/pam_appl.h>
 169 int main(void) {
 170         return 0;
 171 }'
 172         [ -z "$WITHOUT_PAM" ] && check_func "pam_appl_h" "$src" && {
 173                 printf 'SRCS     +=     pam.c\n' >>$CONFIG_MK
 174                 printf 'LDFLAGS  +=     -lpam\n' >>$CONFIG_MK
 175                 printf '#define USE_PAM\n' >>$CONFIG_H
 176                 printf 'pam\n'
 177
 178                 pam_file="pam.d__doas__${OS}"
 179                 [ -e "$pam_file" ] && printf 'PAM_DOAS  =       %s\n' "$pam_file" >>$CONFIG_MK
 180                 return 0
 181         }
 182
 183         #
 184         # Check for shadow.h.
 185         #
 186         src='
 187 #include <shadow.h>
 188 int main(void) {
 189         return 0;
 190 }'
 191         [ -z "$WITHOUT_SHADOW" ] && check_func "shadow_h" "$src" && {
 192                 printf 'SRCS     +=     shadow.c\n' >>$CONFIG_MK
 193                 printf 'LDFLAGS  +=     -lcrypt\n' >>$CONFIG_MK
 194                 printf '#define USE_SHADOW\n' >>$CONFIG_H
 195                 printf 'shadow\n'
 196                 return 0
 197         }
 198
 199         return 1
 200 }
 201
 202 persistmethod() {
 203         [ -z "$WITHOUT_TIMESTAMP" ] && {
 204                 printf '#define USE_TIMESTAMP\n' >>$CONFIG_H
 205                 printf 'SRCS    += timestamp.c\n' >>$CONFIG_MK
 206                 printf 'timestamp\n'
 207                 return 0
 208         }
 209         return 1
 210 }
 211
 212 #
 213 # Check for explicit_bzero().
 214 #
 215 src='
 216 #include <string.h>
 217 int main(void) {
 218         explicit_bzero(NULL, 0);
 219         return 0;
 220 }'
 221 check_func "explicit_bzero" "$src" || {
 222         printf 'SRCS += libopenbsd/explicit_bzero.c\n' >>$CONFIG_MK
 223 }
 224
 225 #
 226 # Check for strlcat().
 227 #
 228 src='
 229 #include <string.h>
 230 int main(void) {
 231         const char s1[] = "foo";
 232         char s2[10];
 233         strlcat(s2, s1, sizeof(s2));
 234         return 0;
 235 }'
 236 check_func "strlcat" "$src" || {
 237         printf 'SRCS += libopenbsd/strlcat.c\n' >>$CONFIG_MK
 238 }
 239
 240 #
 241 # Check for strlcpy().
 242 #
 243 src='
 244 #include <string.h>
 245 int main(void) {
 246         const char s1[] = "foo";
 247         char s2[10];
 248         strlcpy(s2, s1, sizeof(s2));
 249         return 0;
 250 }'
 251 check_func "strlcpy" "$src" || {
 252         printf 'SRCS += libopenbsd/strlcpy.c\n' >>$CONFIG_MK
 253 }
 254
 255 #
 256 # Check for errc().
 257 #
 258 src='
 259 #include <err.h>
 260 int main(void) {
 261         errc(0, 0, "");
 262         return 0;
 263 }'
 264 check_func "errc" "$src" || {
 265         printf 'SRCS += libopenbsd/errc.c\n' >>$CONFIG_MK
 266 }
 267
 268 #
 269 # Check for verrc().
 270 #
 271 src='
 272 #include <err.h>
 273 int main(void) {
 274         verrc(0, 0, "");
 275         return 0;
 276 }'
 277 check_func "verrc" "$src" || {
 278         printf 'SRCS += libopenbsd/verrc.c\n' >>$CONFIG_MK
 279 }
 280
 281 #
 282 # Check for setprogname().
 283 #
 284 src='
 285 #include <stdlib.h>
 286 int main(void) {
 287         setprogname("");
 288         return 0;
 289 }'
 290 check_func "setprogname" "$src" || {
 291         printf 'SRCS += libopenbsd/progname.c\n' >>$CONFIG_MK
 292 }
 293
 294 #
 295 # Check for readpassphrase().
 296 #
 297 src='
 298 #include <readpassphrase.h>
 299 int main(void) {
 300         char buf[12];
 301         readpassphrase("", buf, sizeof(buf), 0);
 302         return 0;
 303 }'
 304 check_func "readpassphrase" "$src" || {
 305         printf 'SRCS += libopenbsd/readpassphrase.c\n' >>$CONFIG_MK
 306 }
 307
 308 #
 309 # Check for strtonum().
 310 #
 311 src='
 312 #include <stdlib.h>
 313 int main(void) {
 314         const char *errstr;
 315         strtonum("", 1, 64, &errstr);
 316         return 0;
 317 }'
 318 check_func "strtonum" "$src" || {
 319         printf 'SRCS += libopenbsd/strtonum.c\n' >>$CONFIG_MK
 320 }
 321
 322 #
 323 # Check for reallocarray().
 324 #
 325 src='
 326 #include <stdlib.h>
 327 int main(void) {
 328         reallocarray(NULL, 0, 0);
 329         return 0;
 330 }'
 331 check_func "reallocarray" "$src" || {
 332         printf 'SRCS += libopenbsd/reallocarray.c\n' >>$CONFIG_MK
 333 }
 334
 335 #
 336 # Check for execvpe().
 337 #
 338 src='
 339 #include <unistd.h>
 340 int main(void) {
 341         const char *p = { "", NULL };
 342         execvpe("", p, p);
 343         return 0;
 344 }'
 345 check_func "execvpe" "$src" || die "system has no execvpe(3): not supported"
 346
 347 #
 348 # Check for setresuid().
 349 #
 350 src='
 351 #include <unistd.h>
 352 int main(void) {
 353         setresuid(0, 0, 0);
 354         return 0;
 355 }'
 356 check_func "setresuid" "$src" || {
 357         printf 'SRCS += libopenbsd/bsd-setres_id.c\n' >>$CONFIG_MK
 358 }
 359
 360 #
 361 # Check for closefrom().
 362 #
 363 src='
 364 #include <unistd.h>
 365 int main(void) {
 366         closefrom(0);
 367         return 0;
 368 }'
 369 check_func "closefrom" "$src" || {
 370         printf 'SRCS += libopenbsd/closefrom.c\n' >>$CONFIG_MK
 371 }
 372
 373 #
 374 # Check for sysconf().
 375 #
 376 src='
 377 #include <unistd.h>
 378 int main(void) {
 379         (void)sysconf(0);
 380         return 0;
 381 }'
 382 check_func "sysconf" "$src"
 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 # Check for login_cap.h.
 460 #
 461 src='
 462 #include <sys/types.h>
 463 #include <login_cap.h>
 464 int main(void) {
 465         return 0;
 466 }'
 467 check_func "login_cap_h" "$src"
 468
 469 #
 470 #
 471 #
 472 src='
 473 #include <stdlib.h>
 474 int main(void){return 0;}
 475 __attribute__((__unused__)) static void foo(void){return;}
 476 '
 477 check_func "__attribute__" "$src" || {
 478         printf 'CFLAGS  +=      -DNO_ATTRIBUTE_ON_RETURN_TYPE=1\n' >>$CONFIG_MK
 479 }
 480
 481 auth=$(authmethod)
 482 if [ $? -eq 0 ]; then
 483         printf 'Using auth method\t\t\t%s.\n' "$auth" >&2
 484 else
 485         printf 'Error auth method\t\t\n' >&2
 486         exit 1
 487 fi
 488
 489 persist=$(persistmethod)
 490 if [ $? -eq 0 ]; then
 491         printf 'Using persist method\t\t\t%s.\n' "$persist" >&2
 492 else
 493         printf 'Using persist method\t\t\tnone.\n' >&2
 494 fi
 495
 496 printf '#define DOAS_CONF "%s/doas.conf"\n' "${SYSCONFDIR}" >>$CONFIG_H
 497
 498 printf '\n#endif /* CONFIG_H */\n' >>$CONFIG_H