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