def detect_floatformat():
from pypy.rpython.lltypesystem import rffi, lltype
buf = lltype.malloc(rffi.CCHARP.TO, 8, flavor='raw')
rffi.cast(rffi.DOUBLEP, buf)[0] = 9006104071832581.0
packed = rffi.charpsize2str(buf, 8)
if packed == "\x43\x3f\xff\x01\x02\x03\x04\x05":
double_format = 'IEEE, big-endian'
elif packed == "\x05\x04\x03\x02\x01\xff\x3f\x43":
double_format = 'IEEE, little-endian'
else:
double_format = 'unknown'
lltype.free(buf, flavor='raw')
#
buf = lltype.malloc(rffi.CCHARP.TO, 4, flavor='raw')
rffi.cast(rffi.FLOATP, buf)[0] = rarithmetic.r_singlefloat(16711938.0)
packed = rffi.charpsize2str(buf, 4)
if packed == "\x4b\x7f\x01\x02":
float_format = 'IEEE, big-endian'
elif packed == "\x02\x01\x7f\x4b":
float_format = 'IEEE, little-endian'
else:
float_format = 'unknown'
lltype.free(buf, flavor='raw')
return double_format, float_format
def detect_floatformat():
from pypy.rpython.lltypesystem import rffi, lltype
buf = lltype.malloc(rffi.CCHARP.TO, 8, flavor='raw')
rffi.cast(rffi.DOUBLEP, buf)[0] = 9006104071832581.0
packed = rffi.charpsize2str(buf, 8)
if packed == "\x43\x3f\xff\x01\x02\x03\x04\x05":
double_format = 'IEEE, big-endian'
elif packed == "\x05\x04\x03\x02\x01\xff\x3f\x43":
double_format = 'IEEE, little-endian'
else:
double_format = 'unknown'
lltype.free(buf, flavor='raw')
#
buf = lltype.malloc(rffi.CCHARP.TO, 4, flavor='raw')
rffi.cast(rffi.FLOATP, buf)[0] = rarithmetic.r_singlefloat(16711938.0)
packed = rffi.charpsize2str(buf, 4)
if packed == "\x4b\x7f\x01\x02":
float_format = 'IEEE, big-endian'
elif packed == "\x02\x01\x7f\x4b":
float_format = 'IEEE, little-endian'
else:
float_format = 'unknown'
lltype.free(buf, flavor='raw')
return double_format, float_format
def _decode_certificate(space, certificate, verbose=False):
w_retval = space.newdict()
w_peer = _create_tuple_for_X509_NAME(
space, libssl_X509_get_subject_name(certificate))
space.setitem(w_retval, space.wrap("subject"), w_peer)
if verbose:
w_issuer = _create_tuple_for_X509_NAME(
space, libssl_X509_get_issuer_name(certificate))
space.setitem(w_retval, space.wrap("issuer"), w_issuer)
space.setitem(w_retval, space.wrap("version"),
space.wrap(libssl_X509_get_version(certificate)))
biobuf = libssl_BIO_new(libssl_BIO_s_mem())
try:
if verbose:
libssl_BIO_reset(biobuf)
serialNumber = libssl_X509_get_serialNumber(certificate)
libssl_i2a_ASN1_INTEGER(biobuf, serialNumber)
# should not exceed 20 octets, 160 bits, so buf is big enough
with lltype.scoped_alloc(rffi.CCHARP.TO, 100) as buf:
length = libssl_BIO_gets(biobuf, buf, 99)
if length < 0:
raise _ssl_seterror(space, None, length)
w_serial = space.wrap(rffi.charpsize2str(buf, length))
space.setitem(w_retval, space.wrap("serialNumber"), w_serial)
libssl_BIO_reset(biobuf)
notBefore = libssl_X509_get_notBefore(certificate)
libssl_ASN1_TIME_print(biobuf, notBefore)
with lltype.scoped_alloc(rffi.CCHARP.TO, 100) as buf:
length = libssl_BIO_gets(biobuf, buf, 99)
if length < 0:
raise _ssl_seterror(space, None, length)
w_date = space.wrap(rffi.charpsize2str(buf, length))
space.setitem(w_retval, space.wrap("notBefore"), w_date)
libssl_BIO_reset(biobuf)
notAfter = libssl_X509_get_notAfter(certificate)
libssl_ASN1_TIME_print(biobuf, notAfter)
with lltype.scoped_alloc(rffi.CCHARP.TO, 100) as buf:
length = libssl_BIO_gets(biobuf, buf, 99)
if length < 0:
raise _ssl_seterror(space, None, length)
w_date = space.wrap(rffi.charpsize2str(buf, length))
space.setitem(w_retval, space.wrap("notAfter"), w_date)
finally:
libssl_BIO_free(biobuf)
# Now look for subjectAltName
w_alt_names = _get_peer_alt_names(space, certificate)
if w_alt_names is not space.w_None:
space.setitem(w_retval, space.wrap("subjectAltName"), w_alt_names)
return w_retval
def _decode_certificate(space, certificate, verbose=False):
w_retval = space.newdict()
w_peer = _create_tuple_for_X509_NAME(
space, libssl_X509_get_subject_name(certificate))
space.setitem(w_retval, space.wrap("subject"), w_peer)
if verbose:
w_issuer = _create_tuple_for_X509_NAME(
space, libssl_X509_get_issuer_name(certificate))
space.setitem(w_retval, space.wrap("issuer"), w_issuer)
space.setitem(w_retval, space.wrap("version"),
space.wrap(libssl_X509_get_version(certificate)))
biobuf = libssl_BIO_new(libssl_BIO_s_mem())
try:
if verbose:
libssl_BIO_reset(biobuf)
serialNumber = libssl_X509_get_serialNumber(certificate)
libssl_i2a_ASN1_INTEGER(biobuf, serialNumber)
# should not exceed 20 octets, 160 bits, so buf is big enough
with lltype.scoped_alloc(rffi.CCHARP.TO, 100) as buf:
length = libssl_BIO_gets(biobuf, buf, 99)
if length < 0:
raise _ssl_seterror(space, None, length)
w_serial = space.wrap(rffi.charpsize2str(buf, length))
space.setitem(w_retval, space.wrap("serialNumber"), w_serial)
libssl_BIO_reset(biobuf)
notBefore = libssl_X509_get_notBefore(certificate)
libssl_ASN1_TIME_print(biobuf, notBefore)
with lltype.scoped_alloc(rffi.CCHARP.TO, 100) as buf:
length = libssl_BIO_gets(biobuf, buf, 99)
if length < 0:
raise _ssl_seterror(space, None, length)
w_date = space.wrap(rffi.charpsize2str(buf, length))
space.setitem(w_retval, space.wrap("notBefore"), w_date)
libssl_BIO_reset(biobuf)
notAfter = libssl_X509_get_notAfter(certificate)
libssl_ASN1_TIME_print(biobuf, notAfter)
with lltype.scoped_alloc(rffi.CCHARP.TO, 100) as buf:
length = libssl_BIO_gets(biobuf, buf, 99)
if length < 0:
raise _ssl_seterror(space, None, length)
w_date = space.wrap(rffi.charpsize2str(buf, length))
space.setitem(w_retval, space.wrap("notAfter"), w_date)
finally:
libssl_BIO_free(biobuf)
# Now look for subjectAltName
w_alt_names = _get_peer_alt_names(space, certificate)
if w_alt_names is not space.w_None:
space.setitem(w_retval, space.wrap("subjectAltName"), w_alt_names)
return w_retval
def recv_bytes_into(self, space, w_buffer, offset=0):
rwbuffer = space.rwbuffer_w(w_buffer)
length = rwbuffer.getlength()
res, newbuf = self.do_recv_string(space, length - offset, PY_SSIZE_T_MAX)
res = intmask(res) # XXX why?
try:
if newbuf:
raise BufferTooShort(space, space.wrap(rffi.charpsize2str(newbuf, res)))
rwbuffer.setslice(offset, rffi.charpsize2str(self.buffer, res))
finally:
if newbuf:
rffi.free_charp(newbuf)
return space.wrap(res)
def recv_bytes(self, space, maxlength=PY_SSIZE_T_MAX):
self._check_readable(space)
if maxlength < 0:
raise OperationError(space.w_ValueError,
space.wrap("maxlength < 0"))
res, newbuf = self.do_recv_string(space, self.BUFFER_SIZE, maxlength)
try:
if newbuf:
return space.wrap(rffi.charpsize2str(newbuf, res))
else:
return space.wrap(rffi.charpsize2str(self.buffer, res))
finally:
if newbuf:
rffi.free_charp(newbuf)
def _create_tuple_for_attribute(space, name, value):
with lltype.scoped_alloc(rffi.CCHARP.TO, X509_NAME_MAXLEN) as buf:
length = libssl_OBJ_obj2txt(buf, X509_NAME_MAXLEN, name, 0)
if length < 0:
raise _ssl_seterror(space, None, 0)
w_name = space.wrap(rffi.charpsize2str(buf, length))
with lltype.scoped_alloc(rffi.CCHARPP.TO, 1) as buf_ptr:
length = libssl_ASN1_STRING_to_UTF8(buf_ptr, value)
if length < 0:
raise _ssl_seterror(space, None, 0)
w_value = space.wrap(rffi.charpsize2str(buf_ptr[0], length))
w_value = space.call_method(w_value, "decode", space.wrap("utf-8"))
return space.newtuple([w_name, w_value])
def _create_tuple_for_attribute(space, name, value):
with lltype.scoped_alloc(rffi.CCHARP.TO, X509_NAME_MAXLEN) as buf:
length = libssl_OBJ_obj2txt(buf, X509_NAME_MAXLEN, name, 0)
if length < 0:
raise _ssl_seterror(space, None, 0)
w_name = space.wrap(rffi.charpsize2str(buf, length))
with lltype.scoped_alloc(rffi.CCHARPP.TO, 1) as buf_ptr:
length = libssl_ASN1_STRING_to_UTF8(buf_ptr, value)
if length < 0:
raise _ssl_seterror(space, None, 0)
w_value = space.wrap(rffi.charpsize2str(buf_ptr[0], length))
w_value = space.call_method(w_value, "decode", space.wrap("utf-8"))
return space.newtuple([w_name, w_value])
def recv_bytes(self, space, maxlength=PY_SSIZE_T_MAX):
self._check_readable(space)
if maxlength < 0:
raise OperationError(space.w_ValueError, space.wrap("maxlength < 0"))
res, newbuf = self.do_recv_string(space, self.BUFFER_SIZE, maxlength)
res = intmask(res) # XXX why?
try:
if newbuf:
return space.wrap(rffi.charpsize2str(newbuf, res))
else:
return space.wrap(rffi.charpsize2str(self.buffer, res))
finally:
if newbuf:
rffi.free_charp(newbuf)
def load_resource(filename, resname, resid, reslang):
"""Load the named resource from the given file.
The filename and resource name must be ascii strings, and the resid and
reslang must be integers.
"""
l_handle = k32_LoadLibraryExA(filename, 0, LOAD_LIBRARY_AS_DATAFILE)
if not l_handle:
raise WindowsError(rwin32.GetLastError(), "LoadLibraryExW failed")
try:
r_handle = k32_FindResourceExA(l_handle, resname, resid, reslang)
if not r_handle:
raise WindowsError(rwin32.GetLastError(), "FindResourceExA failed")
r_size = k32_SizeofResource(l_handle, r_handle)
if not r_size:
raise WindowsError(rwin32.GetLastError(), "SizeofResource failed")
r_info = k32_LoadResource(l_handle, r_handle)
if not r_info:
raise WindowsError(rwin32.GetLastError(), "LoadResource failed")
r_ptr = k32_LockResource(r_info)
if not r_ptr:
raise WindowsError(rwin32.GetLastError(), "LockResource failed")
return rffi.charpsize2str(r_ptr, r_size)
finally:
if not k32_FreeLibrary(l_handle):
raise WindowsError(rwin32.GetLastError(), "FreeLibrary failed")
def ioctl(space, w_fd, op, w_arg=0, mutate_flag=-1):
"""ioctl(fd, opt[, arg[, mutate_flag]])
Perform the requested operation on file descriptor fd. The operation is
defined by opt and is operating system dependent. Typically these codes
are retrieved from the fcntl or termios library modules.
"""
# removed the largish docstring because it is not in sync with the
# documentation any more (even in CPython's docstring is out of date)
# XXX this function's interface is a mess.
# We try to emulate the behavior of Python >= 2.5 w.r.t. mutate_flag
fd = space.c_filedescriptor_w(w_fd)
op = rffi.cast(rffi.INT, op) # C long => C int
if mutate_flag != 0:
try:
rwbuffer = space.rwbuffer_w(w_arg)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
if mutate_flag > 0:
raise
else:
arg = rwbuffer.as_str()
ll_arg = rffi.str2charp(arg)
rv = ioctl_str(fd, op, ll_arg)
arg = rffi.charpsize2str(ll_arg, len(arg))
lltype.free(ll_arg, flavor='raw')
if rv < 0:
raise _get_error(space, "ioctl")
rwbuffer.setslice(0, arg)
return space.wrap(rv)
def win32_urandom(space, n):
"""urandom(n) -> str
Return a string of n random bytes suitable for cryptographic use.
"""
if n < 0:
raise OperationError(space.w_ValueError,
space.wrap("negative argument not allowed"))
provider = get(space).cryptProviderPtr[0]
if not provider:
# Acquire context.
# This handle is never explicitly released. The operating
# system will release it when the process terminates.
if not CryptAcquireContext(
get(space).cryptProviderPtr, None, None,
PROV_RSA_FULL, CRYPT_VERIFYCONTEXT):
raise rwin32.lastWindowsError("CryptAcquireContext")
provider = get(space).cryptProviderPtr[0]
# Get random data
buf = lltype.malloc(rffi.CArray(rwin32.BYTE), n,
zero=True, # zero seed
flavor='raw')
try:
if not CryptGenRandom(provider, n, buf):
raise rwin32.lastWindowsError("CryptGenRandom")
return space.wrap(
rffi.charpsize2str(rffi.cast(rffi.CCHARP, buf), n))
finally:
lltype.free(buf, flavor='raw')
def encodeex(encodebuf, unicodedata, errors="strict", errorcb=None, namecb=None, ignore_error=0):
inleft = len(unicodedata)
inbuf = rffi.get_nonmoving_unicodebuffer(unicodedata)
try:
if pypy_cjk_enc_init(encodebuf, inbuf, inleft) < 0:
raise MemoryError
if ignore_error == 0:
flags = MBENC_FLUSH | MBENC_RESET
else:
flags = 0
while True:
r = pypy_cjk_enc_chunk(encodebuf, flags)
if r == 0 or r == ignore_error:
break
multibytecodec_encerror(encodebuf, r, errors, errorcb, namecb, unicodedata)
while flags & MBENC_RESET:
r = pypy_cjk_enc_reset(encodebuf)
if r == 0:
break
multibytecodec_encerror(encodebuf, r, errors, errorcb, namecb, unicodedata)
src = pypy_cjk_enc_outbuf(encodebuf)
length = pypy_cjk_enc_outlen(encodebuf)
return rffi.charpsize2str(src, length)
#
finally:
rffi.free_nonmoving_unicodebuffer(unicodedata, inbuf)
def ioctl(space, w_fd, op, w_arg=0, mutate_flag=-1):
"""ioctl(fd, opt[, arg[, mutate_flag]])
Perform the requested operation on file descriptor fd. The operation is
defined by opt and is operating system dependent. Typically these codes
are retrieved from the fcntl or termios library modules.
"""
# removed the largish docstring because it is not in sync with the
# documentation any more (even in CPython's docstring is out of date)
# XXX this function's interface is a mess.
# We try to emulate the behavior of Python >= 2.5 w.r.t. mutate_flag
fd = space.c_filedescriptor_w(w_fd)
op = rffi.cast(rffi.INT, op) # C long => C int
if mutate_flag != 0:
try:
rwbuffer = space.rwbuffer_w(w_arg)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
if mutate_flag > 0:
raise
else:
arg = rwbuffer.as_str()
ll_arg = rffi.str2charp(arg)
rv = ioctl_str(fd, op, ll_arg)
arg = rffi.charpsize2str(ll_arg, len(arg))
lltype.free(ll_arg, flavor='raw')
if rv < 0:
raise _get_error(space, "ioctl")
rwbuffer.setslice(0, arg)
return space.wrap(rv)
def File_read(vm):
(self, rsize_o),_ = vm.decode_args(mand="!", opt="I", self_of=File)
assert isinstance(self, File)
_check_open(vm, self)
flockfile(self.filep)
fsize = os.fstat(fileno(self.filep)).st_size
if rsize_o is None:
rsize = fsize
else:
assert isinstance(rsize_o, Con_Int)
rsize = rsize_o.v
if rsize < 0:
vm.raise_helper("File_Exception", \
[Con_String(vm, "Can not read less than 0 bytes from file.")])
elif rsize > fsize:
rsize = fsize
if objectmodel.we_are_translated():
with lltype.scoped_alloc(rffi.CCHARP.TO, rsize) as buf:
r = fread(buf, 1, rsize, self.filep)
if r < rffi.r_size_t(rsize) and ferror(self.filep) != 0:
vm.raise_helper("File_Exception", [Con_String(vm, "Read error.")])
s = rffi.charpsize2str(buf, rarithmetic.intmask(r))
else:
# rffi.charpsize2str is so slow (taking minutes for big strings) that it's worth bypassing
# it when things are run untranslated.
s = os.read(fileno(self.filep), rsize)
funlockfile(self.filep)
return Con_String(vm, s)
def peer_certificate(self, der=False):
"""peer_certificate([der=False]) -> certificate
Returns the certificate for the peer. If no certificate was provided,
returns None. If a certificate was provided, but not validated, returns
an empty dictionary. Otherwise returns a dict containing information
about the peer certificate.
If the optional argument is True, returns a DER-encoded copy of the
peer certificate, or None if no certificate was provided. This will
return the certificate even if it wasn't validated."""
if not self.peer_cert:
return self.space.w_None
if der:
# return cert in DER-encoded format
with lltype.scoped_alloc(rffi.CCHARPP.TO, 1) as buf_ptr:
buf_ptr[0] = lltype.nullptr(rffi.CCHARP.TO)
length = libssl_i2d_X509(self.peer_cert, buf_ptr)
if length < 0:
raise _ssl_seterror(self.space, self, length)
try:
# this is actually an immutable bytes sequence
return self.space.wrap(rffi.charpsize2str(buf_ptr[0],
length))
finally:
libssl_OPENSSL_free(buf_ptr[0])
else:
verification = libssl_SSL_CTX_get_verify_mode(
libssl_SSL_get_SSL_CTX(self.ssl))
if not verification & SSL_VERIFY_PEER:
return self.space.newdict()
else:
return _decode_certificate(self.space, self.peer_cert)
def win32_urandom(space, n):
"""urandom(n) -> str
Return a string of n random bytes suitable for cryptographic use.
"""
if n < 0:
raise OperationError(space.w_ValueError,
space.wrap("negative argument not allowed"))
provider = get(space).cryptProviderPtr[0]
if not provider:
# Acquire context.
# This handle is never explicitly released. The operating
# system will release it when the process terminates.
if not CryptAcquireContext(
get(space).cryptProviderPtr, None, None,
PROV_RSA_FULL, CRYPT_VERIFYCONTEXT):
raise rwin32.lastWindowsError("CryptAcquireContext")
provider = get(space).cryptProviderPtr[0]
# Get random data
buf = lltype.malloc(rffi.CArray(rwin32.BYTE), n,
zero=True, # zero seed
flavor='raw')
try:
if not CryptGenRandom(provider, n, buf):
raise rwin32.lastWindowsError("CryptGenRandom")
return space.wrap(
rffi.charpsize2str(rffi.cast(rffi.CCHARP, buf), n))
finally:
lltype.free(buf, flavor='raw')
def recv_bytes_into(self, space, w_buffer, offset=0):
rwbuffer = space.rwbuffer_w(w_buffer)
length = rwbuffer.getlength()
res, newbuf = self.do_recv_string(space, length - offset,
PY_SSIZE_T_MAX)
try:
if newbuf:
raise BufferTooShort(
space, space.wrap(rffi.charpsize2str(newbuf, res)))
rwbuffer.setslice(offset, rffi.charpsize2str(self.buffer, res))
finally:
if newbuf:
rffi.free_charp(newbuf)
return space.wrap(res)
def llimpl_FormatError(code):
"Return a message corresponding to the given Windows error code."
buf = lltype.malloc(rffi.VOIDPP.TO, 1, flavor='raw')
try:
msglen = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM,
None,
code,
DEFAULT_LANGUAGE,
rffi.cast(rffi.VOIDP, buf),
0, None)
if msglen <= 2 or msglen > sys.maxint:
return fake_FormatError(code)
# FormatMessage always appends \r\n.
buflen = intmask(msglen - 2)
assert buflen > 0
result = rffi.charpsize2str(buf[0], buflen)
LocalFree(buf[0])
finally:
lltype.free(buf, flavor='raw')
return result
def peer_certificate(self, der=False):
"""peer_certificate([der=False]) -> certificate
Returns the certificate for the peer. If no certificate was provided,
returns None. If a certificate was provided, but not validated, returns
an empty dictionary. Otherwise returns a dict containing information
about the peer certificate.
If the optional argument is True, returns a DER-encoded copy of the
peer certificate, or None if no certificate was provided. This will
return the certificate even if it wasn't validated."""
if not self.peer_cert:
return self.space.w_None
if der:
# return cert in DER-encoded format
with lltype.scoped_alloc(rffi.CCHARPP.TO, 1) as buf_ptr:
buf_ptr[0] = lltype.nullptr(rffi.CCHARP.TO)
length = libssl_i2d_X509(self.peer_cert, buf_ptr)
if length < 0:
raise _ssl_seterror(self.space, self, length)
try:
# this is actually an immutable bytes sequence
return self.space.wrap(
rffi.charpsize2str(buf_ptr[0], length))
finally:
libssl_OPENSSL_free(buf_ptr[0])
else:
verification = libssl_SSL_CTX_get_verify_mode(
libssl_SSL_get_SSL_CTX(self.ssl))
if not verification & SSL_VERIFY_PEER:
return self.space.newdict()
else:
return _decode_certificate(self.space, self.peer_cert)
def Array_to_str(vm):
(self,),_ = vm.decode_args("!", self_of=Array)
assert isinstance(self, Array)
data = rffi.charpsize2str(self.data, self.num_entries * self.type_size)
objectmodel.keepalive_until_here(self)
return Con_String(vm, data)
def llimpl_FormatError(code):
"Return a message corresponding to the given Windows error code."
buf = lltype.malloc(rffi.CCHARPP.TO, 1, flavor='raw')
try:
msglen = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM,
None,
rffi.cast(DWORD, code),
DEFAULT_LANGUAGE,
rffi.cast(rffi.CCHARP, buf),
0, None)
if msglen <= 2: # includes the case msglen < 0
return fake_FormatError(code)
# FormatMessage always appends \r\n.
buflen = intmask(msglen - 2)
assert buflen > 0
result = rffi.charpsize2str(buf[0], buflen)
LocalFree(rffi.cast(rffi.VOIDP, buf[0]))
finally:
lltype.free(buf, flavor='raw')
return result
def load_resource(filename,resname,resid,reslang):
"""Load the named resource from the given file.
The filename and resource name must be ascii strings, and the resid and
reslang must be integers.
"""
l_handle = k32_LoadLibraryExA(filename,0,LOAD_LIBRARY_AS_DATAFILE)
if not l_handle:
raise WindowsError(rwin32.GetLastError(),"LoadLibraryExW failed")
try:
r_handle = k32_FindResourceExA(l_handle,resname,resid,reslang)
if not r_handle:
raise WindowsError(rwin32.GetLastError(),"FindResourceExA failed")
r_size = k32_SizeofResource(l_handle,r_handle)
if not r_size:
raise WindowsError(rwin32.GetLastError(),"SizeofResource failed")
r_info = k32_LoadResource(l_handle,r_handle)
if not r_info:
raise WindowsError(rwin32.GetLastError(),"LoadResource failed")
r_ptr = k32_LockResource(r_info)
if not r_ptr:
raise WindowsError(rwin32.GetLastError(),"LockResource failed")
return rffi.charpsize2str(r_ptr,r_size)
finally:
if not k32_FreeLibrary(l_handle):
raise WindowsError(rwin32.GetLastError(),"FreeLibrary failed")
def ioctl(space, w_fd, op, w_arg=0, mutate_flag=True):
"""ioctl(fd, opt[, arg[, mutate_flag]])
Perform the requested operation on file descriptor fd. The operation is
defined by opt and is operating system dependent. Typically these codes
are retrieved from the fcntl or termios library modules.
The argument arg is optional, and defaults to 0; it may be an int or a
buffer containing character data (most likely a string or an array).
If the argument is a mutable buffer (such as an array) and if the
mutate_flag argument (which is only allowed in this case) is true then the
buffer is (in effect) passed to the operating system and changes made by
the OS will be reflected in the contents of the buffer after the call has
returned. The return value is the integer returned by the ioctl system
call.
If the argument is a mutable buffer and the mutable_flag argument is not
passed or is false, the behavior is as if a string had been passed. This
behavior will change in future releases of Python.
If the argument is an immutable buffer (most likely a string) then a copy
of the buffer is passed to the operating system and the return value is a
string of the same length containing whatever the operating system put in
the buffer. The length of the arg buffer in this case is not allowed to
exceed 1024 bytes.
If the arg given is an integer or if none is specified, the result value
is an integer corresponding to the return value of the ioctl call in the
C code."""
fd = _conv_descriptor(space, w_fd)
# Python turns number > sys.maxint into long, we need the signed C value
op = rffi.cast(rffi.INT, op)
IOCTL_BUFSZ = 1024
if space.is_w(space.type(w_arg), space.w_int):
arg = space.int_w(w_arg)
rv = ioctl_int(fd, op, arg)
if rv < 0:
raise OperationError(space.w_IOError,
space.wrap(_get_error_msg()))
return space.wrap(rv)
elif space.is_w(space.type(w_arg), space.w_str): # immutable
arg = space.str_w(w_arg)
if len(arg) > IOCTL_BUFSZ:
raise OperationError(space.w_ValueError,
space.wrap("ioctl string arg too long"))
ll_arg = rffi.str2charp(arg)
rv = ioctl_str(fd, op, ll_arg)
arg = rffi.charpsize2str(ll_arg, len(arg))
lltype.free(ll_arg, flavor='raw')
if rv < 0:
raise OperationError(space.w_IOError,
space.wrap(_get_error_msg()))
return space.wrap(arg)
else:
raise OperationError(space.w_TypeError,
space.wrap("an integer or a buffer required"))
def convert_from_regdata(space, buf, buflen, typ):
if typ == rwinreg.REG_DWORD:
if not buflen:
return space.wrap(0)
d = rffi.cast(rwin32.LPDWORD, buf)[0]
return space.wrap(d)
elif typ == rwinreg.REG_SZ or typ == rwinreg.REG_EXPAND_SZ:
if not buflen:
return space.wrap("")
s = rffi.charp2strn(rffi.cast(rffi.CCHARP, buf), buflen)
return space.wrap(s)
elif typ == rwinreg.REG_MULTI_SZ:
if not buflen:
return space.newlist([])
i = 0
l = []
while i < buflen and buf[i]:
s = []
while i < buflen and buf[i] != '\0':
s.append(buf[i])
i += 1
if len(s) == 0:
break
s = ''.join(s)
l.append(space.wrap(s))
i += 1
return space.newlist(l)
else: # REG_BINARY and all other types
return space.wrap(rffi.charpsize2str(buf, buflen))
def encodeex(encodebuf, unicodedata, errors="strict", errorcb=None,
namecb=None, ignore_error=0):
inleft = len(unicodedata)
inbuf = rffi.get_nonmoving_unicodebuffer(unicodedata)
try:
if pypy_cjk_enc_init(encodebuf, inbuf, inleft) < 0:
raise MemoryError
if ignore_error == 0:
flags = MBENC_FLUSH | MBENC_RESET
else:
flags = 0
while True:
r = pypy_cjk_enc_chunk(encodebuf, flags)
if r == 0 or r == ignore_error:
break
multibytecodec_encerror(encodebuf, r, errors,
errorcb, namecb, unicodedata)
while flags & MBENC_RESET:
r = pypy_cjk_enc_reset(encodebuf)
if r == 0:
break
multibytecodec_encerror(encodebuf, r, errors,
errorcb, namecb, unicodedata)
src = pypy_cjk_enc_outbuf(encodebuf)
length = pypy_cjk_enc_outlen(encodebuf)
return rffi.charpsize2str(src, length)
#
finally:
rffi.free_nonmoving_unicodebuffer(unicodedata, inbuf)
def encode(codec, unicodedata, errors="strict", errorcb=None, namecb=None):
inleft = len(unicodedata)
inbuf = rffi.get_nonmoving_unicodebuffer(unicodedata)
try:
encodebuf = pypy_cjk_enc_init(codec, inbuf, inleft)
if not encodebuf:
raise MemoryError
try:
while True:
r = pypy_cjk_enc_chunk(encodebuf)
if r == 0:
break
multibytecodec_encerror(encodebuf, r, errors,
codec, errorcb, namecb, unicodedata)
while True:
r = pypy_cjk_enc_reset(encodebuf)
if r == 0:
break
multibytecodec_encerror(encodebuf, r, errors,
codec, errorcb, namecb, unicodedata)
src = pypy_cjk_enc_outbuf(encodebuf)
length = pypy_cjk_enc_outlen(encodebuf)
return rffi.charpsize2str(src, length)
#
finally:
pypy_cjk_enc_free(encodebuf)
#
finally:
rffi.free_nonmoving_unicodebuffer(unicodedata, inbuf)
def Array_serialize(vm):
(self,),_ = vm.decode_args("!", self_of=Array)
assert isinstance(self, Array)
data = rffi.charpsize2str(self.data, self.num_entries * self.type_size)
objectmodel.keepalive_until_here(self) # XXX I don't really understand why this is needed
return Con_String(vm, data)
def mk_mod(vm, bc, mod_off):
mod_size = read_word(bc, mod_off + BC_MOD_SIZE)
assert mod_off >= 0 and mod_size >= 0
mod_bc = rffi.ptradd(bc, mod_off)
name = _extract_sstr(mod_bc, BC_MOD_NAME, BC_MOD_NAME_SIZE)
id_ = _extract_sstr(mod_bc, BC_MOD_ID, BC_MOD_ID_SIZE)
src_path = _extract_sstr(mod_bc, BC_MOD_SRC_PATH, BC_MOD_SRC_PATH_SIZE)
imps = []
j = read_word(mod_bc, BC_MOD_IMPORTS)
for k in range(read_word(mod_bc, BC_MOD_NUM_IMPORTS)):
assert j > 0
imp_size = read_word(mod_bc, j)
assert imp_size > 0
j += INTSIZE
imps.append(rffi.charpsize2str(rffi.ptradd(mod_bc, j), imp_size))
j += align(imp_size)
j += INTSIZE + align(read_word(mod_bc, j))
num_vars = read_word(mod_bc, BC_MOD_NUM_TL_VARS_MAP)
tlvars_map = {}
j = read_word(mod_bc, BC_MOD_TL_VARS_MAP)
for k in range(num_vars):
assert j > 0
var_num = read_word(mod_bc, j)
j += INTSIZE
tlvar_size = read_word(mod_bc, j)
assert tlvar_size > 0
j += INTSIZE
n = rffi.charpsize2str(rffi.ptradd(mod_bc, j), tlvar_size)
tlvars_map[n] = var_num
j += align(tlvar_size)
num_consts = read_word(mod_bc, BC_MOD_NUM_CONSTANTS)
mod = Builtins.new_bc_con_module(vm, mod_bc, name, id_, src_path, imps, tlvars_map, num_consts)
init_func_off = read_word(mod_bc, BC_MOD_INSTRUCTIONS)
pc = BC_PC(mod, init_func_off)
max_stack_size = 512 # XXX!
mod.init_func = Builtins.Con_Func(vm, Builtins.Con_String(vm, "$$init$$"), False, pc, \
max_stack_size, 0, num_vars, mod, None)
return mod
def _digest(self, space):
with lltype.scoped_alloc(ropenssl.EVP_MD_CTX.TO) as ctx:
with self.lock:
ropenssl.EVP_MD_CTX_copy(ctx, self.ctx)
digest_size = self.digest_size
with lltype.scoped_alloc(rffi.CCHARP.TO, digest_size) as digest:
ropenssl.EVP_DigestFinal(ctx, digest, None)
ropenssl.EVP_MD_CTX_cleanup(ctx)
return rffi.charpsize2str(digest, digest_size)
def _digest(self, space):
with lltype.scoped_alloc(ropenssl.EVP_MD_CTX.TO) as ctx:
with self.lock:
ropenssl.EVP_MD_CTX_copy(ctx, self.ctx)
digest_size = self.digest_size
with lltype.scoped_alloc(rffi.CCHARP.TO, digest_size) as digest:
ropenssl.EVP_DigestFinal(ctx, digest, None)
ropenssl.EVP_MD_CTX_cleanup(ctx)
return rffi.charpsize2str(digest, digest_size)
def PyUnicode_DecodeUTF32(space, s, size, llerrors, pbyteorder):
"""Decode length bytes from a UTF-32 encoded buffer string and
return the corresponding Unicode object. errors (if non-NULL)
defines the error handling. It defaults to "strict".
If byteorder is non-NULL, the decoder starts decoding using the
given byte order:
*byteorder == -1: little endian
*byteorder == 0: native order
*byteorder == 1: big endian
If *byteorder is zero, and the first four bytes of the input data
are a byte order mark (BOM), the decoder switches to this byte
order and the BOM is not copied into the resulting Unicode string.
If *byteorder is -1 or 1, any byte order mark is copied to the
output.
After completion, *byteorder is set to the current byte order at
the end of input data.
In a narrow build codepoints outside the BMP will be decoded as
surrogate pairs.
If byteorder is NULL, the codec starts in native order mode.
Return NULL if an exception was raised by the codec.
"""
string = rffi.charpsize2str(s, size)
if pbyteorder:
llbyteorder = rffi.cast(lltype.Signed, pbyteorder[0])
if llbyteorder < 0:
byteorder = "little"
elif llbyteorder > 0:
byteorder = "big"
else:
byteorder = "native"
else:
byteorder = "native"
if llerrors:
errors = rffi.charp2str(llerrors)
else:
errors = None
result, length, byteorder = runicode.str_decode_utf_32_helper(
string,
size,
errors,
True, # final ? false for multiple passes?
None, # errorhandler
byteorder)
if pbyteorder is not None:
pbyteorder[0] = rffi.cast(rffi.INT, byteorder)
return space.wrap(result)
def PyUnicode_DecodeUTF16(space, s, size, llerrors, pbyteorder):
"""Decode length bytes from a UTF-16 encoded buffer string and return the
corresponding Unicode object. errors (if non-NULL) defines the error
handling. It defaults to "strict".
If byteorder is non-NULL, the decoder starts decoding using the given byte
order:
*byteorder == -1: little endian
*byteorder == 0: native order
*byteorder == 1: big endian
If *byteorder is zero, and the first two bytes of the input data are a
byte order mark (BOM), the decoder switches to this byte order and the BOM is
not copied into the resulting Unicode string. If *byteorder is -1 or
1, any byte order mark is copied to the output (where it will result in
either a \ufeff or a \ufffe character).
After completion, *byteorder is set to the current byte order at the end
of input data.
If byteorder is NULL, the codec starts in native order mode.
Return NULL if an exception was raised by the codec."""
string = rffi.charpsize2str(s, size)
#FIXME: I don't like these prefixes
if pbyteorder is not None: # correct NULL check?
llbyteorder = rffi.cast(lltype.Signed,
pbyteorder[0]) # compatible with int?
if llbyteorder < 0:
byteorder = "little"
elif llbyteorder > 0:
byteorder = "big"
else:
byteorder = "native"
else:
byteorder = "native"
if llerrors:
errors = rffi.charp2str(llerrors)
else:
errors = None
result, length, byteorder = runicode.str_decode_utf_16_helper(
string,
size,
errors,
True, # final ? false for multiple passes?
None, # errorhandler
byteorder)
if pbyteorder is not None:
pbyteorder[0] = rffi.cast(rffi.INT, byteorder)
return space.wrap(result)
def string_realize(space, py_obj):
"""
Creates the string in the interpreter. The PyStringObject buffer must not
be modified after this call.
"""
py_str = rffi.cast(PyStringObject, py_obj)
s = rffi.charpsize2str(py_str.c_buffer, py_str.c_size)
w_obj = space.wrap(s)
track_reference(space, py_obj, w_obj)
return w_obj
def _sendall(self, space, message, size):
while size > 0:
# XXX inefficient
data = rffi.charpsize2str(message, size)
try:
count = self.WRITE(data)
except OSError, e:
raise wrap_oserror(space, e)
size -= count
message = rffi.ptradd(message, count)
def string_realize(space, py_obj):
"""
Creates the string in the interpreter. The PyStringObject buffer must not
be modified after this call.
"""
py_str = rffi.cast(PyStringObject, py_obj)
s = rffi.charpsize2str(py_str.c_buffer, py_str.c_size)
w_obj = space.wrap(s)
track_reference(space, py_obj, w_obj)
return w_obj
def _sendall(self, space, message, size):
while size > 0:
# XXX inefficient
data = rffi.charpsize2str(message, size)
try:
count = self.WRITE(data)
except OSError, e:
raise wrap_oserror(space, e)
size -= count
message = rffi.ptradd(message, count)
def recv(self, space):
self._check_readable(space)
res, newbuf = self.do_recv_string(space, self.BUFFER_SIZE, PY_SSIZE_T_MAX)
res = intmask(res) # XXX why?
try:
if newbuf:
w_received = space.wrap(rffi.charpsize2str(newbuf, res))
else:
w_received = space.wrap(rffi.charpsize2str(self.buffer, res))
finally:
if newbuf:
rffi.free_charp(newbuf)
w_builtins = space.getbuiltinmodule("__builtin__")
w_picklemodule = space.call_method(w_builtins, "__import__", space.wrap("pickle"))
w_unpickled = space.call_method(w_picklemodule, "loads", w_received)
return w_unpickled
def Array_get_slice(vm):
mod = vm.get_funcs_mod()
(self, i_o, j_o),_ = vm.decode_args("!", opt="ii", self_of=Array)
assert isinstance(self, Array)
i, j = translate_slice_idx_objs(vm, i_o, j_o, self.num_entries)
# This does a double allocation, so isn't very efficient. It is pleasingly simple though.
data = rffi.charpsize2str(rffi.ptradd(self.data, i * self.type_size), int((j - i) * self.type_size))
objectmodel.keepalive_until_here(self)
return Array(vm, mod.get_defn(vm, "Array"), self.type_name, Con_String(vm, data))
def PyUnicode_DecodeUTF8(space, s, size, errors):
"""Create a Unicode object by decoding size bytes of the UTF-8 encoded string
s. Return NULL if an exception was raised by the codec.
"""
w_str = space.wrap(rffi.charpsize2str(s, size))
if errors:
w_errors = space.wrap(rffi.charp2str(errors))
else:
w_errors = space.w_None
return space.call_method(w_str, 'decode', space.wrap("utf-8"), w_errors)
def PyUnicode_FromStringAndSize(space, s, size):
"""Create a Unicode Object from the char buffer u. The bytes will be
interpreted as being UTF-8 encoded. u may also be NULL which causes the
contents to be undefined. It is the user's responsibility to fill in the
needed data. The buffer is copied into the new object. If the buffer is not
NULL, the return value might be a shared object. Therefore, modification of
the resulting Unicode object is only allowed when u is NULL."""
if not s:
raise NotImplementedError
w_str = space.wrap(rffi.charpsize2str(s, size))
return space.call_method(w_str, "decode", space.wrap("utf-8"))
def PyUnicode_DecodeUTF32(space, s, size, llerrors, pbyteorder):
"""Decode length bytes from a UTF-32 encoded buffer string and
return the corresponding Unicode object. errors (if non-NULL)
defines the error handling. It defaults to "strict".
If byteorder is non-NULL, the decoder starts decoding using the
given byte order:
*byteorder == -1: little endian
*byteorder == 0: native order
*byteorder == 1: big endian
If *byteorder is zero, and the first four bytes of the input data
are a byte order mark (BOM), the decoder switches to this byte
order and the BOM is not copied into the resulting Unicode string.
If *byteorder is -1 or 1, any byte order mark is copied to the
output.
After completion, *byteorder is set to the current byte order at
the end of input data.
In a narrow build codepoints outside the BMP will be decoded as
surrogate pairs.
If byteorder is NULL, the codec starts in native order mode.
Return NULL if an exception was raised by the codec.
"""
string = rffi.charpsize2str(s, size)
if pbyteorder:
llbyteorder = rffi.cast(lltype.Signed, pbyteorder[0])
if llbyteorder < 0:
byteorder = "little"
elif llbyteorder > 0:
byteorder = "big"
else:
byteorder = "native"
else:
byteorder = "native"
if llerrors:
errors = rffi.charp2str(llerrors)
else:
errors = None
result, length, byteorder = runicode.str_decode_utf_32_helper(
string, size, errors,
True, # final ? false for multiple passes?
None, # errorhandler
byteorder)
if pbyteorder is not None:
pbyteorder[0] = rffi.cast(rffi.INT, byteorder)
return space.wrap(result)
def PyUnicode_FromStringAndSize(space, s, size):
"""Create a Unicode Object from the char buffer u. The bytes will be
interpreted as being UTF-8 encoded. u may also be NULL which causes the
contents to be undefined. It is the user's responsibility to fill in the
needed data. The buffer is copied into the new object. If the buffer is not
NULL, the return value might be a shared object. Therefore, modification of
the resulting Unicode object is only allowed when u is NULL."""
if not s:
raise NotImplementedError
w_str = space.wrap(rffi.charpsize2str(s, size))
return space.call_method(w_str, 'decode', space.wrap("utf-8"))
def PyUnicode_DecodeXXX(space, s, size, errors):
"""Create a Unicode object by decoding size bytes of the
encoded string s. Return NULL if an exception was raised by
the codec.
"""
w_s = space.wrap(rffi.charpsize2str(s, size))
if errors:
w_errors = space.wrap(rffi.charp2str(errors))
else:
w_errors = space.w_None
return space.call_method(w_s, 'decode', space.wrap(encoding), w_errors)
def canon_path(vm):
(p_o,),_ = vm.decode_args("S")
assert isinstance(p_o, Con_String)
with lltype.scoped_alloc(rffi.CCHARP.TO, PATH_MAX) as resolved:
r = realpath(p_o.v, resolved)
if not r:
_errno_raise(vm, p_o)
rp = rffi.charpsize2str(resolved, rarithmetic.intmask(strlen(resolved)))
return Con_String(vm, rp)
def recv(self, space):
self._check_readable(space)
res, newbuf = self.do_recv_string(space, self.BUFFER_SIZE,
PY_SSIZE_T_MAX)
try:
if newbuf:
w_received = space.wrap(rffi.charpsize2str(newbuf, res))
else:
w_received = space.wrap(rffi.charpsize2str(self.buffer, res))
finally:
if newbuf:
rffi.free_charp(newbuf)
w_builtins = space.getbuiltinmodule('__builtin__')
w_picklemodule = space.call_method(w_builtins, '__import__',
space.wrap("pickle"))
w_unpickled = space.call_method(w_picklemodule, "loads", w_received)
return w_unpickled
def _digest(self, space):
copy = self.copy(space)
ctx = copy.ctx
digest_size = self._digest_size()
digest = lltype.malloc(rffi.CCHARP.TO, digest_size, flavor='raw')
try:
ropenssl.EVP_DigestFinal(ctx, digest, None)
return rffi.charpsize2str(digest, digest_size)
finally:
keepalive_until_here(copy)
lltype.free(digest, flavor='raw')
def PyUnicode_DecodeUTF16(space, s, size, llerrors, pbyteorder):
"""Decode length bytes from a UTF-16 encoded buffer string and return the
corresponding Unicode object. errors (if non-NULL) defines the error
handling. It defaults to "strict".
If byteorder is non-NULL, the decoder starts decoding using the given byte
order:
*byteorder == -1: little endian
*byteorder == 0: native order
*byteorder == 1: big endian
If *byteorder is zero, and the first two bytes of the input data are a
byte order mark (BOM), the decoder switches to this byte order and the BOM is
not copied into the resulting Unicode string. If *byteorder is -1 or
1, any byte order mark is copied to the output (where it will result in
either a \ufeff or a \ufffe character).
After completion, *byteorder is set to the current byte order at the end
of input data.
If byteorder is NULL, the codec starts in native order mode.
Return NULL if an exception was raised by the codec."""
string = rffi.charpsize2str(s, size)
#FIXME: I don't like these prefixes
if pbyteorder is not None: # correct NULL check?
llbyteorder = rffi.cast(lltype.Signed, pbyteorder[0]) # compatible with int?
if llbyteorder < 0:
byteorder = "little"
elif llbyteorder > 0:
byteorder = "big"
else:
byteorder = "native"
else:
byteorder = "native"
if llerrors:
errors = rffi.charp2str(llerrors)
else:
errors = None
result, length, byteorder = runicode.str_decode_utf_16_helper(string, size,
errors,
True, # final ? false for multiple passes?
None, # errorhandler
byteorder)
if pbyteorder is not None:
pbyteorder[0] = rffi.cast(rffi.INT, byteorder)
return space.wrap(result)
def PyUnicode_Decode(space, s, size, encoding, errors):
"""Create a Unicode object by decoding size bytes of the encoded string s.
encoding and errors have the same meaning as the parameters of the same name
in the unicode() built-in function. The codec to be used is looked up
using the Python codec registry. Return NULL if an exception was raised by
the codec."""
w_str = space.wrap(rffi.charpsize2str(s, size))
w_encoding = space.wrap(rffi.charp2str(encoding))
if errors:
w_errors = space.wrap(rffi.charp2str(errors))
else:
w_errors = space.w_None
return space.call_method(w_str, "decode", w_encoding, w_errors)
def PyUnicode_Decode(space, s, size, encoding, errors):
"""Create a Unicode object by decoding size bytes of the encoded string s.
encoding and errors have the same meaning as the parameters of the same name
in the unicode() built-in function. The codec to be used is looked up
using the Python codec registry. Return NULL if an exception was raised by
the codec."""
w_str = space.wrap(rffi.charpsize2str(s, size))
w_encoding = space.wrap(rffi.charp2str(encoding))
if errors:
w_errors = space.wrap(rffi.charp2str(errors))
else:
w_errors = space.w_None
return space.call_method(w_str, 'decode', w_encoding, w_errors)
def PyRun_File(space, fp, filename, start, w_globals, w_locals):
"""This is a simplified interface to PyRun_FileExFlags() below, leaving
closeit set to 0 and flags set to NULL."""
BUF_SIZE = 8192
source = ""
filename = rffi.charp2str(filename)
buf = lltype.malloc(rffi.CCHARP.TO, BUF_SIZE, flavor='raw')
try:
while True:
count = fread(buf, 1, BUF_SIZE, fp)
count = rffi.cast(lltype.Signed, count)
source += rffi.charpsize2str(buf, count)
if count < BUF_SIZE:
if feof(fp):
break
PyErr_SetFromErrno(space, space.w_IOError)
finally:
lltype.free(buf, flavor='raw')
return run_string(space, source, filename, start, w_globals, w_locals)
def initialize(self, connection, param):
# determine the name of the attribute
nameptr = lltype.malloc(rffi.CArrayPtr(roci.oratext).TO, 1,
flavor='raw')
lenptr = lltype.malloc(rffi.CArrayPtr(roci.ub4).TO, 1,
flavor='raw')
try:
status = roci.OCIAttrGet(
param, roci.OCI_DTYPE_PARAM,
rffi.cast(roci.dvoidp, nameptr),
lenptr,
roci.OCI_ATTR_NAME,
connection.environment.errorHandle)
connection.environment.checkForError(
status,
"ObjectAttribute_Initialize(): get name")
self.name = rffi.charpsize2str(nameptr[0], lenptr[0])
finally:
lltype.free(nameptr, flavor='raw')
lltype.free(lenptr, flavor='raw')
# determine the type of the attribute
typecodeptr = lltype.malloc(roci.Ptr(roci.OCITypeCode).TO,
1, flavor='raw')
try:
status = roci.OCIAttrGet(
param, roci.OCI_DTYPE_PARAM,
rffi.cast(roci.dvoidp, typecodeptr),
lltype.nullptr(roci.Ptr(roci.ub4).TO),
roci.OCI_ATTR_TYPECODE,
connection.environment.errorHandle)
connection.environment.checkForError(
status, "ObjectType_Describe(): get type code")
self.typeCode = rffi.cast(lltype.Signed, typecodeptr[0])
finally:
lltype.free(typecodeptr, flavor='raw')
# if the type of the attribute is object, recurse
if self.typeCode in (roci.OCI_TYPECODE_NAMEDCOLLECTION,
roci.OCI_TYPECODE_OBJECT):
self.subType = W_ObjectType(connection, param)
else:
self.subType = None
def fcntl(space, w_fd, op, w_arg=0):
"""fcntl(fd, op, [arg])
Perform the requested operation on file descriptor fd. The operation
is defined by op and is operating system dependent. These constants are
available from the fcntl module. The argument arg is optional, and
defaults to 0; it may be an int or a string. If arg is given as a string,
the return value of fcntl is a string of that length, containing the
resulting value put in the arg buffer by the operating system. The length
of the arg string is not allowed to exceed 1024 bytes. If the arg given
is an integer or if none is specified, the result value is an integer
corresponding to the return value of the fcntl call in the C code."""
fd = _conv_descriptor(space, w_fd)
if space.is_w(space.type(w_arg), space.w_int):
rv = fcntl_int(fd, op, space.int_w(w_arg))
if rv < 0:
raise OperationError(space.w_IOError,
space.wrap(_get_error_msg()))
return space.wrap(rv)
elif space.is_w(space.type(w_arg), space.w_str):
arg = space.str_w(w_arg)
if len(arg) > 1024: # XXX probably makes no sense for PyPy
raise OperationError(space.w_ValueError,
space.wrap("fcntl string arg too long"))
ll_arg = rffi.str2charp(arg)
rv = fcntl_str(fd, op, ll_arg)
arg = rffi.charpsize2str(ll_arg, len(arg))
lltype.free(ll_arg, flavor='raw')
if rv < 0:
raise OperationError(space.w_IOError,
space.wrap(_get_error_msg()))
return space.wrap(arg)
else:
raise OperationError(space.w_TypeError,
space.wrap("int or string required"))
def w_string(space, buf, len=-1):
if len < 0:
return space.wrap(rffi.charp2str(buf))
else:
return space.wrap(rffi.charpsize2str(buf, len))
def array_tostring__Array(space, self):
cbuf = self._charbuf_start()
s = rffi.charpsize2str(cbuf, self.len * mytype.bytes)
self._charbuf_stop()
return self.space.wrap(s)
def _itemDescription(self, space, pos):
"Return a tuple describing the item at the given position"
# acquire parameter descriptor
paramptr = lltype.malloc(roci.Ptr(roci.OCIParam).TO, 1, flavor='raw')
try:
status = roci.OCIParamGet(self.handle, roci.OCI_HTYPE_STMT,
self.environment.errorHandle,
rffi.cast(roci.dvoidpp, paramptr), pos)
self.environment.checkForError(
status, "Cursor_GetDescription(): parameter")
param = paramptr[0]
finally:
lltype.free(paramptr, flavor='raw')
try:
# acquire usable type of item
varType = interp_variable.typeByOracleDescriptor(
param, self.environment)
# acquire internal size of item
attrptr = lltype.malloc(rffi.CArrayPtr(roci.ub2).TO,
1,
flavor='raw')
try:
status = roci.OCIAttrGet(param, roci.OCI_HTYPE_DESCRIBE,
rffi.cast(roci.dvoidp, attrptr),
lltype.nullptr(roci.Ptr(roci.ub4).TO),
roci.OCI_ATTR_DATA_SIZE,
self.environment.errorHandle)
self.environment.checkForError(
status, "Cursor_ItemDescription(): internal size")
internalSize = rffi.cast(lltype.Signed, attrptr[0])
finally:
lltype.free(attrptr, flavor='raw')
# acquire name of item
nameptr = lltype.malloc(rffi.CArrayPtr(roci.oratext).TO,
1,
flavor='raw')
lenptr = lltype.malloc(rffi.CArrayPtr(roci.ub4).TO,
1,
flavor='raw')
try:
status = roci.OCIAttrGet(param, roci.OCI_HTYPE_DESCRIBE,
rffi.cast(roci.dvoidp, nameptr),
lenptr, roci.OCI_ATTR_NAME,
self.environment.errorHandle)
self.environment.checkForError(
status, "Cursor_ItemDescription(): name")
name = rffi.charpsize2str(nameptr[0],
rffi.cast(lltype.Signed, lenptr[0]))
finally:
lltype.free(nameptr, flavor='raw')
lltype.free(lenptr, flavor='raw')
# lookup precision and scale
if varType is interp_variable.VT_Float:
attrptr = lltype.malloc(rffi.CArrayPtr(roci.sb1).TO,
1,
flavor='raw')
try:
status = roci.OCIAttrGet(
param, roci.OCI_HTYPE_DESCRIBE,
rffi.cast(roci.dvoidp, attrptr),
lltype.nullptr(roci.Ptr(roci.ub4).TO),
roci.OCI_ATTR_SCALE, self.environment.errorHandle)
self.environment.checkForError(
status, "Cursor_ItemDescription(): scale")
scale = rffi.cast(lltype.Signed, attrptr[0])
finally:
lltype.free(attrptr, flavor='raw')
attrptr = lltype.malloc(rffi.CArrayPtr(roci.ub2).TO,
1,
flavor='raw')
try:
status = roci.OCIAttrGet(
param, roci.OCI_HTYPE_DESCRIBE,
rffi.cast(roci.dvoidp, attrptr),
lltype.nullptr(roci.Ptr(roci.ub4).TO),
roci.OCI_ATTR_PRECISION, self.environment.errorHandle)
self.environment.checkForError(
status, "Cursor_ItemDescription(): precision")
precision = rffi.cast(lltype.Signed, attrptr[0])
finally:
lltype.free(attrptr, flavor='raw')
else:
scale = 0
precision = 0
# lookup whether null is permitted for the attribute
attrptr = lltype.malloc(rffi.CArrayPtr(roci.ub1).TO,
1,
flavor='raw')
try:
status = roci.OCIAttrGet(param, roci.OCI_HTYPE_DESCRIBE,
rffi.cast(roci.dvoidp, attrptr),
lltype.nullptr(roci.Ptr(roci.ub4).TO),
roci.OCI_ATTR_IS_NULL,
self.environment.errorHandle)
self.environment.checkForError(
status, "Cursor_ItemDescription(): nullable")
nullable = rffi.cast(lltype.Signed, attrptr[0]) != 0
finally:
lltype.free(attrptr, flavor='raw')
# set display size based on data type
if varType is interp_variable.VT_String:
displaySize = internalSize
elif varType is interp_variable.VT_NationalCharString:
displaySize = internalSize / 2
elif varType is interp_variable.VT_Binary:
displaySize = internalSize
elif varType is interp_variable.VT_FixedChar:
displaySize = internalSize
elif varType is interp_variable.VT_FixedNationalChar:
displaySize = internalSize / 2
elif varType is interp_variable.VT_Float:
if precision:
displaySize = precision + 1
if scale > 0:
displaySize += scale + 1
else:
displaySize = 127
elif varType is interp_variable.VT_DateTime:
displaySize = 23
else:
displaySize = -1
# return the tuple
return [
space.wrap(name),
space.gettypeobject(varType.typedef),
space.wrap(displaySize),
space.wrap(internalSize),
space.wrap(precision),
space.wrap(scale),
space.wrap(nullable)
]
finally:
roci.OCIDescriptorFree(param, roci.OCI_DTYPE_PARAM)
def _get_peer_alt_names(space, certificate):
# this code follows the procedure outlined in
# OpenSSL's crypto/x509v3/v3_prn.c:X509v3_EXT_print()
# function to extract the STACK_OF(GENERAL_NAME),
# then iterates through the stack to add the
# names.
if not certificate:
return space.w_None
# get a memory buffer
biobuf = libssl_BIO_new(libssl_BIO_s_mem())
try:
alt_names_w = []
i = 0
while True:
i = libssl_X509_get_ext_by_NID(certificate, NID_subject_alt_name,
i)
if i < 0:
break
# now decode the altName
ext = libssl_X509_get_ext(certificate, i)
method = libssl_X509V3_EXT_get(ext)
if not method:
raise ssl_error(
space, "No method for internalizing subjectAltName!'")
with lltype.scoped_alloc(rffi.CCHARPP.TO, 1) as p_ptr:
p_ptr[0] = ext[0].c_value.c_data
length = intmask(ext[0].c_value.c_length)
null = lltype.nullptr(rffi.VOIDP.TO)
if method[0].c_it:
names = rffi.cast(
GENERAL_NAMES,
libssl_ASN1_item_d2i(
null, p_ptr, length,
libssl_ASN1_ITEM_ptr(method[0].c_it)))
else:
names = rffi.cast(GENERAL_NAMES,
method[0].c_d2i(null, p_ptr, length))
for j in range(libssl_sk_GENERAL_NAME_num(names)):
# Get a rendering of each name in the set of names
name = libssl_sk_GENERAL_NAME_value(names, j)
if intmask(name[0].c_type) == GEN_DIRNAME:
# we special-case DirName as a tuple of tuples of attributes
dirname = libssl_pypy_GENERAL_NAME_dirn(name)
w_t = space.newtuple([
space.wrap("DirName"),
_create_tuple_for_X509_NAME(space, dirname)
])
else:
# for everything else, we use the OpenSSL print form
libssl_BIO_reset(biobuf)
libssl_GENERAL_NAME_print(biobuf, name)
with lltype.scoped_alloc(rffi.CCHARP.TO, 2048) as buf:
length = libssl_BIO_gets(biobuf, buf, 2047)
if length < 0:
raise _ssl_seterror(space, None, 0)
v = rffi.charpsize2str(buf, length)
v1, v2 = v.split(':', 1)
w_t = space.newtuple([space.wrap(v1), space.wrap(v2)])
alt_names_w.append(w_t)
finally:
libssl_BIO_free(biobuf)
if alt_names_w:
return space.newtuple(list(alt_names_w))
else:
return space.w_None
def initialize(self, connection, param):
nameptr = lltype.malloc(rffi.CArrayPtr(roci.oratext).TO, 1,
flavor='raw')
lenptr = lltype.malloc(rffi.CArrayPtr(roci.ub4).TO, 1,
flavor='raw')
try:
# determine the schema of the type
status = roci.OCIAttrGet(
param, roci.OCI_HTYPE_DESCRIBE,
rffi.cast(roci.dvoidp, nameptr),
lenptr,
roci.OCI_ATTR_SCHEMA_NAME,
self.environment.errorHandle)
self.environment.checkForError(
status,
"ObjectType_Initialize(): get schema name")
self.schema = rffi.charpsize2str(nameptr[0], lenptr[0])
# determine the name of the type
status = roci.OCIAttrGet(
param, roci.OCI_HTYPE_DESCRIBE,
rffi.cast(roci.dvoidp, nameptr),
lenptr,
roci.OCI_ATTR_TYPE_NAME,
self.environment.errorHandle)
self.environment.checkForError(
status,
"ObjectType_Initialize(): get schema name")
self.name = rffi.charpsize2str(nameptr[0], lenptr[0])
finally:
lltype.free(nameptr, flavor='raw')
lltype.free(lenptr, flavor='raw')
# retrieve TDO (type descriptor object) of the parameter
tdorefptr = lltype.malloc(rffi.CArrayPtr(roci.OCIRef).TO, 1,
flavor='raw')
try:
status = roci.OCIAttrGet(
param, roci.OCI_HTYPE_DESCRIBE,
rffi.cast(roci.dvoidp, tdorefptr),
lltype.nullptr(roci.Ptr(roci.ub4).TO),
roci.OCI_ATTR_REF_TDO,
self.environment.errorHandle)
self.environment.checkForError(
status,
"ObjectType_Initialize(): get TDO reference")
tdoref = tdorefptr[0]
finally:
lltype.free(tdorefptr, flavor='raw')
tdoptr = lltype.malloc(rffi.CArrayPtr(roci.dvoidp).TO, 1,
flavor='raw')
try:
status = roci.OCIObjectPin(
self.environment.handle,
self.environment.errorHandle,
tdoref,
None, roci.OCI_PIN_ANY,
roci.OCI_DURATION_SESSION, roci.OCI_LOCK_NONE,
tdoptr)
self.environment.checkForError(
status,
"ObjectType_Initialize(): pin TDO reference")
self.tdo = tdoptr[0]
finally:
lltype.free(tdoptr, flavor='raw')
# acquire a describe handle
handleptr = lltype.malloc(rffi.CArrayPtr(roci.OCIDescribe).TO,
1, flavor='raw')
try:
status = roci.OCIHandleAlloc(
self.environment.handle,
handleptr, roci.OCI_HTYPE_DESCRIBE, 0,
lltype.nullptr(rffi.CArray(roci.dvoidp)))
self.environment.checkForError(
status, "ObjectType_Initialize(): allocate describe handle")
describeHandle = handleptr[0]
finally:
lltype.free(handleptr, flavor='raw')
# describe the type
try:
self.describe(connection, describeHandle)
finally:
roci.OCIHandleFree(describeHandle, roci.OCI_HTYPE_DESCRIBE)