'kernel': False,

'execinfo': False,

'ifaddrs': False,

'locking': False,

'event': False,

'timer': False,

'filemonitor': False,

'pcre': False,

'routing': False,

'capabilities': False,

'yaml': False,

'json': False,

'ssl': False,

'xml': False,

'debug': False,

'plugin_dir': False,

'zlib': False,

'ucontext': False,

if verbose_build:

print(verbose_str)

elif default_str is not None:

while True:

(objfile, cmdline) = compile_queue.get()

if objfile:

print_lock.acquire()

print_compilation_output("[thread %d][%s] %s" % (num, GCC, objfile), "[thread %d] %s" % (num, cmdline))

print_lock.release()

ret = os.system(cmdline)

if ret != 0:

os._exit(1)

elif cmdline:

print_lock.acquire()

print(cmdline)

print_lock.release()

else:

p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=open('uwsgibuild.log', 'w'))

if p.wait() == 0:

if sys.version_info[0] > 2:

return p.stdout.read().rstrip().decode()

return p.stdout.read().rstrip()

else:

new_elements = []

for element in elements:

if element.startswith('-W'):

if element not in new_elements:

new_elements.append(element)

else:

new_elements.append(element)

p = subprocess.Popen(cmd, shell=True, stderr=subprocess.PIPE)

if p.wait() == 0:

if sys.version_info[0] > 2:

return p.stderr.read().rstrip().decode()

return p.stderr.read().rstrip()

else:

"""Compile a C snippet to see if features are available at build / link time."""

if not isinstance(snippet, bytes):

if PY3:

snippet = bytes(snippet, sys.getdefaultencoding())

else:

snippet = bytes(snippet)

cmd = "{} -xc - -o /dev/null".format(GCC)

p = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, stderr=subprocess.PIPE, stdout=subprocess.PIPE)

p.communicate(snippet)

if uwsgi_os in ('OpenBSD', 'Haiku'):

return False

if uwsgi_os.startswith('CYGWIN'):

return False

if uwsgi_os == 'Darwin' and uwsgi_os_k.startswith('8'):

return False

if uwsgi_cpu[0:3] == 'arm':

return False

# check for ucontext.h functions definitions, musl has only declarations

