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-seccomp       enable seccomp
  26   --enable-static        prepare for static build
  27
  28   --help, -h             display this help and exit
  29 EOF
  30         exit 0
  31 }
  32
  33 for x; do
  34         opt=${x%%=*}
  35         var=${x#*=}
  36         case "$opt" in
  37         --prefix) PREFIX=$var;;
  38         --exec-prefix) EPREFIX=$var;;
  39         --bindir) BINDIR=$var;;
  40         --datadir) SHAREDIR=$var;;
  41         --mandir) MANDIR=$var;;
  42         --sysconfdir) SYSCONFDIR=$var;;
  43         --pamdir) PAMDIR=$var;;
  44         --build) BUILD=$var;;
  45         --host) HOST=$var;;
  46         --target) TARGET=$var;;
  47         --enable-debug) DEBUG=yes;;
  48         --enable-seccomp) BUILD_SECCOMP=yes;;
  49         --enable-static) BUILD_STATIC=yes;;
  50         --help|-h) usage;;
  51         *) die "Error: unknown option $opt";;
  52         esac
  53 done
  54
  55 CONFIG_MK=config.mk
  56 rm -f "$CONFIG_MK"
  57
  58 : ${VERSION:="$(git describe --dirty --tags --long --always)"}
  59
  60 cat <<EOF >>$CONFIG_MK
  61 PREFIX   ?=     ${PREFIX:="/usr"}
  62 EPREFIX  ?=     ${EPREFIX:="${PREFIX}"}
  63 BINDIR   ?=     ${BINDIR:="${PREFIX}/bin"}
  64 SHAREDIR ?=     ${SHAREDIR:="${PREFIX}/share"}
  65 MANDIR   ?=     ${MANDIR:="${SHAREDIR}/man"}
  66 SYSCONFDIR?=    ${SYSCONFDIR:="/etc"}
  67 PAMDIR   ?=     ${PAMDIR:="${SYSCONFDIR}/pam.d"}
  68 CFLAGS   +=     -DVERSION="\"${VERSION}\""
  69 EOF
  70
  71 if [ -z "$BUILD" ]; then
  72         BUILD="$(uname -m)-unknown-$(uname -s | tr '[:upper:]' '[:lower:]')"
  73 fi
  74 if [ -z "$HOST" ]; then
  75         [ -z "$TARGET" ] && TARGET=$BUILD
  76         HOST=$TARGET
  77 fi
  78 if [ -z "$TARGET" ]; then
  79         [ -z "$HOST" ] && HOST=$BUILD
  80         TARGET=$HOST
  81 fi
  82
  83 if [ -z "$OS" ]; then
  84         # Derive OS from cpu-manufacturer-os-kernel
  85         CPU=${TARGET%%-*}
  86         REST=${TARGET#*-}
  87         MANU=${REST%%-*}
  88         REST=${REST#*-}
  89         OS=${REST%%-*}
  90         REST=${REST#*-}
  91         KERNEL=${REST%%-*}
  92 fi
  93
  94 OS_CFLAGS="-D__${OS}__"
  95
  96 case "$OS" in
  97         linux)
  98                 OS_CFLAGS="$OS_CFLAGS -D_DEFAULT_SOURCE -D_GNU_SOURCE -DUID_MAX=60000 -DGID_MAX=60000"
  99                 printf 'CURDIR   :=     .\n' >>$CONFIG_MK
 100                 printf 'PAM_DOAS  =     pam.d__doas__linux\n' >>$CONFIG_MK
 101                 ;;
 102 esac
 103
 104 [ -n "$OS_CFLAGS" ] && \
 105         printf 'CFLAGS   +=     %s\n' "$OS_CFLAGS" >>$CONFIG_MK
 106
 107 [ -n "$DEBUG" ] && \
 108         printf 'CFLAGS   +=     -O0 -g\n' >>$CONFIG_MK
 109
 110 [ -n "$BUILD_STATIC" ] && \
 111         printf 'CFLAGS   +=     -static\n' >>$CONFIG_MK
 112
 113 # Add CPPFLAGS/CFLAGS/LDFLAGS to CC for testing features
 114 XCC="${CC:=clang} $CFLAGS $OS_CFLAGS $CPPFLAGS $LDFLAGS"
 115 # Make sure to disable --as-needed for CC tests.
 116 XCC="$XCC -Wl,--no-as-needed"
 117
 118 check_func() {
 119         func="$1"; src="$2"; shift 2
 120         printf 'Checking for %-14s\t\t' "$func ..."
 121         printf '%s\n' "$src" >"_$func.c"
 122         $XCC "_$func.c" -o "_$func" 2>/dev/null
 123         ret=$?
 124         rm -f "_$func.c" "_$func"
 125         if [ $ret -eq 0 ]; then
 126                 printf 'yes.\n'
 127                 upperfunc="$(printf '%s\n' "$func" | tr '[[:lower:]]' '[[:upper:]]')"
 128                 printf 'CFLAGS   +=     -DHAVE_%s\n' "$upperfunc" >>$CONFIG_MK
 129                 return 0
 130         else
 131                 printf 'no.\n'
 132                 return 1
 133         fi
 134 }
 135
 136 src='
 137 #include <string.h>
 138 int main(void) {
 139         explicit_bzero(NULL, 0);
 140         return 0;
 141 }'
 142 check_func "explicit_bzero" "$src" || {
 143         printf 'OPENBSD  +=     explicit_bzero.o\n' >>$CONFIG_MK
 144 }
 145
 146
 147 #
 148 # Check for strlcat().
 149 #
 150 src='
 151 #include <string.h>
 152 int main(void) {
 153         const char s1[] = "foo";
 154         char s2[10];
 155         strlcat(s2, s1, sizeof(s2));
 156         return 0;
 157 }'
 158 check_func "strlcat" "$src" || {
 159         printf 'OPENBSD  +=     strlcat.o\n' >>$CONFIG_MK
 160 }
 161
 162 #
 163 # Check for strlcpy().
 164 #
 165 src='
 166 #include <string.h>
 167 int main(void) {
 168         const char s1[] = "foo";
 169         char s2[10];
 170         strlcpy(s2, s1, sizeof(s2));
 171         return 0;
 172 }'
 173 check_func "strlcpy" "$src" || {
 174         printf 'OPENBSD  +=     strlcpy.o\n' >>$CONFIG_MK
 175 }
 176
 177 #
 178 # Check for errc().
 179 #
 180 src='
 181 #include <err.h>
 182 int main(void) {
 183         errc(0, 0, "");
 184         return 0;
 185 }'
 186 check_func "errc" "$src" || {
 187         printf 'OPENBSD  +=     errc.o\n' >>$CONFIG_MK
 188 }
 189
 190 #
 191 # Check for verrc().
 192 #
 193 src='
 194 #include <err.h>
 195 int main(void) {
 196         verrc(0, 0, "");
 197         return 0;
 198 }'
 199 check_func "verrc" "$src" || {
 200         printf 'OPENBSD  +=     verrc.o\n' >>$CONFIG_MK
 201 }
 202
 203 #
 204 # Check for setprogname().
 205 #
 206 src='
 207 #include <stdlib.h>
 208 int main(void) {
 209         setprogname("");
 210         return 0;
 211 }'
 212 check_func "setprogname" "$src" || {
 213         printf 'OPENBSD  +=     progname.o\n' >>$CONFIG_MK
 214 }
 215
 216 #
 217 # Check for readpassphrase().
 218 #
 219 src='
 220 #include <readpassphrase.h>
 221 int main(void) {
 222         char buf[12];
 223         readpassphrase("", buf, sizeof(buf), 0);
 224         return 0;
 225 }'
 226 check_func "readpassphrase" "$src" || {
 227         printf 'OPENBSD  +=     readpassphrase.o\n' >>$CONFIG_MK
 228 }
 229
 230 #
 231 # Check for strtonum().
 232 #
 233 src='
 234 #include <stdlib.h>
 235 int main(void) {
 236         const char *errstr;
 237         strtonum("", 1, 64, &errstr);
 238         return 0;
 239 }'
 240 check_func "strtonum" "$src" || {
 241         printf 'OPENBSD  +=     strtonum.o\n' >>$CONFIG_MK
 242 }
 243
 244 #
 245 # Check for reallocarray().
 246 #
 247 src='
 248 #include <stdlib.h>
 249 int main(void) {
 250         reallocarray(NULL, 0, 0);
 251         return 0;
 252 }'
 253 check_func "reallocarray" "$src" || {
 254         printf 'OPENBSD  +=     reallocarray.o\n' >>$CONFIG_MK
 255 }
 256
 257 #
 258 # Check for bsd_auth.h.
 259 #
 260 src='
 261 #include <bsd_auth.h>
 262 int main(void) {
 263         return 0;
 264 }'
 265 check_func "bsd_auth_h" "$src" && \
 266         have_bsd_auth_h=1
 267
 268 #
 269 # Check for pam_appl.h.
 270 #
 271 src='
 272 #include <security/pam_appl.h>
 273 int main(void) {
 274         return 0;
 275 }'
 276 [ -z "$have_bsd_auth_h" ] && \
 277         check_func "pam_appl_h" "$src" && {
 278                 printf 'SRCS     +=     doas_pam.c\n' >>$CONFIG_MK
 279                 printf 'LDFLAGS  +=     -lpam\n' >>$CONFIG_MK
 280         }
 281
 282 #
 283 # Check for login_cap.h.
 284 #
 285 src='
 286 #include <login_cap.h>
 287 int main(void) {
 288         return 0;
 289 }'
 290 check_func "login_cap_h" "$src" || {
 291         printf 'OPENBSD  +=     setusercontext.o\n' >>$CONFIG_MK
 292 }
 293
 294 #
 295 # Check for execvpe().
 296 #
 297 src='
 298 #include <unistd.h>
 299 int main(void) {
 300         const char *p = { "", NULL };
 301         execvpe("", p, p);
 302         return 0;
 303 }'
 304 check_func "execvpe" "$src" || {
 305         printf 'OPENBSD  +=     execvpe.o\n' >>$CONFIG_MK
 306 }
 307
 308 #
 309 # Check for setresuid().
 310 #
 311 src='
 312 #include <unistd.h>
 313 int main(void) {
 314         setresuid(0, 0, 0);
 315         return 0;
 316 }'
 317 check_func "setresuid" "$src" || {
 318         printf 'OPENBSD  +=     setresuid.o\n' >>$CONFIG_MK
 319 }
 320
 321 #
 322 # Check for pledge().
 323 #
 324 src='
 325 #include <unistd.h>
 326 int main(void) {
 327         pledge("", NULL);
 328         return 0;
 329 }'
 330 check_func "pledge" "$src" && {
 331         have_pledge=1
 332 }
 333
 334 #
 335 # Check for seccomp.h
 336 #
 337 src='
 338 #include <linux/seccomp.h>
 339 #include <sys/prctl.h>
 340 #include <unistd.h>
 341 int main(void) {
 342         prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, NULL);
 343         return 0;
 344 }'
 345 [ -z "$have_pledge" -a -n "$BUILD_SECCOMP" ] && \
 346         check_func "seccomp_h" "$src" && \
 347         {
 348                 have_pledge=1
 349                 printf 'OPENBSD  +=     pledge-seccomp.o\n' >>$CONFIG_MK
 350         }
 351
 352 [ -z "$have_pledge" ] && \
 353         printf 'OPENBSD  +=     pledge-noop.o\n' >>$CONFIG_MK