buildtools/wafsamba/samba_conftests.py

   1 # a set of config tests that use the samba_autoconf functions
   2 # to test for commonly needed configuration options
   3
   4 import os, shutil, re
   5 import Build, Configure, Utils, Options, Logs
   6 from Configure import conf
   7 from samba_utils import TO_LIST, ADD_LD_LIBRARY_PATH
   8
   9
  10 def add_option(self, *k, **kw):
  11     '''syntax help: provide the "match" attribute to opt.add_option() so that folders can be added to specific config tests'''
  12     match = kw.get('match', [])
  13     if match:
  14         del kw['match']
  15     opt = self.parser.add_option(*k, **kw)
  16     opt.match = match
  17     return opt
  18 Options.Handler.add_option = add_option
  19
  20 @conf
  21 def check(self, *k, **kw):
  22     '''Override the waf defaults to inject --with-directory options'''
  23
  24     if not 'env' in kw:
  25         kw['env'] = self.env.copy()
  26
  27     # match the configuration test with specific options, for example:
  28     # --with-libiconv -> Options.options.iconv_open -> "Checking for library iconv"
  29     additional_dirs = []
  30     if 'msg' in kw:
  31         msg = kw['msg']
  32         for x in Options.Handler.parser.parser.option_list:
  33              if getattr(x, 'match', None) and msg in x.match:
  34                  d = getattr(Options.options, x.dest, '')
  35                  if d:
  36                      additional_dirs.append(d)
  37
  38     # we add the additional dirs twice: once for the test data, and again if the compilation test suceeds below
  39     def add_options_dir(dirs, env):
  40         for x in dirs:
  41              if not x in env.CPPPATH:
  42                  env.CPPPATH = [os.path.join(x, 'include')] + env.CPPPATH
  43              if not x in env.LIBPATH:
  44                  env.LIBPATH = [os.path.join(x, 'lib')] + env.LIBPATH
  45
  46     add_options_dir(additional_dirs, kw['env'])
  47
  48     self.validate_c(kw)
  49     self.check_message_1(kw['msg'])
  50     ret = None
  51     try:
  52         ret = self.run_c_code(*k, **kw)
  53     except Configure.ConfigurationError, e:
  54         self.check_message_2(kw['errmsg'], 'YELLOW')
  55         if 'mandatory' in kw and kw['mandatory']:
  56             if Logs.verbose > 1:
  57                 raise
  58             else:
  59                 self.fatal('the configuration failed (see %r)' % self.log.name)
  60     else:
  61         kw['success'] = ret
  62         self.check_message_2(self.ret_msg(kw['okmsg'], kw))
  63
  64         # success! keep the CPPPATH/LIBPATH
  65         add_options_dir(additional_dirs, self.env)
  66
  67     self.post_check(*k, **kw)
  68     if not kw.get('execute', False):
  69         return ret == 0
  70     return ret
  71
  72
  73 @conf
  74 def CHECK_ICONV(conf, define='HAVE_NATIVE_ICONV'):
  75     '''check if the iconv library is installed
  76        optionally pass a define'''
  77     if conf.CHECK_FUNCS_IN('iconv_open', 'iconv', checklibc=True, headers='iconv.h'):
  78         conf.DEFINE(define, 1)
  79         return True
  80     return False
  81
  82
  83 @conf
  84 def CHECK_LARGEFILE(conf, define='HAVE_LARGEFILE'):
  85     '''see what we need for largefile support'''
  86     getconf_cflags = conf.CHECK_COMMAND(['getconf', 'LFS_CFLAGS']);
  87     if getconf_cflags is not False:
  88         if (conf.CHECK_CODE('return !(sizeof(off_t) >= 8)',
  89                             define='WORKING_GETCONF_LFS_CFLAGS',
  90                             execute=True,
  91                             cflags=getconf_cflags,
  92                             msg='Checking getconf large file support flags work')):
  93             conf.ADD_CFLAGS(getconf_cflags)
  94             getconf_cflags_list=TO_LIST(getconf_cflags)
  95             for flag in getconf_cflags_list:
  96                 if flag[:2] == "-D":
  97                     flag_split = flag[2:].split('=')
  98                     if len(flag_split) == 1:
  99                         conf.DEFINE(flag_split[0], '1')
 100                     else:
 101                         conf.DEFINE(flag_split[0], flag_split[1])
 102
 103     if conf.CHECK_CODE('return !(sizeof(off_t) >= 8)',
 104                        define,
 105                        execute=True,
 106                        msg='Checking for large file support without additional flags'):
 107         return True
 108
 109     if conf.CHECK_CODE('return !(sizeof(off_t) >= 8)',
 110                        define,
 111                        execute=True,
 112                        cflags='-D_FILE_OFFSET_BITS=64',
 113                        msg='Checking for -D_FILE_OFFSET_BITS=64'):
 114         conf.DEFINE('_FILE_OFFSET_BITS', 64)
 115         return True
 116
 117     if conf.CHECK_CODE('return !(sizeof(off_t) >= 8)',
 118                        define,
 119                        execute=True,
 120                        cflags='-D_LARGE_FILES',
 121                        msg='Checking for -D_LARGE_FILES'):
 122         conf.DEFINE('_LARGE_FILES', 1)
 123         return True
 124     return False
 125
 126
 127 @conf
 128 def CHECK_C_PROTOTYPE(conf, function, prototype, define, headers=None, msg=None):
 129     '''verify that a C prototype matches the one on the current system'''
 130     if not conf.CHECK_DECLS(function, headers=headers):
 131         return False
 132     if not msg:
 133         msg = 'Checking C prototype for %s' % function
 134     return conf.CHECK_CODE('%s; void *_x = (void *)%s' % (prototype, function),
 135                            define=define,
 136                            local_include=False,
 137                            headers=headers,
 138                            link=False,
 139                            execute=False,
 140                            msg=msg)
 141
 142
 143 @conf
 144 def CHECK_CHARSET_EXISTS(conf, charset, outcharset='UCS-2LE', headers=None, define=None):
 145     '''check that a named charset is able to be used with iconv_open() for conversion
 146     to a target charset
 147     '''
 148     msg = 'Checking if can we convert from %s to %s' % (charset, outcharset)
 149     if define is None:
 150         define = 'HAVE_CHARSET_%s' % charset.upper().replace('-','_')
 151     return conf.CHECK_CODE('''
 152                            iconv_t cd = iconv_open("%s", "%s");
 153                            if (cd == 0 || cd == (iconv_t)-1) return -1;
 154                            ''' % (charset, outcharset),
 155                            define=define,
 156                            execute=True,
 157                            msg=msg,
 158                            lib='iconv',
 159                            headers=headers)
 160
 161 def find_config_dir(conf):
 162     '''find a directory to run tests in'''
 163     k = 0
 164     while k < 10000:
 165         dir = os.path.join(conf.blddir, '.conf_check_%d' % k)
 166         try:
 167             shutil.rmtree(dir)
 168         except OSError:
 169             pass
 170         try:
 171             os.stat(dir)
 172         except:
 173             break
 174         k += 1
 175
 176     try:
 177         os.makedirs(dir)
 178     except:
 179         conf.fatal('cannot create a configuration test folder %r' % dir)
 180
 181     try:
 182         os.stat(dir)
 183     except:
 184         conf.fatal('cannot use the configuration test folder %r' % dir)
 185     return dir
 186
 187 @conf
 188 def CHECK_SHLIB_INTRASINC_NAME_FLAGS(conf, msg):
 189     '''
 190         check if the waf default flags for setting the name of lib
 191         are ok
 192     '''
 193
 194     snip = '''
 195 int foo(int v) {
 196     return v * 2;
 197 }
 198 '''
 199     return conf.check(features='c cshlib',vnum="1",fragment=snip,msg=msg, mandatory=False)
 200
 201 @conf
 202 def CHECK_NEED_LC(conf, msg):
 203     '''check if we need -lc'''
 204
 205     dir = find_config_dir(conf)
 206
 207     env = conf.env
 208
 209     bdir = os.path.join(dir, 'testbuild2')
 210     if not os.path.exists(bdir):
 211         os.makedirs(bdir)
 212
 213
 214     subdir = os.path.join(dir, "liblctest")
 215
 216     os.makedirs(subdir)
 217
 218     Utils.writef(os.path.join(subdir, 'liblc1.c'), '#include <stdio.h>\nint lib_func(void) { FILE *f = fopen("foo", "r");}\n')
 219
 220     bld = Build.BuildContext()
 221     bld.log = conf.log
 222     bld.all_envs.update(conf.all_envs)
 223     bld.all_envs['default'] = env
 224     bld.lst_variants = bld.all_envs.keys()
 225     bld.load_dirs(dir, bdir)
 226
 227     bld.rescan(bld.srcnode)
 228
 229     bld(features='c cshlib',
 230         source='liblctest/liblc1.c',
 231         ldflags=conf.env['EXTRA_LDFLAGS'],
 232         target='liblc',
 233         name='liblc')
 234
 235     try:
 236         bld.compile()
 237         conf.check_message(msg, '', True)
 238         return True
 239     except:
 240         conf.check_message(msg, '', False)
 241         return False
 242
 243
 244 @conf
 245 def CHECK_SHLIB_W_PYTHON(conf, msg):
 246     '''check if we need -undefined dynamic_lookup'''
 247
 248     dir = find_config_dir(conf)
 249     snip = '''
 250 #include <Python.h>
 251 #include <crt_externs.h>
 252 #define environ (*_NSGetEnviron())
 253
 254 static PyObject *ldb_module = NULL;
 255 int foo(int v) {
 256     extern char **environ;
 257     environ[0] = 1;
 258     ldb_module = PyImport_ImportModule("ldb");
 259     return v * 2;
 260 }'''
 261     return conf.check(features='c cshlib',uselib='PYEMBED',fragment=snip,msg=msg, mandatory=False)
 262
 263 # this one is quite complex, and should probably be broken up
 264 # into several parts. I'd quite like to create a set of CHECK_COMPOUND()
 265 # functions that make writing complex compound tests like this much easier
 266 @conf
 267 def CHECK_LIBRARY_SUPPORT(conf, rpath=False, version_script=False, msg=None):
 268     '''see if the platform supports building libraries'''
 269
 270     if msg is None:
 271         if rpath:
 272             msg = "rpath library support"
 273         else:
 274             msg = "building library support"
 275
 276     dir = find_config_dir(conf)
 277
 278     bdir = os.path.join(dir, 'testbuild')
 279     if not os.path.exists(bdir):
 280         os.makedirs(bdir)
 281
 282     env = conf.env
 283
 284     subdir = os.path.join(dir, "libdir")
 285
 286     os.makedirs(subdir)
 287
 288     Utils.writef(os.path.join(subdir, 'lib1.c'), 'int lib_func(void) { return 42; }\n')
 289     Utils.writef(os.path.join(dir, 'main.c'),
 290                  'int lib_func(void);\n'
 291                  'int main(void) {return !(lib_func() == 42);}\n')
 292
 293     bld = Build.BuildContext()
 294     bld.log = conf.log
 295     bld.all_envs.update(conf.all_envs)
 296     bld.all_envs['default'] = env
 297     bld.lst_variants = bld.all_envs.keys()
 298     bld.load_dirs(dir, bdir)
 299
 300     bld.rescan(bld.srcnode)
 301
 302     ldflags = []
 303     if version_script:
 304         ldflags.append("-Wl,--version-script=%s/vscript" % bld.path.abspath())
 305         Utils.writef(os.path.join(dir,'vscript'), 'TEST_1.0A2 { global: *; };\n')
 306
 307     bld(features='c cshlib',
 308         source='libdir/lib1.c',
 309         target='libdir/lib1',
 310         ldflags=ldflags,
 311         name='lib1')
 312
 313     o = bld(features='c cprogram',
 314             source='main.c',
 315             target='prog1',
 316             uselib_local='lib1')
 317
 318     if rpath:
 319         o.rpath=os.path.join(bdir, 'default/libdir')
 320
 321     # compile the program
 322     try:
 323         bld.compile()
 324     except:
 325         conf.check_message(msg, '', False)
 326         return False
 327
 328     # path for execution
 329     lastprog = o.link_task.outputs[0].abspath(env)
 330
 331     if not rpath:
 332         if 'LD_LIBRARY_PATH' in os.environ:
 333             old_ld_library_path = os.environ['LD_LIBRARY_PATH']
 334         else:
 335             old_ld_library_path = None
 336         ADD_LD_LIBRARY_PATH(os.path.join(bdir, 'default/libdir'))
 337
 338     # we need to run the program, try to get its result
 339     args = conf.SAMBA_CROSS_ARGS(msg=msg)
 340     proc = Utils.pproc.Popen([lastprog] + args, stdout=Utils.pproc.PIPE, stderr=Utils.pproc.PIPE)
 341     (out, err) = proc.communicate()
 342     w = conf.log.write
 343     w(str(out))
 344     w('\n')
 345     w(str(err))
 346     w('\nreturncode %r\n' % proc.returncode)
 347     ret = (proc.returncode == 0)
 348
 349     if not rpath:
 350         os.environ['LD_LIBRARY_PATH'] = old_ld_library_path or ''
 351
 352     conf.check_message(msg, '', ret)
 353     return ret
 354
 355
 356
 357 @conf
 358 def CHECK_PERL_MANPAGE(conf, msg=None, section=None):
 359     '''work out what extension perl uses for manpages'''
 360
 361     if msg is None:
 362         if section:
 363             msg = "perl man%s extension" % section
 364         else:
 365             msg = "perl manpage generation"
 366
 367     conf.check_message_1(msg)
 368
 369     dir = find_config_dir(conf)
 370
 371     bdir = os.path.join(dir, 'testbuild')
 372     if not os.path.exists(bdir):
 373         os.makedirs(bdir)
 374
 375     Utils.writef(os.path.join(bdir, 'Makefile.PL'), """
 376 use ExtUtils::MakeMaker;
 377 WriteMakefile(
 378     'NAME'    => 'WafTest',
 379     'EXE_FILES' => [ 'WafTest' ]
 380 );
 381 """)
 382     back = os.path.abspath('.')
 383     os.chdir(bdir)
 384     proc = Utils.pproc.Popen(['perl', 'Makefile.PL'],
 385                              stdout=Utils.pproc.PIPE,
 386                              stderr=Utils.pproc.PIPE)
 387     (out, err) = proc.communicate()
 388     os.chdir(back)
 389
 390     ret = (proc.returncode == 0)
 391     if not ret:
 392         conf.check_message_2('not found', color='YELLOW')
 393         return
 394
 395     if section:
 396         man = Utils.readf(os.path.join(bdir,'Makefile'))
 397         m = re.search('MAN%sEXT\s+=\s+(\w+)' % section, man)
 398         if not m:
 399             conf.check_message_2('not found', color='YELLOW')
 400             return
 401         ext = m.group(1)
 402         conf.check_message_2(ext)
 403         return ext
 404
 405     conf.check_message_2('ok')
 406     return True
 407
 408
 409 @conf
 410 def CHECK_COMMAND(conf, cmd, msg=None, define=None, on_target=True, boolean=False):
 411     '''run a command and return result'''
 412     if msg is None:
 413         msg = 'Checking %s' % ' '.join(cmd)
 414     conf.COMPOUND_START(msg)
 415     cmd = cmd[:]
 416     if on_target:
 417         cmd.extend(conf.SAMBA_CROSS_ARGS(msg=msg))
 418     try:
 419         ret = Utils.cmd_output(cmd)
 420     except:
 421         conf.COMPOUND_END(False)
 422         return False
 423     if boolean:
 424         conf.COMPOUND_END('ok')
 425         if define:
 426             conf.DEFINE(define, '1')
 427     else:
 428         ret = ret.strip()
 429         conf.COMPOUND_END(ret)
 430         if define:
 431             conf.DEFINE(define, ret, quote=True)
 432     return ret
 433
 434
 435 @conf
 436 def CHECK_UNAME(conf):
 437     '''setup SYSTEM_UNAME_* defines'''
 438     ret = True
 439     for v in "sysname machine release version".split():
 440         if not conf.CHECK_CODE('''
 441                                int printf(const char *format, ...);
 442                                struct utsname n;
 443                                if (uname(&n) == -1) return -1;
 444                                printf("%%s", n.%s);
 445                                ''' % v,
 446                                define='SYSTEM_UNAME_%s' % v.upper(),
 447                                execute=True,
 448                                define_ret=True,
 449                                quote=True,
 450                                headers='sys/utsname.h',
 451                                local_include=False,
 452                                msg="Checking uname %s type" % v):
 453             ret = False
 454     return ret
 455
 456 @conf
 457 def CHECK_INLINE(conf):
 458     '''check for the right value for inline'''
 459     conf.COMPOUND_START('Checking for inline')
 460     for i in ['inline', '__inline__', '__inline']:
 461         ret = conf.CHECK_CODE('''
 462         typedef int foo_t;
 463         static %s foo_t static_foo () {return 0; }
 464         %s foo_t foo () {return 0; }''' % (i, i),
 465                               define='INLINE_MACRO',
 466                               addmain=False,
 467                               link=False)
 468         if ret:
 469             if i != 'inline':
 470                 conf.DEFINE('inline', i, quote=False)
 471             break
 472     if not ret:
 473         conf.COMPOUND_END(ret)
 474     else:
 475         conf.COMPOUND_END(i)
 476     return ret
 477
 478 @conf
 479 def CHECK_XSLTPROC_MANPAGES(conf):
 480     '''check if xsltproc can run with the given stylesheets'''
 481
 482
 483     if not conf.CONFIG_SET('XSLTPROC'):
 484         conf.find_program('xsltproc', var='XSLTPROC')
 485     if not conf.CONFIG_SET('XSLTPROC'):
 486         return False
 487
 488     s='http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl'
 489     conf.CHECK_COMMAND('%s --nonet %s 2> /dev/null' % (conf.env.XSLTPROC, s),
 490                              msg='Checking for stylesheet %s' % s,
 491                              define='XSLTPROC_MANPAGES', on_target=False,
 492                              boolean=True)
 493     if not conf.CONFIG_SET('XSLTPROC_MANPAGES'):
 494         print "A local copy of the docbook.xsl wasn't found on your system" \
 495               " consider installing package like docbook-xsl"
 496
 497 #
 498 # Determine the standard libpath for the used compiler,
 499 # so we can later use that to filter out these standard
 500 # library paths when some tools like cups-config or
 501 # python-config report standard lib paths with their
 502 # ldflags (-L...)
 503 #
 504 @conf
 505 def CHECK_STANDARD_LIBPATH(conf):
 506     # at least gcc and clang support this:
 507     try:
 508         cmd = conf.env.CC + ['-print-search-dirs']
 509         out = Utils.cmd_output(cmd).split('\n')
 510     except ValueError:
 511         # option not supported by compiler - use a standard list of directories
 512         dirlist = [ '/usr/lib', '/usr/lib64' ]
 513     except:
 514         raise Utils.WafError('Unexpected error running "%s"' % (cmd))
 515     else:
 516         dirlist = []
 517         for line in out:
 518             line = line.strip()
 519             if line.startswith("libraries: ="):
 520                 dirliststr = line[len("libraries: ="):]
 521                 dirlist = [ os.path.normpath(x) for x in dirliststr.split(':') ]
 522                 break
 523
 524     conf.env.STANDARD_LIBPATH = dirlist
 525