conf = Configure(libxml_env, custom_tests = {"CheckVersion": CheckVersion})

if conf.CheckCHeader("libxml/parser.h") and conf.CheckLib("xml2") :

# and conf.CheckVersion("LibXML", "2.6.23", "LIBXML_VERSION", "libxml/xmlversion.h", 20623):

env["HAVE_LIBXML"] = 1

env["LIBXML_FLAGS"] = { "CPPPATH": ["/usr/include/libxml2"], "LIBS": ["xml2"] }

conf.Finish()

# Expat

if env.get("try_expat", True) and not env.get("HAVE_LIBXML",0) :

expat_conf_env = conf_env.Clone()

expat_flags = {}

if env.get("expat_libdir", None) :

expat_flags["LIBPATH"] = [env["expat_libdir"]]

if env.get("expat_includedir", None) :

expat_flags["CPPPATH"] = [env["expat_includedir"]]

expat_conf_env.MergeFlags(expat_flags)

conf = Configure(expat_conf_env)

if conf.CheckCHeader("expat.h") and conf.CheckLib(env["expat_libname"]) :

env["HAVE_EXPAT"] = 1

env["EXPAT_FLAGS"] = { "LIBS": [env["expat_libname"]] }

env["EXPAT_FLAGS"].update(expat_flags)

conf.Finish()

# Bundled expat

bundledExpat = False

if not env.get("HAVE_EXPAT", 0) and not env.get("HAVE_LIBXML", 0) :

print "Expat or LibXML not found. Using bundled Expat"

SConscript("#/3rdParty/Expat/SConscript")

env["HAVE_EXPAT"] = 1

env["EXPAT_BUNDLED"] = True

################################################################################

# IDN library

################################################################################

# ICU

icu_env = conf_env.Clone()

use_icu = bool(env["icu"])

icu_prefix = ""

if isinstance(env["icu"], str) :

icu_prefix = env["icu"]

icu_flags = {}

if icu_prefix :

icu_flags = { "CPPPATH": [os.path.join(icu_prefix, "include")] }

icu_flags["LIBPATH"] = [os.path.join(icu_prefix, "lib")]

icu_env.MergeFlags(icu_flags)

icu_conf = Configure(icu_env)

if use_icu and icu_conf.CheckCHeader("unicode/usprep.h") :

env["HAVE_ICU"] = 1

env["ICU_FLAGS"] = icu_flags

env["ICU_FLAGS"]["LIBS"] = ["icuuc"]

icu_conf.Finish()

# LibIDN

libidn_conf_env = conf_env.Clone()

libidn_flags = {}

if env.get("libidn_libdir", None) :

libidn_flags["LIBPATH"] = [env["libidn_libdir"]]

if env.get("libidn_includedir", None) :

libidn_flags["CPPPATH"] = [env["libidn_includedir"]]

libidn_conf_env.MergeFlags(libidn_flags)

conf = Configure(libidn_conf_env)

if env.get("try_libidn", True) and not env.get("HAVE_ICU") and conf.CheckCHeader("idna.h") and conf.CheckLib(env["libidn_libname"]) :

env["HAVE_LIBIDN"] = 1

env["LIBIDN_FLAGS"] = { "LIBS": [env["libidn_libname"]] }

env["LIBIDN_FLAGS"].update(libidn_flags)

conf.Finish()

# Fallback to bundled LibIDN

if not env.get("HAVE_ICU", False) and not env.get("HAVE_LIBIDN", False) :

if env.get("libidn_bundled_enable", True) :

env["HAVE_LIBIDN"] = 1

env["LIBIDN_BUNDLED"] = 1

print "Error: ICU and LIBIDN not found, and libidn_bundled_enable is false"

Exit(1)

# Unbound

if env["unbound"] :

env["LDNS_BUNDLED"] = 1

env["UNBOUND_BUNDLED"] = 1

else :

env["LDNS_FLAGS"] = {}

env["UNBOUND_FLAGS"] = {}

# LibMiniUPnPc

if env["experimental_ft"] :

libminiupnpc_flags = {"CPPPATH": ["/usr/include/miniupnpc/"]}

libminiupnpc_conf_env = conf_env.Clone()

if env.get("libminiupnpc_libdir", None) :

libminiupnpc_flags["LIBPATH"] = [env["libminiupnpc_libdir"]]

if env.get("libminiupnpc_includedir", None) :

libminiupnpc_flags["CPPPATH"] = [env["libminiupnpc_includedir"]]

libminiupnpc_conf_env.MergeFlags(libminiupnpc_flags)

conf = Configure(libminiupnpc_conf_env)

if conf.CheckCHeader("miniupnpc.h") and conf.CheckLib(env["libminiupnpc_libname"]) and False :

# ^ False because APIs aren't stable

env["HAVE_LIBMINIUPNPC"] = 1

env["LIBMINIUPNPC_FLAGS"] = { "LIBS": ["miniupnpc"] }

env["LIBMINIUPNPC_FLAGS"].update(libminiupnpc_flags)

else :

env["LIBMINIUPNPC_BUNDLED"] = 1

conf.Finish()

else :

env["LIBMINIUPNPC_FLAGS"] = {}

# LibNATPMP

if env["experimental_ft"] :

libnatpmp_flags = {}

libnatpmp_conf_env = conf_env.Clone()

if env.get("libnatpmp_libdir", None) :