SConstruct

   1 from __future__ import print_function
   2 import os
   3 import re
   4 import string
   5 import sys
   6 from copy import copy
   7 from stat import *
   8
   9 try:
  10         string_types = basestring
  11 except NameError:
  12         string_types = str
  13
  14 package = 'lighttpd'
  15 version = '1.4.54'
  16
  17 underscorify_reg = re.compile('[^A-Z0-9]')
  18 def underscorify(id):
  19         return underscorify_reg.sub('_', id.upper())
  20
  21 def fail(*args, **kwargs):
  22         print(*args, file=sys.stderr, **kwargs)
  23         sys.exit(-1)
  24
  25 class Autoconf:
  26         class RestoreEnvLibs:
  27                 def __init__(self, env):
  28                         self.env = env
  29                         self.active = False
  30
  31                 def __enter__(self):
  32                         if self.active:
  33                                 raise Exception('entered twice')
  34                         self.active = True
  35                         if 'LIBS' in self.env:
  36                                 #print("Backup LIBS: " + repr(self.env['LIBS']))
  37                                 self.empty = False
  38                                 self.backup_libs = copy(self.env['LIBS'])
  39                         else:
  40                                 #print("No LIBS to backup")
  41                                 self.empty = True
  42
  43                 def __exit__(self, type, value, traceback):
  44                         if not self.active:
  45                                 raise Exception('exited twice')
  46                         self.active = False
  47                         if self.empty:
  48                                 if 'LIBS' in self.env:
  49                                         del self.env['LIBS']
  50                         else:
  51                                 #print("Restoring LIBS, now: " + repr(self.env['LIBS']))
  52                                 self.env['LIBS'] = self.backup_libs
  53                                 #print("Restoring LIBS, to: " + repr(self.env['LIBS']))
  54
  55         def __init__(self, env):
  56                 self.conf = Configure(env, custom_tests = {
  57                         'CheckGmtOffInStructTm': Autoconf.__checkGmtOffInStructTm,
  58                         'CheckIPv6': Autoconf.__checkIPv6,
  59                         'CheckWeakSymbols': Autoconf.__checkWeakSymbols,
  60                 })
  61
  62         def append(self, *args, **kw):
  63                 return self.conf.env.Append(*args, **kw)
  64
  65         def Finish(self):
  66                 return self.conf.Finish()
  67
  68         @property
  69         def env(self):
  70                 return self.conf.env
  71
  72         def restoreEnvLibs(self):
  73                 return Autoconf.RestoreEnvLibs(self.conf.env)
  74
  75         def CheckType(self, *args, **kw):
  76                 return self.conf.CheckType(*args, **kw)
  77
  78         def CheckLib(self, *args, **kw):
  79                 return self.conf.CheckLib(*args, autoadd = 0, **kw)
  80
  81         def CheckLibWithHeader(self, *args, **kw):
  82                 return self.conf.CheckLibWithHeader(*args, autoadd = 0, **kw)
  83
  84         def CheckGmtOffInStructTm(self):
  85                 return self.conf.CheckGmtOffInStructTm()
  86
  87         def CheckIPv6(self):
  88                 return self.conf.CheckIPv6()
  89
  90         def CheckWeakSymbols(self):
  91                 return self.conf.CheckWeakSymbols()
  92
  93         def CheckCHeader(self, hdr):
  94                 return self.conf.CheckCHeader(hdr)
  95
  96         def haveCHeader(self, hdr):
  97                 if self.CheckCHeader(hdr):
  98                         # if we have a list of headers define HAVE_ only for last one
  99                         target = hdr
 100                         if not isinstance(target, string_types):
 101                                 target = target[-1]
 102                         self.conf.env.Append(CPPFLAGS = [ '-DHAVE_' + underscorify(target) ])
 103                         return True
 104                 return False
 105
 106         def haveCHeaders(self, hdrs):
 107                 for hdr in hdrs:
 108                         self.haveCHeader(hdr)
 109
 110         def CheckFunc(self, func, header = None, libs = []):
 111                 with self.restoreEnvLibs():
 112                         self.env.Append(LIBS = libs)
 113                         return self.conf.CheckFunc(func, header = header)
 114
 115         def CheckFuncInLib(self, func, lib):
 116                 return self.CheckFunc(func, libs = [lib])
 117
 118         def haveFuncInLib(self, func, lib):
 119                 if self.CheckFuncInLib(func, lib):
 120                         self.conf.env.Append(CPPFLAGS = [ '-DHAVE_' + underscorify(func) ])
 121                         return True
 122                 return False
 123
 124         def haveFunc(self, func, header = None, libs = []):
 125                 if self.CheckFunc(func, header = header, libs = libs):
 126                         self.conf.env.Append(CPPFLAGS = [ '-DHAVE_' + underscorify(func) ])
 127                         return True
 128                 return False
 129
 130         def haveFuncs(self, funcs):
 131                 for func in funcs:
 132                         self.haveFunc(func)
 133
 134         def haveTypes(self, types):
 135                 for type in types:
 136                         if self.conf.CheckType(type, '#include <sys/types.h>'):
 137                                 self.conf.env.Append(CPPFLAGS = [ '-DHAVE_' + underscorify(type) ])
 138
 139         def CheckParseConfig(self, *args, **kw):
 140                 try:
 141                         self.conf.env.ParseConfig(*args, **kw)
 142                         return True
 143                 except Exception as e:
 144                         print(e.message, file=sys.stderr)
 145                         return False
 146
 147         def CheckParseConfigForLib(self, lib, *args, **kw):
 148                 with self.restoreEnvLibs():
 149                         self.env['LIBS'] = []
 150                         if not self.CheckParseConfig(*args, **kw):
 151                                 return False
 152                         self.env.Append(**{lib: self.env['LIBS']})
 153                         return True
 154
 155         @staticmethod
 156         def __checkGmtOffInStructTm(context):
 157                 source = """
 158 #include <time.h>
 159 int main() {
 160         struct tm a;
 161         a.tm_gmtoff = 0;
 162         return 0;
 163 }
 164 """
 165                 context.Message('Checking for tm_gmtoff in struct tm...')
 166                 result = context.TryLink(source, '.c')
 167                 context.Result(result)
 168
 169                 return result
 170
 171         @staticmethod
 172         def __checkIPv6(context):
 173                 source = """
 174 #include <sys/types.h>
 175 #include <sys/socket.h>
 176 #include <netinet/in.h>
 177
 178 int main() {
 179         struct sockaddr_in6 s; struct in6_addr t=in6addr_any; int i=AF_INET6; s; t.s6_addr[0] = 0;
 180         return 0;
 181 }
 182 """
 183                 context.Message('Checking for IPv6 support...')
 184                 result = context.TryLink(source, '.c')
 185                 context.Result(result)
 186
 187                 return result
 188
 189         @staticmethod
 190         def __checkWeakSymbols(context):
 191                 source = """
 192 __attribute__((weak)) void __dummy(void *x) { }
 193 int main() {
 194         void *x;
 195         __dummy(x);
 196 }
 197 """
 198                 context.Message('Checking for weak symbol support...')
 199                 result = context.TryLink(source, '.c')
 200                 context.Result(result)
 201
 202                 return result
 203
 204         def checkProgram(self, withname, progname):
 205                 withname = 'with_' + withname
 206                 binpath = None
 207
 208                 if self.env[withname] != 1:
 209                         binpath = self.env[withname]
 210                 else:
 211                         prog = self.env.Detect(progname)
 212                         if prog:
 213                                 binpath = self.env.WhereIs(prog)
 214
 215                 if binpath:
 216                         mode = os.stat(binpath)[ST_MODE]
 217                         if S_ISDIR(mode):
 218                                 fail("* error: path `%s' is a directory" % (binpath))
 219                         if not S_ISREG(mode):
 220                                 fail("* error: path `%s' is not a file or not exists" % (binpath))
 221
 222                 if not binpath:
 223                         fail("* error: can't find program `%s'" % (progname))
 224
 225                 return binpath
 226
 227 VariantDir('sconsbuild/build', 'src', duplicate = 0)
 228 VariantDir('sconsbuild/tests', 'tests', duplicate = 0)
 229
 230 vars = Variables()
 231 vars.AddVariables(
 232         ('prefix', 'prefix', '/usr/local'),
 233         ('bindir', 'binary directory', '${prefix}/bin'),
 234         ('sbindir', 'binary directory', '${prefix}/sbin'),
 235         ('libdir', 'library directory', '${prefix}/lib'),
 236         PathVariable('CC', 'path to the c-compiler', None),
 237         BoolVariable('build_dynamic', 'enable dynamic build', 'yes'),
 238         BoolVariable('build_static', 'enable static build', 'no'),
 239         BoolVariable('build_fullstatic', 'enable fullstatic build', 'no'),
 240
 241         BoolVariable('with_bzip2', 'enable bzip2 compression', 'no'),
 242         PackageVariable('with_dbi', 'enable dbi support', 'no'),
 243         BoolVariable('with_fam', 'enable FAM/gamin support', 'no'),
 244         BoolVariable('with_gdbm', 'enable gdbm support', 'no'),
 245         BoolVariable('with_geoip', 'enable GeoIP support', 'no'),
 246         BoolVariable('with_krb5', 'enable krb5 auth support', 'no'),
 247         BoolVariable('with_ldap', 'enable ldap auth support', 'no'),
 248         # with_libev not supported
 249         # with_libunwind not supported
 250         BoolVariable('with_lua', 'enable lua support for mod_cml', 'no'),
 251         BoolVariable('with_memcached', 'enable memcached support', 'no'),
 252         PackageVariable('with_mysql', 'enable mysql support', 'no'),
 253         BoolVariable('with_openssl', 'enable openssl support', 'no'),
 254         PackageVariable('with_wolfssl', 'enable wolfSSL support', 'no'),
 255         BoolVariable('with_pam', 'enable PAM auth support', 'no'),
 256         PackageVariable('with_pcre', 'enable pcre support', 'yes'),
 257         PackageVariable('with_pgsql', 'enable pgsql support', 'no'),
 258         PackageVariable('with_sasl', 'enable SASL support', 'no'),
 259         BoolVariable('with_sqlite3', 'enable sqlite3 support (required for webdav props)', 'no'),
 260         BoolVariable('with_uuid', 'enable uuid support (required for webdav locks)', 'no'),
 261         # with_valgrind not supported
 262         # with_xattr not supported
 263         PackageVariable('with_xml', 'enable xml support (required for webdav props)', 'no'),
 264         BoolVariable('with_zlib', 'enable deflate/gzip compression', 'no'),
 265
 266         BoolVariable('with_all', 'enable all with_* features', 'no'),
 267 )
 268
 269 env = Environment(
 270         ENV = os.environ,
 271         variables = vars,
 272         CPPPATH = Split('#sconsbuild/build')
 273 )
 274
 275 env.Help(vars.GenerateHelpText(env))
 276
 277 if env.subst('${CC}') is not '':
 278         env['CC'] = env.subst('${CC}')
 279
 280 env['package'] = package
 281 env['version'] = version
 282 if env['CC'] == 'gcc':
 283         ## we need x-open 6 and bsd 4.3 features
 284         env.Append(CCFLAGS = Split('-Wall -O2 -g -W -pedantic -Wunused -Wshadow -std=gnu99'))
 285
 286 env.Append(CPPFLAGS = [
 287         '-D_FILE_OFFSET_BITS=64',
 288         '-D_LARGEFILE_SOURCE',
 289         '-D_LARGE_FILES',
 290         '-D_GNU_SOURCE',
 291 ])
 292
 293 if env['with_all']:
 294         for feature in vars.keys():
 295                 # only enable 'with_*' flags
 296                 if not feature.startswith('with_'): continue
 297                 # don't overwrite manual arguments
 298                 if feature in vars.args: continue
 299                 # now activate
 300                 env[feature] = True
 301
 302 # cache configure checks
 303 if 1:
 304         autoconf = Autoconf(env)
 305
 306         if 'CFLAGS' in os.environ:
 307                 autoconf.env.Append(CCFLAGS = os.environ['CFLAGS'])
 308                 print(">> Appending custom build flags : " + os.environ['CFLAGS'])
 309
 310         if 'LDFLAGS' in os.environ:
 311                 autoconf.env.Append(LINKFLAGS = os.environ['LDFLAGS'])
 312                 print(">> Appending custom link flags : " + os.environ['LDFLAGS'])
 313
 314         if 'LIBS' in os.environ:
 315                 autoconf.env.Append(APPEND_LIBS = os.environ['LIBS'])
 316                 print(">> Appending custom libraries : " + os.environ['LIBS'])
 317         else:
 318                 autoconf.env.Append(APPEND_LIBS = '')
 319
 320         autoconf.env.Append(
 321                 LIBBZ2 = '',
 322                 LIBCRYPT = '',
 323                 LIBCRYPTO = '',
 324                 LIBDBI = '',
 325                 LIBDL = '',
 326                 LIBFCGI = '',
 327                 LIBGDBM = '',
 328                 LIBGSSAPI_KRB5 = '',
 329                 LIBKRB5 = '',
 330                 LIBLBER = '',
 331                 LIBLDAP = '',
 332                 LIBLUA = '',
 333                 LIBMEMCACHED = '',
 334                 LIBMYSQL = '',
 335                 LIBPAM = '',
 336                 LIBPCRE = '',
 337                 LIBPGSQL = '',
 338                 LIBSASL = '',
 339                 LIBSQLITE3 = '',
 340                 LIBSSL = '',
 341                 LIBUUID = '',
 342                 LIBXML2 = '',
 343                 LIBZ = '',
 344         )
 345
 346         autoconf.haveCHeaders([
 347                 'arpa/inet.h',
 348                 'crypt.h',
 349                 'fcntl.h',
 350                 'getopt.h',
 351                 'inttypes.h',
 352                 'linux/random.h',
 353                 'netinet/in.h',
 354                 'poll.h',
 355                 'pwd.h',
 356                 'stdint.h',
 357                 'stdlib.h',
 358                 'string.h',
 359                 'strings.h',
 360                 'sys/devpoll.h',
 361                 'sys/epoll.h',
 362                 'sys/event.h',
 363                 'sys/filio.h',
 364                 'sys/mman.h',
 365                 'sys/poll.h',
 366                 'sys/port.h',
 367                 'sys/prctl.h',
 368                 'sys/resource.h',
 369                 'sys/select.h',
 370                 'sys/sendfile.h',
 371                 'sys/socket.h',
 372                 'sys/time.h',
 373                 'sys/uio.h',
 374                 'sys/un.h',
 375                 'sys/wait.h',
 376                 'syslog.h',
 377                 'unistd.h',
 378                 'winsock2.h',
 379
 380                 # "have" the last header if we include others before?
 381                 ['sys/time.h', 'sys/types.h', 'sys/resource.h'],
 382                 ['sys/types.h', 'netinet/in.h'],
 383                 ['sys/types.h', 'sys/event.h'],
 384                 ['sys/types.h', 'sys/mman.h'],
 385                 ['sys/types.h', 'sys/select.h'],
 386                 ['sys/types.h', 'sys/socket.h'],
 387                 ['sys/types.h', 'sys/uio.h'],
 388                 ['sys/types.h', 'sys/un.h'],
 389         ])
 390
 391         autoconf.haveFuncs([
 392                 'arc4random_buf',
 393                 'chroot',
 394                 'clock_gettime',
 395                 'dup2',
 396                 'epoll_ctl',
 397                 'explicit_bzero',
 398                 'fork',
 399                 'getcwd',
 400                 'gethostbyname',
 401                 'getloadavg',
 402                 'getopt',
 403                 'getrlimit',
 404                 'getuid',
 405                 'inet_ntoa',
 406                 'inet_ntop',
 407                 'inet_pton',
 408                 'issetugid',
 409                 'jrand48',
 410                 'kqueue',
 411                 'localtime_r',
 412                 'lstat',
 413                 'madvise',
 414                 'memset_s',
 415                 'memset',
 416                 'mmap',
 417                 'munmap',
 418                 'pathconf',
 419                 'pipe2',
 420                 'poll',
 421                 'port_create',
 422                 'posix_fadvise',
 423                 'prctl',
 424                 'select',
 425                 'send_file',
 426                 'sendfile',
 427                 'sendfile64',
 428                 'sigaction',
 429                 'signal',
 430                 'socket',
 431                 'srandom',
 432                 'stat',
 433                 'strchr',
 434                 'strdup',
 435                 'strerror',
 436                 'strftime',
 437                 'strstr',
 438                 'strtol',
 439                 'writev',
 440         ])
 441         autoconf.haveFunc('getentropy', 'sys/random.h')
 442         autoconf.haveFunc('getrandom', 'linux/random.h')
 443
 444         autoconf.haveTypes(Split('pid_t size_t off_t'))
 445
 446         # have crypt_r/crypt, and is -lcrypt needed?
 447         if autoconf.CheckLib('crypt'):
 448                 autoconf.env.Append(
 449                         CPPFLAGS = [ '-DHAVE_LIBCRYPT' ],
 450                         LIBCRYPT = 'crypt',
 451                 )
 452                 with autoconf.restoreEnvLibs():
 453                         autoconf.env['LIBS'] = ['crypt']
 454                         autoconf.haveFuncs(['crypt', 'crypt_r'])
 455         else:
 456                 autoconf.haveFuncs(['crypt', 'crypt_r'])
 457
 458         if autoconf.CheckType('socklen_t', '#include <unistd.h>\n#include <sys/socket.h>\n#include <sys/types.h>'):
 459                 autoconf.env.Append(CPPFLAGS = [ '-DHAVE_SOCKLEN_T' ])
 460
 461         if autoconf.CheckType('struct sockaddr_storage', '#include <sys/socket.h>\n'):
 462                 autoconf.env.Append(CPPFLAGS = [ '-DHAVE_STRUCT_SOCKADDR_STORAGE' ])
 463
 464         if autoconf.CheckLibWithHeader('rt', 'time.h', 'c', 'clock_gettime(CLOCK_MONOTONIC, (struct timespec*)0);'):
 465                 autoconf.env.Append(
 466                         CPPFLAGS = [ '-DHAVE_CLOCK_GETTIME' ],
 467                         LIBS = [ 'rt' ],
 468                 )
 469
 470         if autoconf.CheckIPv6():
 471                 autoconf.env.Append(CPPFLAGS = [ '-DHAVE_IPV6' ])
 472
 473         if autoconf.CheckWeakSymbols():
 474                 autoconf.env.Append(CPPFLAGS = [ '-DHAVE_WEAK_SYMBOLS' ])
 475
 476         if autoconf.CheckGmtOffInStructTm():
 477                 autoconf.env.Append(CPPFLAGS = [ '-DHAVE_STRUCT_TM_GMTOFF' ])
 478
 479         if autoconf.CheckLibWithHeader('dl', 'dlfcn.h', 'C'):
 480                 autoconf.env.Append(LIBDL = 'dl')
 481
 482         # used in tests if present
 483         if autoconf.CheckLibWithHeader('fcgi', 'fastcgi.h', 'C'):
 484                 autoconf.env.Append(LIBFCGI = 'fcgi')
 485
 486         if env['with_bzip2']:
 487                 if not autoconf.CheckLibWithHeader('bz2', 'bzlib.h', 'C'):
 488                         fail("Couldn't find bz2")
 489                 autoconf.env.Append(
 490                         CPPFLAGS = [ '-DHAVE_BZLIB_H', '-DHAVE_LIBBZ2' ],
 491                         LIBBZ2 = 'bz2',
 492                 )
 493
 494         if env['with_dbi']:
 495                 if not autoconf.CheckLibWithHeader('dbi', 'dbi/dbi.h', 'C'):
 496                         fail("Couldn't find dbi")
 497                 autoconf.env.Append(
 498                         CPPFLAGS = [ '-DHAVE_DBI_H', '-DHAVE_LIBDBI' ],
 499                         LIBDBI = 'dbi',
 500                 )
 501
 502         if env['with_fam']:
 503                 if not autoconf.CheckLibWithHeader('fam', 'fam.h', 'C'):
 504                         fail("Couldn't find fam")
 505                 autoconf.env.Append(
 506                         CPPFLAGS = [ '-DHAVE_FAM_H', '-DHAVE_LIBFAM' ],
 507                         LIBS = [ 'fam' ],
 508                 )
 509                 autoconf.haveFunc('FAMNoExists')
 510
 511         if env['with_gdbm']:
 512                 if not autoconf.CheckLibWithHeader('gdbm', 'gdbm.h', 'C'):
 513                         fail("Couldn't find gdbm")
 514                 autoconf.env.Append(
 515                         CPPFLAGS = [ '-DHAVE_GDBM_H', '-DHAVE_GDBM' ],
 516                         LIBGDBM = 'gdbm',
 517                 )
 518
 519         if env['with_geoip']:
 520                 if not autoconf.CheckLibWithHeader('GeoIP', 'GeoIP.h', 'C'):
 521                         fail("Couldn't find geoip")
 522                 autoconf.env.Append(
 523                         CPPFLAGS = [ '-DHAVE_GEOIP' ],
 524                         LIBGEOIP = 'GeoIP',
 525                 )
 526
 527         if env['with_krb5']:
 528                 if not autoconf.CheckLibWithHeader('krb5', 'krb5.h', 'C'):
 529                         fail("Couldn't find krb5")
 530                 if not autoconf.CheckLibWithHeader('gssapi_krb5', 'gssapi/gssapi_krb5.h', 'C'):
 531                         fail("Couldn't find gssapi_krb5")
 532                 autoconf.env.Append(
 533                         CPPFLAGS = [ '-DHAVE_KRB5' ],
 534                         LIBKRB5 = 'krb5',
 535                         LIBGSSAPI_KRB5 = 'gssapi_krb5',
 536                 )
 537
 538         if env['with_ldap']:
 539                 if not autoconf.CheckLibWithHeader('ldap', 'ldap.h', 'C'):
 540                         fail("Couldn't find ldap")
 541                 if not autoconf.CheckLibWithHeader('lber', 'lber.h', 'C'):
 542                         fail("Couldn't find lber")
 543                 autoconf.env.Append(
 544                         CPPFLAGS = [
 545                                 '-DHAVE_LDAP_H', '-DHAVE_LIBLDAP',
 546                                 '-DHAVE_LBER_H', '-DHAVE_LIBLBER',
 547                         ],
 548                         LIBLDAP = 'ldap',
 549                         LIBLBER = 'lber',
 550                 )
 551
 552         if env['with_lua']:
 553                 found_lua = False
 554                 for lua_name in ['lua5.3', 'lua-5.3', 'lua5.2', 'lua-5.2', 'lua5.1', 'lua-5.1', 'lua']:
 555                         print("Searching for lua: " + lua_name + " >= 5.0")
 556                         if autoconf.CheckParseConfigForLib('LIBLUA', "pkg-config '" + lua_name + " >= 5.0' --cflags --libs"):
 557                                 autoconf.env.Append(CPPFLAGS = [ '-DHAVE_LUA_H' ])
 558                                 found_lua = True
 559                                 break
 560                 if not found_lua:
 561                         fail("Couldn't find any lua implementation")
 562
 563         if env['with_memcached']:
 564                 if not autoconf.CheckLibWithHeader('memcached', 'libmemcached/memcached.h', 'C'):
 565                         fail("Couldn't find memcached")
 566                 autoconf.env.Append(
 567                         CPPFLAGS = [ '-DUSE_MEMCACHED' ],
 568                         LIBMEMCACHED = 'memcached',
 569                 )
 570
 571         if env['with_mysql']:
 572                 mysql_config = autoconf.checkProgram('mysql', 'mysql_config')
 573                 if not autoconf.CheckParseConfigForLib('LIBMYSQL', mysql_config + ' --cflags --libs'):
 574                         fail("Couldn't find mysql")
 575                 autoconf.env.Append(CPPFLAGS = [ '-DHAVE_MYSQL_H', '-DHAVE_LIBMYSQL' ])
 576
 577         if env['with_openssl']:
 578                 if not autoconf.CheckLibWithHeader('ssl', 'openssl/ssl.h', 'C'):
 579                         fail("Couldn't find openssl")
 580                 autoconf.env.Append(
 581                         CPPFLAGS = [ '-DHAVE_OPENSSL_SSL_H', '-DHAVE_LIBSSL'],
 582                         LIBSSL = 'ssl',
 583                         LIBCRYPTO = 'crypto',
 584                 )
 585
 586         if env['with_wolfssl']:
 587                 if type(env['with_wolfssl']) is str:
 588                         autoconf.env.AppendUnique(
 589                                 CPPPATH = [ env['with_wolfssl'] + '/include',
 590                                             env['with_wolfssl'] + '/include/wolfssl' ],
 591                                 LIBPATH = [ env['with_wolfssl'] + '/lib' ],
 592                         )
 593                 if not autoconf.CheckLibWithHeader('wolfssl', 'wolfssl/ssl.h', 'C'):
 594                         fail("Couldn't find wolfssl")
 595                 autoconf.env.Append(
 596                         CPPFLAGS = [ '-DHAVE_WOLFSSL_SSL_H' ],
 597                         LIBSSL = '',
 598                         LIBCRYPTO = 'wolfssl',
 599                 )
 600
 601         if env['with_pam']:
 602                 if not autoconf.CheckLibWithHeader('pam', 'security/pam_appl.h', 'C'):
 603                         fail("Couldn't find pam")
 604                 autoconf.env.Append(
 605                         CPPFLAGS = [ '-DHAVE_PAM' ],
 606                         LIBPAM = 'pam',
 607                 )
 608
 609         if env['with_pcre']:
 610                 pcre_config = autoconf.checkProgram('pcre', 'pcre-config')
 611                 if not autoconf.CheckParseConfigForLib('LIBPCRE', pcre_config + ' --cflags --libs'):
 612                         fail("Couldn't find pcre")
 613                 autoconf.env.Append(CPPFLAGS = [ '-DHAVE_PCRE_H', '-DHAVE_LIBPCRE' ])
 614
 615         if env['with_pgsql']:
 616                 if not autoconf.CheckParseConfigForLib('LIBPGSQL', 'pkg-config libpq --cflags --libs'):
 617                         fail("Couldn't find libpq")
 618                 autoconf.env.Append(CPPFLAGS = [ '-DHAVE_PGSQL_H', '-DHAVE_LIBPGSQL' ])
 619
 620         if env['with_sasl']:
 621                 if not autoconf.CheckLibWithHeader('sasl2', 'sasl/sasl.h', 'C'):
 622                         fail("Couldn't find libsasl2")
 623                 autoconf.env.Append(
 624                         CPPFLAGS = [ '-DHAVE_SASL' ],
 625                         LIBSASL = 'sasl2',
 626                 )
 627
 628         if env['with_sqlite3']:
 629                 if not autoconf.CheckLibWithHeader('sqlite3', 'sqlite3.h', 'C'):
 630                         fail("Couldn't find sqlite3")
 631                 autoconf.env.Append(
 632                         CPPFLAGS = [ '-DHAVE_SQLITE3_H', '-DHAVE_LIBSQLITE3' ],
 633                         LIBSQLITE3 = 'sqlite3',
 634                 )
 635
 636         if env['with_uuid']:
 637                 if not autoconf.CheckLibWithHeader('uuid', 'uuid/uuid.h', 'C'):
 638                         fail("Couldn't find uuid")
 639                 autoconf.env.Append(
 640                         CPPFLAGS = [ '-DHAVE_UUID_UUID_H', '-DHAVE_LIBUUID' ],
 641                         LIBUUID = 'uuid',
 642                 )
 643
 644         if env['with_xml']:
 645                 xml2_config = autoconf.checkProgram('xml', 'xml2-config')
 646                 if not autoconf.CheckParseConfigForLib('LIBXML2', xml2_config + ' --cflags --libs'):
 647                         fail("Couldn't find xml2")
 648                 autoconf.env.Append(CPPFLAGS = [ '-DHAVE_LIBXML_H', '-DHAVE_LIBXML2' ])
 649
 650         if env['with_zlib']:
 651                 if not autoconf.CheckLibWithHeader('z', 'zlib.h', 'C'):
 652                         fail("Couldn't find zlib")
 653                 autoconf.env.Append(
 654                         CPPFLAGS = [ '-DHAVE_ZLIB_H', '-DHAVE_LIBZ' ],
 655                         LIBZ = 'z',
 656                 )
 657
 658         env = autoconf.Finish()
 659
 660 if re.compile("cygwin|mingw|midipix").search(env['PLATFORM']):
 661         env.Append(COMMON_LIB = 'bin')
 662 elif re.compile("darwin|aix").search(env['PLATFORM']):
 663         env.Append(COMMON_LIB = 'lib')
 664 else:
 665         env.Append(COMMON_LIB = False)
 666
 667 versions = version.split('.')
 668 version_id = int(versions[0]) << 16 | int(versions[1]) << 8 | int(versions[2])
 669 env.Append(CPPFLAGS = [
 670                 '-DLIGHTTPD_VERSION_ID=' + hex(version_id),
 671                 '-DPACKAGE_NAME=\\"' + package + '\\"',
 672                 '-DPACKAGE_VERSION=\\"' + version + '\\"',
 673                 '-DLIBRARY_DIR="\\"${libdir}\\""',
 674                 ] )
 675
 676 SConscript('src/SConscript', exports = 'env', variant_dir = 'sconsbuild/build', duplicate = 0)
 677 SConscript('tests/SConscript', exports = 'env', variant_dir = 'sconsbuild/tests')