def runs_ctgetstr():
p_errret = lltype.malloc(rffi.INTP.TO, 1, flavor='raw')
with rffi.scoped_str2charp("xterm") as ll_term:
errval = fficurses.setupterm(ll_term, 1, p_errret)
with rffi.scoped_str2charp("cup") as ll_capname:
ll = fficurses.rpy_curses_tigetstr(ll_capname)
return rffi.charp2str(ll)
def test_encode_decimal(self, space, api):
with rffi.scoped_unicode2wcharp(u' (12, 35 ABC)') as u:
with rffi.scoped_alloc_buffer(20) as buf:
res = api.PyUnicode_EncodeDecimal(u, 13, buf.raw, None)
s = rffi.charp2str(buf.raw)
assert res == 0
assert s == ' (12, 35 ABC)'
with rffi.scoped_unicode2wcharp(u' (12, \u1234\u1235)') as u:
with rffi.scoped_alloc_buffer(20) as buf:
res = api.PyUnicode_EncodeDecimal(u, 9, buf.raw, None)
assert res == -1
api.PyErr_Clear()
with rffi.scoped_unicode2wcharp(u' (12, \u1234\u1235)') as u:
with rffi.scoped_alloc_buffer(20) as buf:
with rffi.scoped_str2charp("replace") as errors:
res = api.PyUnicode_EncodeDecimal(u, 9, buf.raw, errors)
s = rffi.charp2str(buf.raw)
assert res == 0
assert s == " (12, ??)"
with rffi.scoped_unicode2wcharp(u'12\u1234') as u:
with rffi.scoped_alloc_buffer(20) as buf:
with rffi.scoped_str2charp("xmlcharrefreplace") as errors:
res = api.PyUnicode_EncodeDecimal(u, 3, buf.raw, errors)
s = rffi.charp2str(buf.raw)
assert res == 0
assert s == "12ሴ"
def test_encode_decimal(self, space):
with rffi.scoped_unicode2wcharp(u' (12, 35 ABC)') as u:
with rffi.scoped_alloc_buffer(20) as buf:
res = PyUnicode_EncodeDecimal(space, u, 13, buf.raw, None)
s = rffi.charp2str(buf.raw)
assert res == 0
assert s == ' (12, 35 ABC)'
with rffi.scoped_unicode2wcharp(u' (12, \u1234\u1235)') as u:
with rffi.scoped_alloc_buffer(20) as buf:
with pytest.raises(OperationError):
PyUnicode_EncodeDecimal(space, u, 9, buf.raw, None)
with rffi.scoped_unicode2wcharp(u' (12, \u1234\u1235)') as u:
with rffi.scoped_alloc_buffer(20) as buf:
with rffi.scoped_str2charp("replace") as errors:
res = PyUnicode_EncodeDecimal(space, u, 9, buf.raw, errors)
s = rffi.charp2str(buf.raw)
assert res == 0
assert s == " (12, ??)"
with rffi.scoped_unicode2wcharp(u'12\u1234') as u:
with rffi.scoped_alloc_buffer(20) as buf:
with rffi.scoped_str2charp("xmlcharrefreplace") as errors:
res = PyUnicode_EncodeDecimal(space, u, 3, buf.raw, errors)
s = rffi.charp2str(buf.raw)
assert res == 0
assert s == "12ሴ"
def spawn(loop, process, file, args, env, streams):
"""
The file descriptor list should be a list of streams to wire up to FDs in
the child. A None stream is mapped to UV_IGNORE.
"""
with rffi.scoped_str2charp(file) as rawFile:
rawArgs = rffi.liststr2charpp(args)
rawEnv = rffi.liststr2charpp(env)
with rffi.scoped_str2charp(".") as rawCWD:
options = rffi.make(cConfig["process_options_t"], c_file=rawFile,
c_args=rawArgs, c_env=rawEnv, c_cwd=rawCWD)
with lltype.scoped_alloc(rffi.CArray(stdio_container_t),
len(streams)) as rawStreams:
for i, stream in enumerate(streams):
if stream == lltype.nullptr(stream_t):
flags = UV_IGNORE
else:
flags = UV_CREATE_PIPE
if i == 0:
flags |= UV_READABLE_PIPE
elif i in (1, 2):
flags |= UV_WRITABLE_PIPE
set_stdio_stream(rawStreams[i], stream)
rffi.setintfield(rawStreams[i], "c_flags", flags)
options.c_stdio = rawStreams
rffi.setintfield(options, "c_stdio_count", len(streams))
add_exit_cb(options, processDiscard)
rffi.setintfield(options, "c_flags", UV_PROCESS_WINDOWS_HIDE)
rv = uv_spawn(loop, process, options)
free(options)
rffi.free_charpp(rawEnv)
rffi.free_charpp(rawArgs)
check("spawn", rv)
def test_encode_decimal(self, space, api):
with rffi.scoped_unicode2wcharp(u' (12, 35 ABC)') as u:
with rffi.scoped_alloc_buffer(20) as buf:
res = api.PyUnicode_EncodeDecimal(u, 13, buf.raw, None)
s = rffi.charp2str(buf.raw)
assert res == 0
assert s == ' (12, 35 ABC)'
with rffi.scoped_unicode2wcharp(u' (12, \u1234\u1235)') as u:
with rffi.scoped_alloc_buffer(20) as buf:
res = api.PyUnicode_EncodeDecimal(u, 9, buf.raw, None)
assert res == -1
api.PyErr_Clear()
with rffi.scoped_unicode2wcharp(u' (12, \u1234\u1235)') as u:
with rffi.scoped_alloc_buffer(20) as buf:
with rffi.scoped_str2charp("replace") as errors:
res = api.PyUnicode_EncodeDecimal(u, 9, buf.raw,
errors)
s = rffi.charp2str(buf.raw)
assert res == 0
assert s == " (12, ??)"
with rffi.scoped_unicode2wcharp(u'12\u1234') as u:
with rffi.scoped_alloc_buffer(20) as buf:
with rffi.scoped_str2charp("xmlcharrefreplace") as errors:
res = api.PyUnicode_EncodeDecimal(u, 3, buf.raw,
errors)
s = rffi.charp2str(buf.raw)
assert res == 0
assert s == "12ሴ"
def spawn(loop, process, file, args, env, streams):
"""
The file descriptor list should be a list of streams to wire up to FDs in
the child. A None stream is mapped to UV_IGNORE.
"""
with rffi.scoped_str2charp(file) as rawFile:
rawArgs = rffi.liststr2charpp(args)
rawEnv = rffi.liststr2charpp(env)
with rffi.scoped_str2charp(".") as rawCWD:
options = rffi.make(cConfig["process_options_t"], c_file=rawFile,
c_args=rawArgs, c_env=rawEnv, c_cwd=rawCWD)
with lltype.scoped_alloc(rffi.CArray(stdio_container_t), len(streams)) as rawStreams:
for i, stream in enumerate(streams):
if stream == lltype.nullptr(stream_t):
flags = UV_IGNORE
else:
flags = UV_CREATE_PIPE
if i == 0:
flags |= UV_READABLE_PIPE
elif i in (1, 2):
flags |= UV_WRITABLE_PIPE
set_stdio_stream(rawStreams[i], stream)
rffi.setintfield(rawStreams[i], "c_flags", flags)
options.c_stdio = rawStreams
rffi.setintfield(options, "c_stdio_count", len(streams))
add_exit_cb(options, processDiscard)
rffi.setintfield(options, "c_flags", UV_PROCESS_WINDOWS_HIDE)
rv = uv_spawn(loop, process, options)
free(options)
rffi.free_charpp(rawEnv)
rffi.free_charpp(rawArgs)
check("spawn", rv)
def runs_tparm():
with rffi.scoped_str2charp("xterm") as ll_term:
fficurses.rpy_curses_setupterm(ll_term, 1)
with rffi.scoped_str2charp("cup") as ll_capname:
cup = fficurses.rpy_curses_tigetstr(ll_capname)
res = fficurses.rpy_curses_tparm(cup, 5, 3, 0, 0, 0, 0, 0, 0,
0)
return rffi.charp2str(res)
def test_charp(self):
sb = StringBuilderRepr.ll_new(32)
with rffi.scoped_str2charp("hello world") as p:
StringBuilderRepr.ll_append_charpsize(sb, p, 12)
with rffi.scoped_str2charp("0123456789abcdefghijklmn") as p:
StringBuilderRepr.ll_append_charpsize(sb, p, 24)
s = StringBuilderRepr.ll_build(sb)
assert hlstr(s) == "hello world\x000123456789abcdefghijklmn"
def test_charp(self):
sb = StringBuilderRepr.ll_new(32)
with rffi.scoped_str2charp("hello world") as p:
StringBuilderRepr.ll_append_charpsize(sb, p, 12)
with rffi.scoped_str2charp("0123456789abcdefghijklmn") as p:
StringBuilderRepr.ll_append_charpsize(sb, p, 24)
s = StringBuilderRepr.ll_build(sb)
assert hlstr(s) == "hello world\x000123456789abcdefghijklmn"
def test_addmodule(self, space, api):
with rffi.scoped_str2charp("sys") as modname:
w_sys = api.PyImport_AddModule(modname)
assert w_sys is space.sys
with rffi.scoped_str2charp("foobar") as modname:
w_foobar = api.PyImport_AddModule(modname)
assert space.str_w(space.getattr(w_foobar,
space.wrap('__name__'))) == 'foobar'
def test_unpack(self, space, api):
with rffi.scoped_str2charp("\x9a\x99\x99?") as ptr:
assert abs(api._PyFloat_Unpack4(ptr, 1) - 1.2) < 1e-7
with rffi.scoped_str2charp("?\x99\x99\x9a") as ptr:
assert abs(api._PyFloat_Unpack4(ptr, 0) - 1.2) < 1e-7
with rffi.scoped_str2charp("\x1f\x85\xebQ\xb8\x1e\t@") as ptr:
assert abs(api._PyFloat_Unpack8(ptr, 1) - 3.14) < 1e-15
with rffi.scoped_str2charp("@\t\x1e\xb8Q\xeb\x85\x1f") as ptr:
assert abs(api._PyFloat_Unpack8(ptr, 0) - 3.14) < 1e-15
def test_unpack(self, space):
with rffi.scoped_str2charp("\x9a\x99\x99?") as ptr:
assert abs(_PyFloat_Unpack4(space, ptr, 1) - 1.2) < 1e-7
with rffi.scoped_str2charp("?\x99\x99\x9a") as ptr:
assert abs(_PyFloat_Unpack4(space, ptr, 0) - 1.2) < 1e-7
with rffi.scoped_str2charp("\x1f\x85\xebQ\xb8\x1e\t@") as ptr:
assert abs(_PyFloat_Unpack8(space, ptr, 1) - 3.14) < 1e-15
with rffi.scoped_str2charp("@\t\x1e\xb8Q\xeb\x85\x1f") as ptr:
assert abs(_PyFloat_Unpack8(space, ptr, 0) - 3.14) < 1e-15
def test_addmodule(self, space):
with rffi.scoped_str2charp("sys") as modname:
w_sys = PyImport_AddModule(space, modname)
assert w_sys is space.sys
with rffi.scoped_str2charp("foobar") as modname:
w_foobar = PyImport_AddModule(space, modname)
assert space.str_w(space.getattr(w_foobar,
space.wrap('__name__'))) == 'foobar'
def test_file_fromfile(self, space, api):
name = str(udir / "_test_file")
with rffi.scoped_str2charp(name) as filename:
with rffi.scoped_str2charp("wb") as mode:
w_file = api.PyFile_FromString(filename, mode)
fp = api.PyFile_AsFile(w_file)
assert fp is not None
w_file2 = api.PyFile_FromFile(fp, filename, mode, None)
assert w_file2 is not None
assert PyFile_Check(space, w_file2)
assert space.str_w(api.PyFile_Name(w_file2)) == name
def test_file_fromfile(self, space, api):
name = str(udir / "_test_file")
with rffi.scoped_str2charp(name) as filename:
with rffi.scoped_str2charp("wb") as mode:
w_file = api.PyFile_FromString(filename, mode)
fp = api.PyFile_AsFile(w_file)
assert fp is not None
w_file2 = api.PyFile_FromFile(fp, filename, mode, None)
assert w_file2 is not None
assert api.PyFile_Check(w_file2)
assert space.str_w(api.PyFile_Name(w_file2)) == name
def boxSeal(message, nonce, public, secret):
cipherSize = len(message) + intmask(cryptoBoxMacbytes())
with rffi.scoped_alloc_buffer(cipherSize) as cipher:
with rffi.scoped_str2charp(message) as rawMessage:
with rffi.scoped_str2charp(nonce) as rawNonce:
with rffi.scoped_str2charp(public) as rawPublic:
with rffi.scoped_str2charp(secret) as rawSecret:
rv = cryptoBoxEasy(cipher.raw, rawMessage,
len(message), rawNonce, rawPublic,
rawSecret)
if rv:
raise SodiumError("crypto_box_easy: %d" % rv)
return cipher.str(cipherSize)
def boxUnseal(cipher, nonce, public, secret):
messageSize = len(cipher) - intmask(cryptoBoxMacbytes())
assert messageSize >= 0
with rffi.scoped_alloc_buffer(messageSize) as message:
with rffi.scoped_str2charp(cipher) as rawCipher:
with rffi.scoped_str2charp(nonce) as rawNonce:
with rffi.scoped_str2charp(public) as rawPublic:
with rffi.scoped_str2charp(secret) as rawSecret:
rv = cryptoBoxOpenEasy(message.raw, rawCipher,
len(cipher), rawNonce,
rawPublic, rawSecret)
if rv:
raise SodiumError("crypto_box_open_easy: %d" % rv)
return message.str(messageSize)
def str_interval_to_time(s):
if len(s) == 0:
raise IntervalToTimeException
with rffi.scoped_str2charp(s) as ll_s:
error_c = lltype.malloc(timelib_error_containerP.TO, 1, flavor='raw')
ll_res = timelib_strtotime(ll_s, len(s), error_c, timelib_builtin_db(),
tzinfo_callback)
error_count = rffi.cast(lltype.Signed, error_c[0].c_error_count)
error = error_c[0]
lltype.free(error_c, flavor='raw')
if error_count != 0:
if DEBUG:
print(
rffi.charp2str(error.c_error_messages[0].c_message), "at",
rffi.cast(lltype.Signed,
error.c_error_messages[0].c_position))
timelib_error_container_dtor(error)
raise IntervalToTimeException
if rffi.cast(lltype.Signed, error.c_warning_count) != 0:
pass
res = (ll_res.c_relative.c_y, ll_res.c_relative.c_m,
ll_res.c_relative.c_d, ll_res.c_relative.c_h,
ll_res.c_relative.c_i, ll_res.c_relative.c_s)
timelib_error_container_dtor(error)
timelib_time_dtor(ll_res)
return res
def setsockopt(self, level, option, value):
with rffi.scoped_str2charp(value) as buf:
res = _c.socketsetsockopt(self.fd, level, option,
rffi.cast(rffi.VOIDP, buf),
len(value))
if res < 0:
raise self.error_handler()
def setupterm(space, w_termname=None, fd=-1):
_fd = fd
if fd == -1:
w_stdout = space.getattr(space.getbuiltinmodule('sys'),
space.newtext('stdout'))
_fd = space.int_w(
space.call_function(
space.getattr(w_stdout, space.newtext('fileno'))))
if space.is_none(w_termname):
termname = None
termname_err = 'None'
else:
termname = space.text_w(w_termname)
termname_err = "'%s'" % termname
p_errret = lltype.malloc(rffi.INTP.TO, 1, flavor='raw')
try:
with rffi.scoped_str2charp(termname) as ll_term:
_fd = rffi.cast(rffi.INT, _fd)
errval = fficurses.setupterm(ll_term, _fd, p_errret)
if errval == -1:
errret = widen(p_errret[0])
if errret == 0:
msg_ext = 'could not find terminal'
elif errret == -1:
msg_ext = 'could not find termininfo database'
else:
msg_ext = 'unknown error'
msg = ("setupterm(%s, %d) failed (err=%d): %s" %
(termname_err, fd, errret, msg_ext))
raise curses_error(space, msg)
finally:
lltype.free(p_errret, flavor='raw')
space.fromcache(ModuleInfo).setupterm_called = True
def spawn(loop, process, file, args, env):
with rffi.scoped_str2charp(file) as rawFile:
rawArgs = rffi.liststr2charpp(args)
rawEnv = rffi.liststr2charpp(env)
with rffi.scoped_str2charp(".") as rawCWD:
options = rffi.make(cConfig["process_options_t"], c_file=rawFile,
c_args=rawArgs, c_env=rawEnv, c_cwd=rawCWD)
add_exit_cb(options, processDiscard)
rffi.setintfield(options, "c_flags", UV_PROCESS_WINDOWS_HIDE)
rffi.setintfield(options, "c_stdio_count", 0)
rv = uv_spawn(loop, process, options)
free(options)
rffi.free_charpp(rawEnv)
rffi.free_charpp(rawArgs)
check("spawn", rv)
def spawn(loop, process, file, args, env):
with rffi.scoped_str2charp(file) as rawFile:
rawArgs = rffi.liststr2charpp(args)
rawEnv = rffi.liststr2charpp(env)
with rffi.scoped_str2charp(".") as rawCWD:
options = rffi.make(cConfig["process_options_t"], c_file=rawFile,
c_args=rawArgs, c_env=rawEnv, c_cwd=rawCWD)
add_exit_cb(options, processDiscard)
rffi.setintfield(options, "c_flags", UV_PROCESS_WINDOWS_HIDE)
rffi.setintfield(options, "c_stdio_count", 0)
rv = uv_spawn(loop, process, options)
free(options)
rffi.free_charpp(rawEnv)
rffi.free_charpp(rawArgs)
check("spawn", rv)
def SetValue(space, w_hkey, w_subkey, typ, value):
"""SetValue(key, sub_key, type, value) - Associates a value with a specified key.
key is an already open key, or any one of the predefined HKEY_* constants.
sub_key is a string that names the subkey with which the value is associated.
type is an integer that specifies the type of the data. Currently this
must be REG_SZ, meaning only strings are supported.
value is a string that specifies the new value.
If the key specified by the sub_key parameter does not exist, the SetValue
function creates it.
Value lengths are limited by available memory. Long values (more than
2048 bytes) should be stored as files with the filenames stored in
the configuration registry. This helps the registry perform efficiently.
The key identified by the key parameter must have been opened with
KEY_SET_VALUE access."""
if typ != rwinreg.REG_SZ:
errstring = space.wrap("Type must be _winreg.REG_SZ")
raise OperationError(space.w_ValueError, errstring)
hkey = hkey_w(w_hkey, space)
if space.is_w(w_subkey, space.w_None):
subkey = None
else:
subkey = space.str_w(w_subkey)
with rffi.scoped_str2charp(value) as dataptr:
ret = rwinreg.RegSetValue(hkey, subkey, rwinreg.REG_SZ, dataptr, len(value))
if ret != 0:
raiseWindowsError(space, ret, 'RegSetValue')
def temp_file(vm):
mod = vm.get_funcs_mod()
file_class = type_check_class(vm, mod.get_defn(vm, "File"))
vm.decode_args()
if HAS_MKSTEMP:
#tmpdir = None
#if os.environ.has_key("TMPDIR"):
# tmpdir = os.environ["TMPDIR"]
#if tmpdir is None:
# tmpdir = "/tmp"
tmpp = "/tmp/tmp.XXXXXXXXXX"
with rffi.scoped_str2charp(tmpp) as buf:
fd = mkstemp(buf)
tmpp = rffi.charp2str(buf)
if fd == -1:
_errno_raise(vm, Con_String(vm, tmpp))
f = fdopen(fd, "w+")
if not f:
_errno_raise(vm, Con_String(vm, tmpp))
return File(vm, file_class, Con_String(vm, tmpp), f)
else:
raise Exception("XXX")
def setsockopt(self, level, option, value):
with rffi.scoped_str2charp(value) as buf:
res = _c.socketsetsockopt(self.fd, level, option,
rffi.cast(rffi.VOIDP, buf),
len(value))
if res < 0:
raise self.error_handler()
def temp_file(vm):
mod = vm.get_funcs_mod()
file_class = type_check_class(vm, mod.get_defn(vm, "File"))
vm.decode_args()
if HAS_MKSTEMP:
#tmpdir = None
#if os.environ.has_key("TMPDIR"):
# tmpdir = os.environ["TMPDIR"]
#if tmpdir is None:
# tmpdir = "/tmp"
tmpp = "/tmp/tmp.XXXXXXXXXX"
with rffi.scoped_str2charp(tmpp) as buf:
fd = mkstemp(buf)
tmpp = rffi.charp2str(buf)
if fd == -1:
_errno_raise(vm, Con_String(vm, tmpp))
f = fdopen(fd, "w+")
if not f:
_errno_raise(vm, Con_String(vm, tmpp))
return File(vm, file_class, Con_String(vm, tmpp), f)
else:
raise Exception("XXX")
def SetValue(space, w_hkey, w_subkey, typ, value):
"""SetValue(key, sub_key, type, value) - Associates a value with a specified key.
key is an already open key, or any one of the predefined HKEY_* constants.
sub_key is a string that names the subkey with which the value is associated.
type is an integer that specifies the type of the data. Currently this
must be REG_SZ, meaning only strings are supported.
value is a string that specifies the new value.
If the key specified by the sub_key parameter does not exist, the SetValue
function creates it.
Value lengths are limited by available memory. Long values (more than
2048 bytes) should be stored as files with the filenames stored in
the configuration registry. This helps the registry perform efficiently.
The key identified by the key parameter must have been opened with
KEY_SET_VALUE access."""
if typ != rwinreg.REG_SZ:
raise oefmt(space.w_ValueError, "Type must be _winreg.REG_SZ")
hkey = hkey_w(w_hkey, space)
if space.is_w(w_subkey, space.w_None):
subkey = None
else:
subkey = space.text_w(w_subkey)
with rffi.scoped_str2charp(value) as dataptr:
ret = rwinreg.RegSetValueA(hkey, subkey, rwinreg.REG_SZ, dataptr,
len(value))
if ret != 0:
raiseWindowsError(space, ret, 'RegSetValue')
def sqlite3_result_text(self, s):
self.invalidate_cache()
with rffi.scoped_str2charp(s) as charp:
capi.sqlite3VdbeMemSetStr(
self.pMem, charp, len(s),
CConfig.SQLITE_UTF8,
rffi.cast(rffi.VOIDP, CConfig.SQLITE_TRANSIENT))
def __init__(self, ffi, filename, flags):
with rffi.scoped_str2charp(filename) as ll_libname:
if filename is None:
filename = "<None>"
try:
handle = dlopen(ll_libname, flags)
except DLOpenError, e:
raise wrap_dlopenerror(ffi.space, e, filename)
def prepare(self, query, use_flag_cache):
length = len(query)
with rffi.scoped_str2charp(query) as query, lltype.scoped_alloc(rffi.VOIDPP.TO, 1) as result, lltype.scoped_alloc(rffi.CCHARPP.TO, 1) as unused_buffer:
errorcode = capi.sqlite3_prepare_v2(rffi.cast(rffi.VOIDP, self.db), query, length, result, unused_buffer)
if not errorcode == 0:
raise SqliteException(errorcode, rffi.charp2str(capi.sqlite3_errmsg(self.db)))
self.p = rffi.cast(capi.VDBEP, result[0])
self._init_python_data(use_flag_cache)
def __init__(self, ffi, filename, flags):
with rffi.scoped_str2charp(filename) as ll_libname:
if filename is None:
filename = "<None>"
try:
handle = dlopen(ll_libname, flags)
except DLOpenError, e:
raise wrap_dlopenerror(ffi.space, e, filename)
def test_file_writestring(self, space, api, capfd):
w_stdout = space.sys.get("stdout")
with rffi.scoped_str2charp("test\n") as s:
api.PyFile_WriteString(s, w_stdout)
space.call_method(w_stdout, "flush")
out, err = capfd.readouterr()
out = out.replace('\r\n', '\n')
assert out == "test\n"
def test_file_writestring(self, space, api, capfd):
w_stdout = space.sys.get("stdout")
with rffi.scoped_str2charp("test\n") as s:
api.PyFile_WriteString(s, w_stdout)
space.call_method(w_stdout, "flush")
out, err = capfd.readouterr()
out = out.replace('\r\n', '\n')
assert out == "test\n"
def tigetstr(space, capname):
check_setup_invoked(space)
with rffi.scoped_str2charp(capname) as ll_capname:
ll_result = fficurses.rpy_curses_tigetstr(ll_capname)
if ll_result:
return space.newbytes(rffi.charp2str(ll_result))
else:
return space.w_None
def bind_str(self, i, s):
self.invalidate_caches_outside()
with rffi.scoped_str2charp(s) as charp:
return rffi.cast(
lltype.Signed,
capi.sqlite3_bind_text(
self.p, i, charp, len(s),
rffi.cast(rffi.VOIDP, CConfig.SQLITE_TRANSIENT)))
def spawn(loop, process, file, args, env, streams):
"""
The file descriptor list should be a list of streams to wire up to FDs in
the child. A None stream is mapped to UV_IGNORE.
"""
with rffi.scoped_str2charp(file) as rawFile:
rawArgs = rffi.liststr2charpp(args)
rawEnv = rffi.liststr2charpp(env)
with rffi.scoped_str2charp(".") as rawCWD:
options = rffi.make(cConfig["process_options_t"], c_file=rawFile,
c_args=rawArgs, c_env=rawEnv, c_cwd=rawCWD)
with lltype.scoped_alloc(rffi.CArray(stdio_container_t),
len(streams)) as rawStreams:
for i, stream in enumerate(streams):
if stream == lltype.nullptr(stream_t):
flags = UV_IGNORE
else:
flags = UV_CREATE_PIPE
if i == 0:
flags |= UV_READABLE_PIPE
elif i in (1, 2):
flags |= UV_WRITABLE_PIPE
if not we_are_translated():
# doing extra allocations here to work around ll2ctypes'
# desire to gratuitously copy arrays
with lltype.scoped_alloc(stdio_container_t) as con:
set_stdio_stream(con, stream)
for field in rawStreams[i]._T._names:
setattr(rawStreams[i], field, getattr(con, field))
else:
set_stdio_stream(rawStreams[i], stream)
rffi.setintfield(rawStreams[i], "c_flags", flags)
options.c_stdio = rawStreams
rffi.setintfield(options, "c_stdio_count", len(streams))
add_exit_cb(options, processDiscard)
# On Windows, ask to *not* have one of those annoying
# console/terminal windows pop up. ~ C.
rffi.setintfield(options, "c_flags", UV_PROCESS_WINDOWS_HIDE)
rv = uv_spawn(loop, process, options)
free(options)
rffi.free_charpp(rawEnv)
rffi.free_charpp(rawArgs)
check("spawn", rv)
def RAND_add(space, string, entropy):
"""RAND_add(string, entropy)
Mix string into the OpenSSL PRNG state. entropy (a float) is a lower
bound on the entropy contained in string."""
with rffi.scoped_str2charp(string) as buf:
libssl_RAND_add(buf, len(string), entropy)
def RAND_add(space, string, entropy):
"""RAND_add(string, entropy)
Mix string into the OpenSSL PRNG state. entropy (a float) is a lower
bound on the entropy contained in string."""
with rffi.scoped_str2charp(string) as buf:
libssl_RAND_add(buf, len(string), entropy)
def initialize_timezone_info(tz_name):
tzi = TimeZoneInfo(tz_name is None)
with rffi.scoped_str2charp("UTC") as ll_s:
ll_tzi = timelib.timelib_parse_tzfile(
ll_s, timelib.timelib_builtin_db())
if not ll_tzi:
raise Exception("failed to initialize timezone")
tzi.timezone = tz_name
tzi.utc_tzi = ll_tzi
if tz_name is None:
tzi.timezone = 'UTC'
return tzi
with rffi.scoped_str2charp(tz_name) as ll_s:
ll_tzi = timelib.timelib_parse_tzfile(
ll_s, timelib.timelib_builtin_db())
if not ll_tzi:
raise Exception("failed to initialize timezone")
tzi.local_tzi = ll_tzi
return tzi
def __init__(self, ffi, filename, flags):
with rffi.scoped_str2charp(filename) as ll_libname:
if filename is None:
filename = "<None>"
try:
handle = dlopen(ll_libname, flags)
except DLOpenError as e:
raise wrap_dlopenerror(ffi.space, e, filename)
W_LibObject.__init__(self, ffi, filename)
self.libhandle = handle
self.register_finalizer(ffi.space)
def test_encode_fsdefault(self, space, api):
w_u = space.wrap(u'späm')
w_s = api.PyUnicode_EncodeFSDefault(w_u)
if w_s is None:
api.PyErr_Clear()
py.test.skip("Requires a unicode-aware fsencoding")
with rffi.scoped_str2charp(space.str_w(w_s)) as encoded:
w_decoded = api.PyUnicode_DecodeFSDefaultAndSize(encoded, space.len_w(w_s))
assert space.eq_w(w_decoded, w_u)
w_decoded = api.PyUnicode_DecodeFSDefault(encoded)
assert space.eq_w(w_decoded, w_u)
def _glob(pattern, flags):
ll_glob_t = lltype.malloc(PTR_GLOB_T.TO, flavor='raw')
files = []
with rffi.scoped_str2charp(pattern) as ll_pattern:
ll_res = c_glob(ll_pattern, flags, lltype.nullptr(callback.TO),
ll_glob_t)
num = intmask(ll_glob_t.c_gl_pathc)
for i in range(num):
fname = rffi.charp2str(ll_glob_t.c_gl_pathv[i])
files.append(fname)
return ll_res, files
def __init__(self, ffi, filename, flags):
with rffi.scoped_str2charp(filename) as ll_libname:
if filename is None:
filename = "<None>"
try:
handle = dlopen(ll_libname, flags)
except DLOpenError as e:
raise wrap_dlopenerror(ffi.space, e, filename)
W_LibObject.__init__(self, ffi, filename)
self.libhandle = handle
self.register_finalizer(ffi.space)
def _glob(pattern, flags):
ll_glob_t = lltype.malloc(PTR_GLOB_T.TO, flavor='raw')
files = []
with rffi.scoped_str2charp(pattern) as ll_pattern:
ll_res = c_glob(ll_pattern, flags, lltype.nullptr(callback.TO),
ll_glob_t)
num = intmask(ll_glob_t.c_gl_pathc)
for i in range(num):
fname = rffi.charp2str(ll_glob_t.c_gl_pathv[i])
files.append(fname)
return ll_res, files
def __init__(self, space, filename, flags):
self.space = space
with rffi.scoped_str2charp(filename) as ll_libname:
if filename is None:
filename = "<None>"
try:
self.handle = dlopen(ll_libname, flags)
except DLOpenError as e:
raise wrap_dlopenerror(space, e, filename)
self.name = filename
self.register_finalizer(space)
def __init__(self, space, filename, flags):
self.space = space
with rffi.scoped_str2charp(filename) as ll_libname:
if filename is None:
filename = "<None>"
try:
self.handle = dlopen(ll_libname, flags)
except DLOpenError as e:
raise wrap_dlopenerror(space, e, filename)
self.name = filename
self.register_finalizer(space)
def test_getmoduledict(self, space):
testmod = "_functools"
w_pre_dict = PyImport_GetModuleDict(space, )
assert not space.contains_w(w_pre_dict, space.wrap(testmod))
with rffi.scoped_str2charp(testmod) as modname:
w_module = PyImport_ImportModule(space, modname)
print w_module
assert w_module
w_dict = PyImport_GetModuleDict(space, )
assert space.contains_w(w_dict, space.wrap(testmod))
def test_getmoduledict(self, space, api):
testmod = "contextlib"
w_pre_dict = api.PyImport_GetModuleDict()
assert not space.is_true(space.contains(w_pre_dict, space.wrap(testmod)))
with rffi.scoped_str2charp(testmod) as modname:
w_module = api.PyImport_ImportModule(modname)
print w_module
assert w_module
w_dict = api.PyImport_GetModuleDict()
assert space.is_true(space.contains(w_dict, space.wrap(testmod)))
def test_encode_fsdefault(self, space):
w_u = space.wrap(u'späm')
try:
w_s = PyUnicode_EncodeFSDefault(space, w_u)
except (OperationError, UnicodeEncodeError):
py.test.skip("Requires a unicode-aware fsencoding")
with rffi.scoped_str2charp(space.bytes_w(w_s)) as encoded:
w_decoded = PyUnicode_DecodeFSDefaultAndSize(
space, encoded, space.len_w(w_s))
assert space.eq_w(w_decoded, w_u)
w_decoded = PyUnicode_DecodeFSDefault(space, encoded)
assert space.eq_w(w_decoded, w_u)
def test_getmoduledict(self, space, api):
testmod = "_functools"
w_pre_dict = api.PyImport_GetModuleDict()
assert not space.contains_w(w_pre_dict, space.wrap(testmod))
with rffi.scoped_str2charp(testmod) as modname:
w_module = api.PyImport_ImportModule(modname)
print w_module
assert w_module
w_dict = api.PyImport_GetModuleDict()
assert space.contains_w(w_dict, space.wrap(testmod))
def test_locale(self, space):
# Input is bytes
w_input = space.newbytes("test")
with rffi.scoped_str2charp('strict') as errors:
w_ret = PyUnicode_DecodeLocale(space, w_input, errors)
assert space.utf8_w(w_ret) == 'test'
with rffi.scoped_str2charp('surrogateescape') as errors:
w_ret = PyUnicode_DecodeLocale(space, w_input, errors)
assert space.utf8_w(w_ret) == 'test'
# Input is unicode
w_input = space.newtext("test", 4)
with rffi.scoped_str2charp('strict') as errors:
w_ret = PyUnicode_EncodeLocale(space, w_input, errors)
assert space.utf8_w(w_ret) == 'test'
with rffi.scoped_str2charp(None) as errors:
w_ret = PyUnicode_EncodeLocale(space, w_input, errors)
assert space.utf8_w(w_ret) == 'test'
with rffi.scoped_str2charp('surrogateescape') as errors:
w_ret = PyUnicode_EncodeLocale(space, w_input, errors)
assert space.utf8_w(w_ret) == 'test'
# 'errors' is invalid
with rffi.scoped_str2charp('something else') as errors:
with pytest.raises(OperationError):
PyUnicode_EncodeLocale(space, w_input, errors)
def regenerateKey(secretKey):
"""
Regenerate a public key from a secret key.
"""
publicSize = intmask(cryptoBoxPublickeybytes())
with rffi.scoped_alloc_buffer(publicSize) as public:
with rffi.scoped_str2charp(secretKey) as rawSecret:
rv = cryptoScalarmultBase(public.raw, rawSecret)
if rv:
raise SodiumError("crypto_scalarmult_base: %d" % rv)
return public.str(publicSize)
def unsetenv_llimpl(name):
with rffi.scoped_str2charp(name) as l_name:
error = rffi.cast(lltype.Signed, os_unsetenv(l_name))
if error:
from rpython.rlib import rposix
raise OSError(rposix.get_saved_errno(), "os_unsetenv failed")
try:
l_oldstring = envkeepalive.byname[name]
except KeyError:
pass
else:
del envkeepalive.byname[name]
rffi.free_charp(l_oldstring)
def find_extension(self, name, path):
from pypy.module.cpyext.import_ import PyImport_AddModule
from pypy.interpreter.module import Module
try:
w_dict = self.extensions[path]
except KeyError:
return None
with rffi.scoped_str2charp(name) as ll_name:
w_mod = PyImport_AddModule(self.space, ll_name)
assert isinstance(w_mod, Module)
w_mdict = w_mod.getdict(self.space)
self.space.call_method(w_mdict, 'update', w_dict)
return w_mod
def RAND_egd(space, path):
"""RAND_egd(path) -> bytes
Queries the entropy gather daemon (EGD) on socket path. Returns number
of bytes read. Raises socket.sslerror if connection to EGD fails or
if it does provide enough data to seed PRNG."""
with rffi.scoped_str2charp(path) as socket_path:
bytes = libssl_RAND_egd(socket_path)
if bytes == -1:
raise ssl_error(space,
"EGD connection failed or EGD did not return "
"enough data to seed the PRNG")
return space.wrap(bytes)
def create_aggregate(self, name, nargs, contextcls):
index, func = self.funcregistry.create_aggregate(name, nargs, contextcls)
with rffi.scoped_str2charp(name) as name:
# use 1 as the function pointer and pass in the index as the user
# data
errorcode = capi.sqlite3_create_function(
self.db, name, nargs, CConfig.SQLITE_UTF8,
rffi.cast(rffi.VOIDP, index),
lltype.nullptr(rffi.VOIDP.TO),
rffi.cast(rffi.VOIDP, 1),
rffi.cast(rffi.VOIDP, 1),
)
assert errorcode == 0
return func