return test_snippet("""#include <ucontext.h>

int main()

{

ucontext_t uc;

getcontext(&uc);

return 0;

p = subprocess.Popen(cmd, shell=True, stdin=open('/dev/null'), stderr=subprocess.PIPE, stdout=subprocess.PIPE)

if p.wait() == 0:

if sys.version_info[0] > 2:

return p.stderr.read().rstrip().decode()

return p.stderr.read().rstrip()

else:

if x == 'uwsgi':

x = 'main'

elif x.endswith('.a') or x.endswith('.o') or x.startswith('-'):

return x

x = x + '.o'

if not compile_queue:

print(msg)

else:

if not compile_queue:

print_compilation_output("[%s] %s" % (GCC, objfile), cmdline)

ret = os.system(cmdline)

if ret != 0:

sys.exit(1)

else:

source_stat = os.stat(srcfile)

header_stat = os.stat('uwsgi.h')

try:

if os.environ.get('UWSGI_FORCE_REBUILD', None):

raise

if source_stat[8] >= last_cflags_ts:

raise

if header_stat[8] >= last_cflags_ts:

raise

object_stat = os.stat(objfile)

if object_stat[8] <= source_stat[8]:

raise

if object_stat[8] <= header_stat[8]:

raise

for profile in os.listdir('buildconf'):

profile_stat = os.stat('buildconf/%s' % profile)

if object_stat[8] <= profile_stat[8]:

raise

print("%s is up to date" % objfile)

return

except Exception:

pass

cmdline = "%s -c %s -o %s %s" % (GCC, cflags, objfile, srcfile)

global print_lock, compile_queue, thread_compilers

if CPUCOUNT > 1:

print_lock = Lock()

compile_queue = Queue(maxsize=CPUCOUNT)

for i in range(0, CPUCOUNT):

t = Thread(target=thread_compiler, args=(i,))

t.daemon = True

t.start()

thread_compilers.append(t)

if not gcll:

gcc_list, cflags, ldflags, libs = uc.get_gcll()

else:

gcc_list, cflags, ldflags, libs = gcll

if 'UWSGI_EMBED_PLUGINS' in os.environ:

ep = uc.get('embedded_plugins')

if ep:

uc.set('embedded_plugins', ep + ',' + os.environ['UWSGI_EMBED_PLUGINS'])

else:

uc.set('embedded_plugins', os.environ['UWSGI_EMBED_PLUGINS'])

if uc.get('embedded_plugins'):

ep = uc.get('embedded_plugins').split(',')

epc = "-DUWSGI_DECLARE_EMBEDDED_PLUGINS=\""

eplc = "-DUWSGI_LOAD_EMBEDDED_PLUGINS=\""

for item in ep:

# allow name=path syntax

kv = item.split('=')

p = kv[0]

p = p.strip()

if not p or p == 'None':

continue

if p == 'ugreen':

if not report['ucontext']:

continue

epc += "UDEP(%s);" % p

eplc += "ULEP(%s);" % p

epc += "\""

eplc += "\""

cflags.append(epc)

cflags.append(eplc)

if print_only:

print(' '.join(cflags))

sys.exit(0)

if 'APPEND_CFLAGS' in os.environ:

cflags += os.environ['APPEND_CFLAGS'].split()

print("detected CPU cores: %d" % CPUCOUNT)

print("configured CFLAGS: %s" % ' '.join(cflags))

if sys.version_info[0] >= 3:

import binascii

uwsgi_cflags = binascii.b2a_hex(' '.join(cflags).encode('ascii')).decode('ascii')

else:

uwsgi_cflags = ' '.join(cflags).encode('hex')

last_cflags_ts = 0

if os.path.exists('uwsgibuild.lastcflags'):

ulc = open('uwsgibuild.lastcflags', 'r')

last_cflags = ulc.read()

ulc.close()

if uwsgi_cflags != last_cflags:

os.environ['UWSGI_FORCE_REBUILD'] = '1'

else:

last_cflags_ts = os.stat('uwsgibuild.lastcflags')[8]

with open('uwsgibuild.lastcflags', 'w') as ulc:

ulc.write(uwsgi_cflags)

# embed uwsgi.h in the server binary. It increases the binary size, but will be very useful

# for various tricks (like cffi integration)

# if possible, the blob is compressed

if sys.version_info[0] >= 3:

uwsgi_dot_h_content = open('uwsgi.h', 'rb').read()

else:

uwsgi_dot_h_content = open('uwsgi.h').read()

if report['zlib']:

import zlib

# maximum level of compression

uwsgi_dot_h_content = zlib.compress(uwsgi_dot_h_content, 9)

if sys.version_info[0] >= 3:

import binascii

uwsgi_dot_h = binascii.b2a_hex(uwsgi_dot_h_content).decode('ascii')

else:

uwsgi_dot_h = uwsgi_dot_h_content.encode('hex')

open('core/dot_h.c', 'w').write('char *uwsgi_dot_h = "%s";\n' % uwsgi_dot_h)

gcc_list.append('core/dot_h')

# embed uwsgiconfig.py in the server binary. It increases the binary size, but will be very useful

# if possible, the blob is compressed

if sys.version_info[0] >= 3:

uwsgi_config_py_content = open('uwsgiconfig.py', 'rb').read()

else:

uwsgi_config_py_content = open('uwsgiconfig.py').read()

if report['zlib']:

import zlib

# maximum level of compression

uwsgi_config_py_content = zlib.compress(uwsgi_config_py_content, 9)

if sys.version_info[0] >= 3:

import binascii

uwsgi_config_py = binascii.b2a_hex(uwsgi_config_py_content).decode('ascii')

else:

uwsgi_config_py = uwsgi_config_py_content.encode('hex')

open('core/config_py.c', 'w').write('char *uwsgi_config_py = "%s";\n' % uwsgi_config_py)

gcc_list.append('core/config_py')

additional_sources = os.environ.get('UWSGI_ADDITIONAL_SOURCES')

if not additional_sources:

additional_sources = uc.get('additional_sources')

if additional_sources:

for item in additional_sources.split(','):

gcc_list.append(item)

if uc.filename.endswith('coverity.ini'):

cflags.append('-DUWSGI_CFLAGS=\\"\\"')

else:

cflags.append('-DUWSGI_CFLAGS=\\"%s\\"' % uwsgi_cflags)

cflags.append('-DUWSGI_BUILD_DATE="\\"%s\\""' % time.strftime("%d %B %Y %H:%M:%S"))

post_build = []

push_print("*** uWSGI compiling server core ***")

for file in gcc_list:

objfile = file

if objfile == 'uwsgi':

objfile = 'main'

if not objfile.endswith('.a') and not objfile.endswith('.o'):

if objfile.endswith('.c') or objfile.endswith('.cc') or objfile.endswith('.m') or objfile.endswith('.go'):

if objfile.endswith('.go'):

cflags.append('-Wno-error')

compile(' '.join(cflags), last_cflags_ts, objfile + '.o', file)

if objfile.endswith('.go'):

cflags.pop()

else:

if objfile == 'core/dot_h':

cflags.append('-g')

compile(' '.join(cflags), last_cflags_ts, objfile + '.o', file + '.c')

if objfile == 'core/dot_h':

cflags.pop()

if uc.get('embedded_plugins'):

ep = uc.get('embedded_plugins').split(',')

if len(ep) > 0:

push_print("*** uWSGI compiling embedded plugins ***")

for item in ep:

# allows name=path syntax

kv = item.split('=')

if len(kv) > 1:

p = kv[1]

p = p.strip()

if is_remote_plugin(p):

p = get_remote_plugin(p)

path = os.path.abspath(p)

else:

p = kv[0]

p = p.strip()

path = 'plugins/%s' % p

if not p or p == 'None':

continue

if p == 'ugreen':

if not report['ucontext']:

continue

path = path.rstrip('/')

path, up = get_plugin_up(path)

p_cflags = cflags[:]

p_cflags += up['CFLAGS']

if uwsgi_os.startswith('CYGWIN'):

try:

p_cflags.remove('-fstack-protector')

except ValueError:

pass

if GCC in ('clang',):

try:

p_cflags.remove('-fno-fast-math')

p_cflags.remove('-ggdb3')

except ValueError:

pass

p_cflags_blacklist = (

'-Wdeclaration-after-statement',

'-Werror=declaration-after-statement',

'-Wwrite-strings',

'-Werror=write-strings',

)

for cflag in p_cflags_blacklist:

try:

p_cflags.remove(cflag)

except ValueError:

pass

try:

if up['post_build']:

post_build.append(up['post_build'])

except Exception:

pass

for cfile in up['GCC_LIST']:

if cfile.endswith('.a'):

gcc_list.append(cfile)

elif cfile.endswith('.o'):

gcc_list.append('%s/%s' % (path, cfile))

elif not cfile.endswith('.c') and not cfile.endswith('.cc') and not cfile.endswith('.go') and not cfile.endswith('.m'):

compile(' '.join(uniq_warnings(p_cflags)), last_cflags_ts,

path + '/' + cfile + '.o', path + '/' + cfile + '.c')

gcc_list.append('%s/%s' % (path, cfile))

else:

if cfile.endswith('.go'):

p_cflags.append('-Wno-error')

compile(' '.join(uniq_warnings(p_cflags)), last_cflags_ts,

path + '/' + cfile + '.o', path + '/' + cfile)

gcc_list.append('%s/%s' % (path, cfile))

for bfile in up.get('BINARY_LIST', []):

try:

binary_link_cmd = "ld -r -b binary -o %s/%s.o %s/%s" % (path, bfile[1], path, bfile[1])

print(binary_link_cmd)

if os.system(binary_link_cmd) != 0:

raise Exception('unable to link binary file')

for kind in ('start', 'end'):

objcopy_cmd = "objcopy --redefine-sym _binary_%s_%s=%s_%s %s/%s.o" % (binarize('%s/%s' % (path, bfile[1])), kind, bfile[0], kind, path, bfile[1])

print(objcopy_cmd)

if os.system(objcopy_cmd) != 0:

raise Exception('unable to link binary file')

gcc_list.append('%s/%s.o' % (path, bfile[1]))

except Exception:

if uwsgi_os == 'Darwin':

gcc_list.append('-sectcreate __DATA %s %s/%s' % (strip_prefix('_uwsgi_', bfile[0]), path, bfile[1]))

libs += up['LIBS']

if uwsgi_os == 'Darwin':

found_arch = False

sanitized_ldflags = []

for flag in up['LDFLAGS']:

if flag == '-arch':

found_arch = True

continue

if found_arch:

found_arch = False

continue

sanitized_ldflags.append(flag)

ldflags += sanitized_ldflags

else:

ldflags += up['LDFLAGS']

if uc.get('plugins'):

plugins = uc.get('plugins').split(',')

if len(plugins) > 0:

push_print("*** uWSGI building plugins ***")

for p in plugins:

p = p.strip()

push_print("*** building plugin: %s ***" % p)

build_plugin("plugins/%s" % p, uc, cflags, ldflags, libs)

bin_name = os.environ.get('UWSGI_BIN_NAME', uc.get('bin_name'))

if uc.embed_config:

gcc_list.append("%s.o" % binarize(uc.embed_config))

for ef in binary_list:

gcc_list.append("%s.o" % ef)

if compile_queue:

for t in thread_compilers:

compile_queue.put((None, None))

for t in thread_compilers:

t.join()

print("*** uWSGI linking ***")

ldline = "%s -o %s %s %s %s" % (

GCC,

bin_name,

' '.join(uniq_warnings(ldflags)),

' '.join(map(add_o, gcc_list)),

' '.join(uniq_warnings(libs))

)

print(ldline)

ret = os.system(ldline)

if ret != 0:

print("*** error linking uWSGI ***")

sys.exit(1)

print("################# uWSGI configuration #################")

print("")

for report_key in report:

print("%s = %s" % (report_key, report[report_key]))

print("")

print("############## end of uWSGI configuration #############")

print("total build time: %d seconds" % (time.time() - started_at))

if bin_name.find("/") < 0:

bin_name = './' + bin_name

if uc.get('as_shared_library'):

print("*** uWSGI shared library (%s) is ready, move it to a library directory ***" % bin_name)

else:

print("*** uWSGI is ready, launch it with %s ***" % bin_name)

for pb in post_build:

if filename.startswith('http://') or filename.startswith('https://') or filename.startswith('ftp://'):

wrapped = False

try:

import urllib2

except ImportError:

import urllib.request

wrapped = True

if wrapped:

import io

return io.TextIOWrapper(urllib.request.urlopen(filename), encoding='utf-8')

return urllib2.urlopen(filename)

def __init__(self, filename, mute=False):

global GCC

self.filename = filename

self.config = ConfigParser.ConfigParser()

if not mute:

print("using profile: %s" % filename)

if os.path.exists('uwsgibuild.lastprofile'):

ulp = open('uwsgibuild.lastprofile', 'r')

last_profile = ulp.read()

ulp.close()

if last_profile != filename:

os.environ['UWSGI_FORCE_REBUILD'] = '1'

with open('uwsgibuild.lastprofile', 'w') as ulp:

ulp.write(filename)

self.config.readfp(open_profile(filename))

self.gcc_list = [

'core/utils', 'core/protocol', 'core/socket', 'core/logging',

'core/master', 'core/master_utils', 'core/emperor', 'core/notify',

'core/mule', 'core/subscription', 'core/stats', 'core/sendfile',

'core/async', 'core/master_checks', 'core/fifo', 'core/offload',

'core/io', 'core/static', 'core/websockets', 'core/spooler',

'core/snmp', 'core/exceptions', 'core/config', 'core/setup_utils',

'core/clock', 'core/init', 'core/buffer', 'core/reader',

'core/writer', 'core/alarm', 'core/cron', 'core/hooks',

'core/plugins', 'core/lock', 'core/cache', 'core/daemons',

'core/errors', 'core/hash', 'core/master_events', 'core/chunked',

'core/queue', 'core/event', 'core/signal', 'core/strings',

'core/progress', 'core/timebomb', 'core/ini', 'core/fsmon',

'core/mount', 'core/metrics', 'core/plugins_builder',

'core/sharedarea', 'core/fork_server', 'core/webdav', 'core/zeus',

'core/rpc', 'core/gateway', 'core/loop', 'core/cookie',

'core/querystring', 'core/rb_timers', 'core/transformations',

'core/uwsgi',

]

# add protocols

self.gcc_list.append('proto/base')

self.gcc_list.append('proto/uwsgi')

self.gcc_list.append('proto/http')

self.gcc_list.append('proto/fastcgi')

self.gcc_list.append('proto/scgi')

self.gcc_list.append('proto/puwsgi')

self.include_path = []

if 'UWSGI_INCLUDES' in os.environ:

self.include_path += os.environ['UWSGI_INCLUDES'].split(',')

self.cflags = [

'-O2',

'-I.',

'-Wall',

'-Werror',

'-D_LARGEFILE_SOURCE',

'-D_FILE_OFFSET_BITS=64'

] + os.environ.get("CFLAGS", "").split() + self.get('cflags', '').split()

report['kernel'] = uwsgi_os

if uwsgi_os == 'Linux':

if uwsgi_cpu != 'ia64':

self.gcc_list.append('lib/linux_ns')

try:

lk_ver = uwsgi_os_k.split('.')

if int(lk_ver[0]) <= 2 and int(lk_ver[1]) <= 6 and int(lk_ver[2]) <= 9:

self.cflags.append('-DOBSOLETE_LINUX_KERNEL')

report['kernel'] = 'Old Linux'

except Exception:

pass

if uwsgi_os == 'GNU':

self.cflags.append('-D__HURD__')

gcc_version = spcall("%s -dumpversion" % GCC)

if not gcc_version and GCC.startswith('gcc'):

if uwsgi_os == 'Darwin':

GCC = 'llvm-' + GCC

else:

GCC = 'gcc'

gcc_version = spcall("%s -dumpversion" % GCC)

try:

add_it = False

cpp_include_list = str(spcall3("%s -v" % CPP)).split("\n")

for line in cpp_include_list:

if line.startswith('#include <...> search starts here:'):

add_it = True

elif line.startswith('End of search list.'):

add_it = False

elif add_it:

self.include_path.append(line.strip().split()[0])

if not self.include_path:

raise

except Exception:

self.include_path = ['/usr/include', '/usr/local/include']

additional_include_paths = self.get('additional_include_paths')

if additional_include_paths:

for ipath in additional_include_paths.split():

self.include_path.append(ipath)

if 'UWSGI_REMOVE_INCLUDES' in os.environ:

for inc in os.environ['UWSGI_REMOVE_INCLUDES'].split(','):

try:

self.include_path.remove(inc)

except ValueError:

pass

if not mute:

print("detected include path: %s" % self.include_path)

try:

gcc_version_components = gcc_version.split('.')

gcc_major = int(gcc_version_components[0])

if len(gcc_version_components) > 1:

gcc_minor = int(gcc_version_components[1])

else:

# gcc 5.0 is represented as simply "5"

gcc_minor = 0

except Exception:

raise Exception("you need a C compiler to build uWSGI")

# add -fno-strict-aliasing only on python2 and gcc < 4.3

if (sys.version_info[0] == 2) or (gcc_major < 4) or (gcc_major == 4 and gcc_minor < 3):

self.cflags += ['-fno-strict-aliasing']

if gcc_major >= 4:

self.cflags += ['-Wextra', '-Wno-unused-parameter', '-Wno-missing-field-initializers']

if gcc_major == 4 and gcc_minor < 9:

self.cflags.append('-Wno-format -Wno-format-security')

self.ldflags = os.environ.get("LDFLAGS", "").split()

self.libs = ['-lpthread', '-lm', '-rdynamic']

if uwsgi_os in ('Linux', 'GNU', 'GNU/kFreeBSD'):

self.libs.append('-ldl')

if uwsgi_os == 'GNU/kFreeBSD':

self.cflags.append('-D__GNU_kFreeBSD__')

self.libs.append('-lbsd')

# check for inherit option

inherit = self.get('inherit')

if inherit:

if '/' not in inherit:

inherit = 'buildconf/%s' % inherit

if not inherit.endswith('.ini'):

inherit = '%s.ini' % inherit

interpolations = {}

for option in self.config.options('uwsgi'):

interpolations[option] = self.get(option, default='')

iconfig = ConfigParser.ConfigParser(interpolations)

iconfig.readfp(open_profile(inherit))

for opt in iconfig.options('uwsgi'):

if not self.config.has_option('uwsgi', opt):

self.set(opt, iconfig.get('uwsgi', opt))

elif self.get(opt):

if self.get(opt).startswith('+'):

self.set(opt, iconfig.get('uwsgi', opt) + self.get(opt)[1:])

elif self.get(opt) == 'null':

self.config.remove_option('uwsgi', opt)

def set(self, key, value):

self.config.set('uwsgi', key, value)

def get(self, key, default=None):

try:

value = self.config.get('uwsgi', key)

if value == "" or value == "false":

return default

return value

except Exception:

if default is not None:

return default

return None

def depends_on(self, what, dep):

for d in dep:

if not self.get(d):

print("%s needs %s support." % (what, d))

sys.exit(1)

def has_include(self, what):

for include in self.include_path:

if os.path.exists("%s/%s" % (include, what)):

return True

return False

def get_gcll(self):

global uwsgi_version

kvm_list = ['FreeBSD', 'OpenBSD', 'NetBSD', 'DragonFly']

if 'UWSGI_PROFILE_OVERRIDE' in os.environ:

for item in os.environ['UWSGI_PROFILE_OVERRIDE'].split(';'):

k, v = item.split('=', 1)

self.set(k, v)

if 'UWSGI_AS_LIB' in os.environ:

self.set('as_shared_library', 'true')

self.set('bin_name', os.environ['UWSGI_AS_LIB'])

if self.has_include('ifaddrs.h'):

self.cflags.append('-DUWSGI_HAS_IFADDRS')

report['ifaddrs'] = True

if uwsgi_os in ('FreeBSD', 'OpenBSD'):

if self.has_include('execinfo.h') or os.path.exists('/usr/local/include/execinfo.h'):

if os.path.exists('/usr/local/include/execinfo.h'):

self.cflags.append('-I/usr/local/include')

self.ldflags.append('-L/usr/local/lib')

self.cflags.append('-DUWSGI_HAS_EXECINFO')

self.libs.append('-lexecinfo')

report['execinfo'] = True

if uwsgi_os == 'GNU/kFreeBSD':

if self.has_include('execinfo.h'):

self.cflags.append('-DUWSGI_HAS_EXECINFO')

report['execinfo'] = True

if self.has_include('zlib.h'):

self.cflags.append('-DUWSGI_ZLIB')

self.libs.append('-lz')

self.gcc_list.append('core/zlib')

report['zlib'] = True

if uwsgi_os == 'OpenBSD':

try:

obsd_major = int(uwsgi_os_k.split('.')[0])

obsd_minor = int(uwsgi_os_k.split('.')[1])

if obsd_major >= 5 and obsd_minor > 0:

self.cflags.append('-DUWSGI_NEW_OPENBSD')

report['kernel'] = 'New OpenBSD'

except Exception:

pass

if uwsgi_os == 'SunOS':

self.libs.append('-lsendfile')

self.libs.append('-lrt')

self.gcc_list.append('lib/sun_fixes')

sunos_major = int(uwsgi_os_k.split('.')[0])

sunos_minor = int(uwsgi_os_k.split('.')[1])

# solaris < 11 does not have sethostname declared in unistd

if not (sunos_major == 5 and sunos_minor > 10):

self.cflags.append('-DUWSGI_SUNOS_EXTERN_SETHOSTNAME')

self.ldflags.append('-L/lib')

if not uwsgi_os_v.startswith('Nexenta'):

self.libs.remove('-rdynamic')

if uwsgi_os == 'GNU/kFreeBSD':

if self.has_include('kvm.h'):

kvm_list.append('GNU/kFreeBSD')

if uwsgi_os in kvm_list:

self.libs.append('-lkvm')

if uwsgi_os == 'Haiku':

self.libs.remove('-rdynamic')

self.libs.remove('-lpthread')

self.libs.append('-lroot')

if uwsgi_os == 'Darwin':

if uwsgi_os_k.startswith('8'):

self.cflags.append('-DUNSETENV_VOID')

self.cflags.append('-DNO_SENDFILE')

self.cflags.append('-DNO_EXECINFO')

self.cflags.append('-DOLD_REALPATH')

self.cflags.append('-mmacosx-version-min=10.5')

if GCC in ('clang',):

self.libs.remove('-rdynamic')

if uwsgi_os.startswith('CYGWIN'):

self.libs.remove('-rdynamic')

# compile extras

extras = self.get('extras', None)

if extras:

for extra in extras.split(','):

self.gcc_list.append(extra)

# check for usable ucontext

report['ucontext'] = has_usable_ucontext()

# set locking subsystem

locking_mode = self.get('locking', 'auto')

if locking_mode == 'auto':

if uwsgi_os == 'Linux' or uwsgi_os == 'SunOS':

locking_mode = 'pthread_mutex'

# FreeBSD umtx is still not ready for process shared locking

# starting from FreeBSD 9 posix semaphores can be shared between processes

elif uwsgi_os in ('FreeBSD', 'GNU/kFreeBSD'):

try:

fbsd_major = int(uwsgi_os_k.split('.')[0])

if fbsd_major >= 9:

locking_mode = 'posix_sem'

except Exception:

pass

elif uwsgi_os == 'GNU':

locking_mode = 'posix_sem'

elif uwsgi_os == 'Darwin':

locking_mode = 'osx_spinlock'

elif uwsgi_os.startswith('CYGWIN'):

locking_mode = 'windows_mutex'

if locking_mode == 'pthread_mutex':

self.cflags.append('-DUWSGI_LOCK_USE_MUTEX')

# FreeBSD umtx is still not ready for process shared locking

elif locking_mode == 'posix_sem':

self.cflags.append('-DUWSGI_LOCK_USE_POSIX_SEM')

elif locking_mode == 'osx_spinlock':

self.cflags.append('-DUWSGI_LOCK_USE_OSX_SPINLOCK')

elif locking_mode == 'windows_mutex':

self.cflags.append('-DUWSGI_LOCK_USE_WINDOWS_MUTEX')

else:

self.cflags.append('-DUWSGI_IPCSEM_ATEXIT')

if locking_mode == 'auto':

report['locking'] = 'sysv semaphores'

else:

report['locking'] = locking_mode

# set event subsystem

event_mode = self.get('event', 'auto')

if event_mode == 'auto':

if uwsgi_os == 'Linux':

event_mode = 'epoll'

if uwsgi_os == 'SunOS':

event_mode = 'devpoll'

sun_major, sun_minor = uwsgi_os_k.split('.')

if int(sun_major) >= 5:

if int(sun_minor) >= 10:

event_mode = 'port'

elif uwsgi_os in ('Darwin', 'FreeBSD', 'GNU/kFreeBSD', 'OpenBSD', 'NetBSD', 'DragonFly'):

event_mode = 'kqueue'

elif uwsgi_os.startswith('CYGWIN') or uwsgi_os == 'GNU':

event_mode = 'poll'

if event_mode == 'epoll':

self.cflags.append('-DUWSGI_EVENT_USE_EPOLL')

elif event_mode == 'kqueue':

self.cflags.append('-DUWSGI_EVENT_USE_KQUEUE')

elif event_mode == 'devpoll':

self.cflags.append('-DUWSGI_EVENT_USE_DEVPOLL')

elif event_mode == 'port':

self.cflags.append('-DUWSGI_EVENT_USE_PORT')

elif event_mode == 'poll':

self.cflags.append('-DUWSGI_EVENT_USE_POLL')

report['event'] = event_mode

# set timer subsystem

timer_mode = self.get('timer', 'auto')

if timer_mode == 'auto':

if uwsgi_os == 'Linux':

k_all = uwsgi_os_k.split('.')

k_base = k_all[0]

# k_major = k_all[1]

if len(k_all) > 2:

k_minor = k_all[2]

else:

k_minor = 0

if int(k_base) > 2:

timer_mode = 'timerfd'

elif int(k_minor) >= 25:

timer_mode = 'timerfd'

else:

timer_mode = 'none'

elif uwsgi_os == 'SunOS':

sun_major, sun_minor = uwsgi_os_k.split('.')

if int(sun_major) >= 5:

if int(sun_minor) >= 10:

timer_mode = 'port'

elif uwsgi_os in ('Darwin', 'FreeBSD', 'GNU/kFreeBSD', 'OpenBSD', 'NetBSD', 'DragonFly'):

timer_mode = 'kqueue'

if timer_mode == 'timerfd':

self.cflags.append('-DUWSGI_EVENT_TIMER_USE_TIMERFD')

if not self.has_include('sys/timerfd.h'):

self.cflags.append('-DUWSGI_EVENT_TIMER_USE_TIMERFD_NOINC')

elif timer_mode == 'kqueue':

self.cflags.append('-DUWSGI_EVENT_TIMER_USE_KQUEUE')

elif timer_mode == 'port':

self.cflags.append('-DUWSGI_EVENT_TIMER_USE_PORT')

else:

self.cflags.append('-DUWSGI_EVENT_TIMER_USE_NONE')