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