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         netbsd)
 129                 OS_CFLAGS="$OS_CFLAGS -D_OPENBSD_SOURCE"
 130                 ;;
 131 esac
 132
 133 [ -n "$OS_CFLAGS" ] && \
 134         printf 'CFLAGS   +=     %s\n' "$OS_CFLAGS" >>$CONFIG_MK
 135
 136 [ -n "$DEBUG" ] && \
 137         printf 'CFLAGS   +=     -O0 -g\n' >>$CONFIG_MK
 138
 139 [ -n "$BUILD_STATIC" ] && \
 140         printf 'CFLAGS   +=     -static\n' >>$CONFIG_MK
 141
 142 # Add CPPFLAGS/CFLAGS/LDFLAGS to CC for testing features
 143 XCC="${CC:=cc} $CFLAGS $OS_CFLAGS $CPPFLAGS $LDFLAGS"
 144 # Make sure to disable --as-needed for CC tests.
 145 XCC="$XCC -Wl,--no-as-needed"
 146
 147 check_func() {
 148         func="$1"; src="$2"; shift 2
 149         printf 'Checking for %-14s\t\t' "$func ..." >&2
 150         printf '%s\n' "$src" >"_$func.c"
 151         $XCC "_$func.c" -o "_$func" 2>/dev/null
 152         ret=$?
 153         rm -f "_$func.c" "_$func"
 154         upperfunc="$(printf '%s\n' "$func" | tr '[[:lower:]]' '[[:upper:]]')"
 155         if [ $ret -eq 0 ]; then
 156                 printf 'yes.\n' >&2
 157                 printf '#define HAVE_%s\n' "$upperfunc" >>$CONFIG_H
 158                 return 0
 159         else
 160                 printf '/* #define HAVE_%s */\n' "$upperfunc" >>$CONFIG_H
 161                 printf 'no.\n' >&2
 162                 return 1
 163         fi
 164 }
 165
 166 authmethod() {
 167         #
 168         # Check for pam_appl.h.
 169         #
 170         src='
 171 #include <security/pam_appl.h>
 172 int main(void) {
 173         return 0;
 174 }'
 175         [ -z "$WITHOUT_PAM" ] && check_func "pam_appl_h" "$src" && {
 176                 printf 'SRCS     +=     pam.c\n' >>$CONFIG_MK
 177                 printf 'LDFLAGS  +=     -lpam\n' >>$CONFIG_MK
 178                 printf '#define USE_PAM\n' >>$CONFIG_H
 179                 printf 'pam\n'
 180
 181                 pam_file="pam.d__doas__${OS}"
 182                 [ -e "$pam_file" ] && printf 'PAM_DOAS  =       %s\n' "$pam_file" >>$CONFIG_MK
 183                 return 0
 184         }
 185
 186         #
 187         # Check for shadow.h.
 188         #
 189         src='
 190 #include <shadow.h>
 191 int main(void) {
 192         return 0;
 193 }'
 194         [ -z "$WITHOUT_SHADOW" ] && check_func "shadow_h" "$src" && {
 195                 printf 'SRCS     +=     shadow.c\n' >>$CONFIG_MK
 196                 printf 'LDFLAGS  +=     -lcrypt\n' >>$CONFIG_MK
 197                 printf '#define USE_SHADOW\n' >>$CONFIG_H
 198                 printf 'shadow\n'
 199                 return 0
 200         }
 201
 202         return 1
 203 }
 204
 205 persistmethod() {
 206         [ -z "$WITHOUT_TIMESTAMP" ] && {
 207                 printf '#define USE_TIMESTAMP\n' >>$CONFIG_H
 208                 printf 'SRCS    += timestamp.c\n' >>$CONFIG_MK
 209                 printf 'timestamp\n'
 210                 return 0
 211         }
 212         return 1
 213 }
 214
 215 #
 216 # Check for explicit_bzero().
 217 #
 218 src='
 219 #include <string.h>
 220 int main(void) {
 221         explicit_bzero(NULL, 0);
 222         return 0;
 223 }'
 224 check_func "explicit_bzero" "$src" || {
 225         printf 'SRCS += libopenbsd/explicit_bzero.c\n' >>$CONFIG_MK
 226 }
 227
 228 #
 229 # Check for strlcat().
 230 #
 231 src='
 232 #include <string.h>
 233 int main(void) {
 234         const char s1[] = "foo";
 235         char s2[10];
 236         strlcat(s2, s1, sizeof(s2));
 237         return 0;
 238 }'
 239 check_func "strlcat" "$src" || {
 240         printf 'SRCS += libopenbsd/strlcat.c\n' >>$CONFIG_MK
 241 }
 242
 243 #
 244 # Check for strlcpy().
 245 #
 246 src='
 247 #include <string.h>
 248 int main(void) {
 249         const char s1[] = "foo";
 250         char s2[10];
 251         strlcpy(s2, s1, sizeof(s2));
 252         return 0;
 253 }'
 254 check_func "strlcpy" "$src" || {
 255         printf 'SRCS += libopenbsd/strlcpy.c\n' >>$CONFIG_MK
 256 }
 257
 258 #
 259 # Check for errc().
 260 #
 261 src='
 262 #include <err.h>
 263 int main(void) {
 264         errc(0, 0, "");
 265         return 0;
 266 }'
 267 check_func "errc" "$src" || {
 268         printf 'SRCS += libopenbsd/errc.c\n' >>$CONFIG_MK
 269 }
 270
 271 #
 272 # Check for verrc().
 273 #
 274 src='
 275 #include <err.h>
 276 int main(void) {
 277         verrc(0, 0, "");
 278         return 0;
 279 }'
 280 check_func "verrc" "$src" || {
 281         printf 'SRCS += libopenbsd/verrc.c\n' >>$CONFIG_MK
 282 }
 283
 284 #
 285 # Check for setprogname().
 286 #
 287 src='
 288 #include <stdlib.h>
 289 int main(void) {
 290         setprogname("");
 291         return 0;
 292 }'
 293 check_func "setprogname" "$src" || {
 294         printf 'SRCS += libopenbsd/progname.c\n' >>$CONFIG_MK
 295 }
 296
 297 #
 298 # Check for readpassphrase().
 299 #
 300 src='
 301 #include <readpassphrase.h>
 302 int main(void) {
 303         char buf[12];
 304         readpassphrase("", buf, sizeof(buf), 0);
 305         return 0;
 306 }'
 307 check_func "readpassphrase" "$src" || {
 308         printf 'SRCS += libopenbsd/readpassphrase.c\n' >>$CONFIG_MK
 309 }
 310
 311 #
 312 # Check for strtonum().
 313 #
 314 src='
 315 #include <stdlib.h>
 316 int main(void) {
 317         const char *errstr;
 318         strtonum("", 1, 64, &errstr);
 319         return 0;
 320 }'
 321 check_func "strtonum" "$src" || {
 322         printf 'SRCS += libopenbsd/strtonum.c\n' >>$CONFIG_MK
 323 }
 324
 325 #
 326 # Check for reallocarray().
 327 #
 328 src='
 329 #include <stdlib.h>
 330 int main(void) {
 331         reallocarray(NULL, 0, 0);
 332         return 0;
 333 }'
 334 check_func "reallocarray" "$src" || {
 335         printf 'SRCS += libopenbsd/reallocarray.c\n' >>$CONFIG_MK
 336 }
 337
 338 #
 339 # Check for execvpe().
 340 #
 341 src='
 342 #include <unistd.h>
 343 int main(void) {
 344         const char *p = { "", NULL };
 345         execvpe("", p, p);
 346         return 0;
 347 }'
 348 check_func "execvpe" "$src" || die "system has no execvpe(3): not supported"
 349
 350 #
 351 # Check for setresuid().
 352 #
 353 src='
 354 #include <unistd.h>
 355 int main(void) {
 356         setresuid(0, 0, 0);
 357         return 0;
 358 }'
 359 check_func "setresuid" "$src" || {
 360         printf 'SRCS += libopenbsd/bsd-setres_id.c\n' >>$CONFIG_MK
 361 }
 362
 363 #
 364 # Check for closefrom().
 365 #
 366 src='
 367 #include <unistd.h>
 368 int main(void) {
 369         closefrom(0);
 370         return 0;
 371 }'
 372 check_func "closefrom" "$src" || {
 373         printf 'SRCS += libopenbsd/closefrom.c\n' >>$CONFIG_MK
 374 }
 375
 376 #
 377 # Check for sysconf().
 378 #
 379 src='
 380 #include <unistd.h>
 381 int main(void) {
 382         (void)sysconf(0);
 383         return 0;
 384 }'
 385 check_func "sysconf" "$src"
 386
 387 #
 388 # Check for dirfd().
 389 #
 390 src='
 391 #include <dirent.h>
 392 int main(void) {
 393         (void)dirfd(0);
 394         return 0;
 395 }'
 396 check_func "dirfd" "$src"
 397
 398 #
 399 # Check for fcntl.h.
 400 #
 401 src='
 402 #include <fcntl.h>
 403 int main(void) {
 404         return 0;
 405 }'
 406 check_func "fcntl_h" "$src"
 407
 408 #
 409 # Check for F_CLOSEM.
 410 #
 411 src='
 412 #include <fcntl.h>
 413 #ifndef F_CLOSEM
 414 #error no F_CLOSEM
 415 #endif
 416 int main(void) {
 417         return 0;
 418 }'
 419 check_func "F_CLOSEM" "$src"
 420
 421 #
 422 # Check for dirent.h.
 423 #
 424 src='
 425 #include <dirent.h>
 426 int main(void) {
 427         return 0;
 428 }'
 429 check_func "dirent_h" "$src"
 430
 431 #
 432 # Check for sys/ndir.h.
 433 #
 434 src='
 435 #include <sys/ndir.h>
 436 int main(void) {
 437         return 0;
 438 }'
 439 check_func "sys_ndir_h" "$src"
 440
 441 #
 442 # Check for sys/dir.h.
 443 #
 444 src='
 445 #include <sys/dir.h>
 446 int main(void) {
 447         return 0;
 448 }'
 449 check_func "sys_dir_h" "$src"
 450
 451 #
 452 # Check for ndir.h.
 453 #
 454 src='
 455 #include <ndir.h>
 456 int main(void) {
 457         return 0;
 458 }'
 459 check_func "ndir_h" "$src"
 460
 461 #
 462 # Check for login_cap.h.
 463 #
 464 src='
 465 #include <sys/types.h>
 466 #include <login_cap.h>
 467 int main(void) {
 468         return 0;
 469 }'
 470 check_func "login_cap_h" "$src"
 471
 472 #
 473 #
 474 #
 475 src='
 476 #include <stdlib.h>
 477 int main(void){return 0;}
 478 __attribute__((__unused__)) static void foo(void){return;}
 479 '
 480 check_func "__attribute__" "$src" || {
 481         printf 'CFLAGS  +=      -DNO_ATTRIBUTE_ON_RETURN_TYPE=1\n' >>$CONFIG_MK
 482 }
 483
 484 auth=$(authmethod)
 485 if [ $? -eq 0 ]; then
 486         printf 'Using auth method\t\t\t%s.\n' "$auth" >&2
 487 else
 488         printf 'Error auth method\t\t\n' >&2
 489         exit 1
 490 fi
 491
 492 persist=$(persistmethod)
 493 if [ $? -eq 0 ]; then
 494         printf 'Using persist method\t\t\t%s.\n' "$persist" >&2
 495 else
 496         printf 'Using persist method\t\t\tnone.\n' >&2
 497 fi
 498
 499 printf '#define DOAS_CONF "%s/doas.conf"\n' "${SYSCONFDIR}" >>$CONFIG_H
 500
 501 printf '\n#endif /* CONFIG_H */\n' >>$CONFIG_H