import os.path

import sys

import test.support

import unittest

import unittest.mock

from ctypes import CDLL, RTLD_GLOBAL

from ctypes.util import find_library

from test.support import os_helper, thread_unsafe

# On some systems, loading the OpenGL libraries needs the RTLD_GLOBAL mode.

class Test_OpenGL_libs(unittest.TestCase):

@classmethod

def setUpClass(cls):

lib_gl = lib_glu = lib_gle = None

if sys.platform == "win32":

lib_gl = find_library("OpenGL32")

lib_glu = find_library("Glu32")

elif sys.platform == "darwin":

lib_gl = lib_glu = find_library("OpenGL")

else:

lib_gl = find_library("GL")

lib_glu = find_library("GLU")

lib_gle = find_library("gle")

# print, for debugging

if test.support.verbose:

print("OpenGL libraries:")

for item in (("GL", lib_gl),

("GLU", lib_glu),

("gle", lib_gle)):

print("\t", item)

cls.gl = cls.glu = cls.gle = None

if lib_gl:

try:

cls.gl = CDLL(lib_gl, mode=RTLD_GLOBAL)

except OSError:

pass

if lib_glu:

try:

cls.glu = CDLL(lib_glu, RTLD_GLOBAL)

except OSError:

pass

if lib_gle:

try:

cls.gle = CDLL(lib_gle)

except OSError:

pass

@classmethod

def tearDownClass(cls):

cls.gl = cls.glu = cls.gle = None

def test_gl(self):

if self.gl is None:

self.skipTest('lib_gl not available')

self.gl.glClearIndex

def test_glu(self):

if self.glu is None:

self.skipTest('lib_glu not available')

self.glu.gluBeginCurve

def test_gle(self):

if self.gle is None:

self.skipTest('lib_gle not available')

self.gle.gleGetJoinStyle

def test_shell_injection(self):

result = find_library('; echo Hello shell > ' + os_helper.TESTFN)

self.assertFalse(os.path.lexists(os_helper.TESTFN))

self.assertIsNone(result)

@unittest.skipUnless(sys.platform.startswith('linux'),

'Test only valid for Linux')

class FindLibraryLinux(unittest.TestCase):

@thread_unsafe('uses setenv')

def test_find_on_libpath(self):

import subprocess

import tempfile

try:

p = subprocess.Popen(['gcc', '--version'], stdout=subprocess.PIPE,

stderr=subprocess.DEVNULL)

out, _ = p.communicate()

except OSError:

raise unittest.SkipTest('gcc, needed for test, not available')

with tempfile.TemporaryDirectory() as d:

# create an empty temporary file

srcname = os.path.join(d, 'dummy.c')

libname = 'py_ctypes_test_dummy'

dstname = os.path.join(d, 'lib%s.so' % libname)

with open(srcname, 'wb') as f:

pass

self.assertTrue(os.path.exists(srcname))

# compile the file to a shared library

cmd = ['gcc', '-o', dstname, '--shared',

'-Wl,-soname,lib%s.so' % libname, srcname]

out = subprocess.check_output(cmd)

self.assertTrue(os.path.exists(dstname))

# now check that the .so can't be found (since not in

# LD_LIBRARY_PATH)

self.assertIsNone(find_library(libname))

# now add the location to LD_LIBRARY_PATH

with os_helper.EnvironmentVarGuard() as env:

KEY = 'LD_LIBRARY_PATH'

if KEY not in env:

v = d

else:

v = '%s:%s' % (env[KEY], d)

env.set(KEY, v)

# now check that the .so can be found (since in

# LD_LIBRARY_PATH)

self.assertEqual(find_library(libname), 'lib%s.so' % libname)

def test_find_library_with_gcc(self):

with unittest.mock.patch("ctypes.util._findSoname_ldconfig", lambda *args: None):

self.assertNotEqual(find_library('c'), None)

def test_find_library_with_ld(self):

with unittest.mock.patch("ctypes.util._findSoname_ldconfig", lambda *args: None), \

unittest.mock.patch("ctypes.util._findLib_gcc", lambda *args: None):

self.assertNotEqual(find_library('c'), None)

def test_gh114257(self):

self.assertIsNone(find_library("libc"))

@unittest.skipUnless(sys.platform == 'android', 'Test only valid for Android')

class FindLibraryAndroid(unittest.TestCase):

def test_find(self):

for name in [

"c", "m", # POSIX

"z", # Non-POSIX, but present on Linux

"log", # Not present on Linux

]:

with self.subTest(name=name):

path = find_library(name)

self.assertIsInstance(path, str)

self.assertEqual(

os.path.dirname(path),

"/system/lib64" if "64" in os.uname().machine

else "/system/lib")

self.assertEqual(os.path.basename(path), f"lib{name}.so")

self.assertTrue(os.path.isfile(path), path)

for name in ["libc", "nonexistent"]:

with self.subTest(name=name):

self.assertIsNone(find_library(name))

@unittest.skipUnless(test.support.is_emscripten,

'Test only valid for Emscripten')

class FindLibraryEmscripten(unittest.TestCase):

@classmethod

def setUpClass(cls):

import tempfile

# A very simple wasm module

# In WAT format: (module)

cls.wasm_module = b'\x00asm\x01\x00\x00\x00\x00\x08\x04name\x02\x01\x00'

cls.non_wasm_content = b'This is not a WASM file'

cls.temp_dir = tempfile.mkdtemp()

cls.libdummy_so_path = os.path.join(cls.temp_dir, 'libdummy.so')

with open(cls.libdummy_so_path, 'wb') as f:

f.write(cls.wasm_module)

cls.libother_wasm_path = os.path.join(cls.temp_dir, 'libother.wasm')

with open(cls.libother_wasm_path, 'wb') as f:

f.write(cls.wasm_module)

cls.libnowasm_so_path = os.path.join(cls.temp_dir, 'libnowasm.so')

with open(cls.libnowasm_so_path, 'wb') as f:

f.write(cls.non_wasm_content)

@classmethod

def tearDownClass(cls):

import shutil

shutil.rmtree(cls.temp_dir)

def test_find_wasm_file_with_so_extension(self):

with os_helper.EnvironmentVarGuard() as env:

env.set('LD_LIBRARY_PATH', self.temp_dir)

result = find_library('dummy')

self.assertEqual(result, self.libdummy_so_path)

def test_find_wasm_file_with_wasm_extension(self):

with os_helper.EnvironmentVarGuard() as env:

env.set('LD_LIBRARY_PATH', self.temp_dir)

result = find_library('other')

self.assertEqual(result, self.libother_wasm_path)

def test_ignore_non_wasm_file(self):

with os_helper.EnvironmentVarGuard() as env:

env.set('LD_LIBRARY_PATH', self.temp_dir)

result = find_library('nowasm')

self.assertIsNone(result)

def test_find_nothing_without_ld_library_path(self):

with os_helper.EnvironmentVarGuard() as env:

if 'LD_LIBRARY_PATH' in env:

del env['LD_LIBRARY_PATH']

result = find_library('dummy')

self.assertIsNone(result)

result = find_library('other')

self.assertIsNone(result)

def test_find_nothing_with_wrong_ld_library_path(self):

import tempfile

with tempfile.TemporaryDirectory() as empty_dir:

with os_helper.EnvironmentVarGuard() as env:

env.set('LD_LIBRARY_PATH', empty_dir)

result = find_library('dummy')

self.assertIsNone(result)

result = find_library('other')

self.assertIsNone(result)

if __name__ == "__main__":

unittest.main()