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, 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 freshKeypair():
"""
Make a fresh keypair.
"""
publicSize = intmask(cryptoBoxPublickeybytes())
secretSize = intmask(cryptoBoxSecretkeybytes())
with rffi.scoped_alloc_buffer(publicSize) as public:
with rffi.scoped_alloc_buffer(secretSize) as secret:
rv = cryptoBoxKeypair(public.raw, secret.raw)
if rv:
raise SodiumError("crypto_box_keypair: %d" % rv)
return public.str(publicSize), secret.str(secretSize)
def READ(self, size):
from rpython.rlib._rsocket_rffi import socketrecv, geterrno
with rffi.scoped_alloc_buffer(size) as buf:
length = socketrecv(self.fd, buf.raw, buf.size, 0)
if length < 0:
raise WindowsError(geterrno(), "recv")
return buf.str(length)
def recvfrom(self, buffersize, flags=0):
"""Like recv(buffersize, flags) but also return the sender's
address."""
read_bytes = -1
timeout = self._select(False)
if timeout == 1:
raise SocketTimeout
elif timeout == 0:
with rffi.scoped_alloc_buffer(buffersize) as buf:
address, addr_p, addrlen_p = self._addrbuf()
try:
read_bytes = _c.recvfrom(self.fd, buf.raw, buffersize, flags,
addr_p, addrlen_p)
addrlen = rffi.cast(lltype.Signed, addrlen_p[0])
finally:
lltype.free(addrlen_p, flavor='raw')
address.unlock()
if read_bytes >= 0:
if addrlen:
address.addrlen = addrlen
else:
address = None
data = buf.str(read_bytes)
return (data, address)
raise self.error_handler()
def recvfrom(self, buffersize, flags=0):
"""Like recv(buffersize, flags) but also return the sender's
address."""
read_bytes = -1
timeout = self._select(False)
if timeout == 1:
raise SocketTimeout
elif timeout == 0:
with rffi.scoped_alloc_buffer(buffersize) as buf:
address, addr_p, addrlen_p = self._addrbuf()
try:
read_bytes = _c.recvfrom(self.fd, buf.raw, buffersize, flags,
addr_p, addrlen_p)
addrlen = rffi.cast(lltype.Signed, addrlen_p[0])
finally:
lltype.free(addrlen_p, flavor='raw')
address.unlock()
if read_bytes >= 0:
if addrlen:
address.addrlen = addrlen
else:
address = None
data = buf.str(read_bytes)
return (data, address)
raise self.error_handler()
def READ(self, size):
from rpython.rlib._rsocket_rffi import socketrecv, geterrno
with rffi.scoped_alloc_buffer(size) as buf:
length = socketrecv(self.fd, buf.raw, buf.size, 0)
if length < 0:
raise WindowsError(geterrno(), "recv")
return buf.str(length)
def read(self, size=-1):
# XXX CPython uses a more delicate logic here
self._check_closed()
ll_file = self._ll_file
if size == 0:
return ""
elif size < 0:
# read the entire contents
buf = lltype.malloc(rffi.CCHARP.TO, BASE_BUF_SIZE, flavor='raw')
try:
s = StringBuilder()
while True:
returned_size = self._fread(buf, BASE_BUF_SIZE, ll_file)
returned_size = intmask(returned_size) # is between 0 and BASE_BUF_SIZE
if returned_size == 0:
if c_feof(ll_file):
# ok, finished
return s.build()
raise _error(ll_file)
s.append_charpsize(buf, returned_size)
finally:
lltype.free(buf, flavor='raw')
else: # size > 0
with rffi.scoped_alloc_buffer(size) as buf:
returned_size = self._fread(buf.raw, size, ll_file)
returned_size = intmask(returned_size) # is between 0 and size
if returned_size == 0:
if not c_feof(ll_file):
raise _error(ll_file)
s = buf.str(returned_size)
assert s is not None
return s
def read(self, size=-1):
# XXX CPython uses a more delicate logic here
self._check_closed()
ll_file = self._ll_file
if size == 0:
return ""
elif size < 0:
# read the entire contents
buf = lltype.malloc(rffi.CCHARP.TO, BASE_BUF_SIZE, flavor='raw')
try:
s = StringBuilder()
while True:
returned_size = self._fread(buf, BASE_BUF_SIZE, ll_file)
returned_size = intmask(returned_size) # is between 0 and BASE_BUF_SIZE
if returned_size == 0:
if c_feof(ll_file):
# ok, finished
return s.build()
raise _error(ll_file)
s.append_charpsize(buf, returned_size)
finally:
lltype.free(buf, flavor='raw')
else: # size > 0
with rffi.scoped_alloc_buffer(size) as buf:
returned_size = self._fread(buf.raw, size, ll_file)
returned_size = intmask(returned_size) # is between 0 and size
if returned_size == 0:
if not c_feof(ll_file):
raise _error(ll_file)
s = buf.str(returned_size)
assert s is not None
return s
def utf8_encode_code_page(cp, s, errors, errorhandler):
"""Encode a utf8 string s using code page cp and the given
errors/errorhandler.
Returns a encoded byte string
"""
name = _code_page_name(cp)
lgt = len(s)
if lgt == 0:
return ''
flags = _encode_code_page_flags(cp, errors)
if cp in (rwin32.CP_UTF8, rwin32.CP_UTF7):
used_default_p = lltype.nullptr(BOOLP.TO)
else:
used_default_p = lltype.malloc(BOOLP.TO, 1, flavor='raw')
# Encode one codpoint at a time to allow the errorhandlers to do
# their thing
chars = lltype.malloc(rffi.CWCHARP.TO, 2, flavor='raw')
res = StringBuilder(lgt)
try:
with rffi.scoped_alloc_buffer(4) as buf:
pos = 0
# TODO: update s if obj != s is returned from an errorhandler
for uni in Utf8StringIterator(s):
if used_default_p:
used_default_p[0] = rffi.cast(rwin32.BOOL, False)
if uni < 0x10000:
chars[0] = rffi.cast(lltype.UniChar, uni)
charsize = 1
else:
chars[0] = Py_UNICODE_HIGH_SURROGATE(uni)
chars[1] = Py_UNICODE_LOW_SURROGATE(uni)
charsize = 2
# first get the size of the result
outsize = WideCharToMultiByte(cp, flags, chars, charsize,
buf.raw, 4, None, used_default_p)
if outsize > 0:
if not (used_default_p and used_default_p[0]):
r = buf.str(outsize)
assert r is not None
res.append(r)
pos += 1
continue
elif rwin32.GetLastError_saved(
) != rwin32.ERROR_NO_UNICODE_TRANSLATION:
raise rwin32.lastSavedWindowsError()
# If we used a default char, then we failed!
r, pos, retype, obj = errorhandler(errors, name,
"invalid character", s, pos,
pos + 1)
res.append(r)
pos += 1
finally:
lltype.free(chars, flavor='raw')
if used_default_p:
lltype.free(used_default_p, flavor='raw')
return res.build()
def receive(self):
msgsize = self.msgsize
with rffi.scoped_alloc_buffer(msgsize) as msg_ptr:
with lltype.scoped_alloc(rffi.UINTP.TO, 1) as msg_prio:
size = check_call(
mq_receive(self.mqd, msg_ptr.raw, msgsize, msg_prio),
"mq_receive")
return msg_ptr.str(size), msg_prio[0]
def receive(self):
msgsize = self.msgsize
with rffi.scoped_alloc_buffer(msgsize) as msg_ptr:
with lltype.scoped_alloc(rffi.UINTP.TO, 1) as msg_prio:
size = check_call(mq_receive(self.mqd, msg_ptr.raw, msgsize,
msg_prio),
"mq_receive")
return msg_ptr.str(size), msg_prio[0]
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 rffi.scoped_alloc_buffer(digest_size) as buf:
ropenssl.EVP_DigestFinal(ctx, buf.raw, None)
ropenssl.EVP_MD_CTX_cleanup(ctx)
return buf.str(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 rffi.scoped_alloc_buffer(digest_size) as buf:
ropenssl.EVP_DigestFinal(ctx, buf.raw, None)
ropenssl.EVP_MD_CTX_cleanup(ctx)
return buf.str(digest_size)
def descr__unicode__(self, space):
h_str = support.emjs_to_string(self.handle)
_check_error(space, h_str)
# The buffer must hold utf8 version of the string, which
# might take up to four bytes per character.
bufsize = support.emjs_length(h_str) * 4
_check_error(space, bufsize)
with rffi.scoped_alloc_buffer(bufsize) as buf:
n = support.emjs_read_strn(h_str, buf.raw, buf.size)
return space.wrap(buf.str(n).decode("utf-8"))
def descr__unicode__(self, space):
h_str = support.emjs_to_string(self.handle)
_check_error(space, h_str)
# The buffer must hold utf8 version of the string, which
# might take up to four bytes per character.
bufsize = support.emjs_length(h_str) * 4
_check_error(space, bufsize)
with rffi.scoped_alloc_buffer(bufsize) as buf:
n = support.emjs_read_strn(h_str, buf.raw, buf.size)
return space.wrap(buf.str(n).decode("utf-8"))
def freshNonce():
"""
Make a fresh nonce.
"""
nonceSize = intmask(cryptoBoxNoncebytes())
with rffi.scoped_alloc_buffer(nonceSize) as nonce:
randombytesBuf(nonce.raw, nonceSize)
return nonce.str(nonceSize)
def copy_bio_ssl(bio, w_dst, dstlen, loglevel):
nbytes = ropenssl.libssl_BIO_ctrl_pending(bio)
if loglevel:
print("copy_bio_ssl: %s bytes pending; buffer size %s" %
(nbytes, dstlen))
if nbytes > dstlen: # more bytes to copy than available
return -1
with rffi.scoped_alloc_buffer(nbytes) as buf:
r = ropenssl.libssl_BIO_read(bio, buf.raw, dstlen)
for idx in range(r):
w_dst.setchar(idx, buf.raw[idx])
return r
def copy_bio_ssl(bio, w_dst, dstlen, loglevel):
nbytes = ropenssl.libssl_BIO_ctrl_pending(bio)
if loglevel:
print ("copy_bio_ssl: %s bytes pending; buffer size %s" %
(nbytes, dstlen))
if nbytes > dstlen: # more bytes to copy than available
return -1
with rffi.scoped_alloc_buffer(nbytes) as buf:
r = ropenssl.libssl_BIO_read(bio, buf.raw, dstlen)
for idx in range(r):
w_dst.setchar(idx, buf.raw[idx])
return r
def get_profile_path(space):
vmp = _get_vmprof()
if not vmp.is_enabled:
return None
with rffi.scoped_alloc_buffer(4096) as buf:
length = vmp.cintf.vmprof_get_profile_path(buf.raw, buf.size)
if length == -1:
return ""
return buf.str(length)
return None
def descr__repr__(self, space):
bufsize = support.emjs_length(self.handle)
_check_error(space, bufsize)
truncated = False
if bufsize > 17:
bufsize = 17
truncated = True
with rffi.scoped_alloc_buffer(bufsize) as buf:
n = support.emjs_read_strn(self.handle, buf.raw, buf.size)
strval = buf.str(n)
if truncated:
strval = strval + "..."
return space.wrap("<js.String '%s'>" % (strval, ))
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 descr__repr__(self, space):
bufsize = support.emjs_length(self.handle)
_check_error(space, bufsize)
truncated = False
if bufsize > 17:
bufsize = 17
truncated = True
with rffi.scoped_alloc_buffer(bufsize) as buf:
n = support.emjs_read_strn(self.handle, buf.raw, buf.size)
strval = buf.str(n)
if truncated:
strval = strval + "..."
return space.wrap("<js.String '%s'>" % (strval,))
def read(self, space, num_bytes=1024):
"""read([len]) -> string
Read up to len bytes from the SSL socket."""
count = libssl_SSL_pending(self.ssl)
if not count:
sockstate = checkwait(space, self.w_socket, False)
if sockstate == SOCKET_HAS_TIMED_OUT:
raise ssl_error(space, "The read operation timed out")
elif sockstate == SOCKET_TOO_LARGE_FOR_SELECT:
raise ssl_error(space,
"Underlying socket too large for select().")
elif sockstate == SOCKET_HAS_BEEN_CLOSED:
if libssl_SSL_get_shutdown(self.ssl) == SSL_RECEIVED_SHUTDOWN:
return space.wrap('')
raise ssl_error(
space, "Socket closed without SSL shutdown handshake")
with rffi.scoped_alloc_buffer(num_bytes) as buf:
while True:
err = 0
count = libssl_SSL_read(self.ssl, buf.raw, num_bytes)
err = libssl_SSL_get_error(self.ssl, count)
if err == SSL_ERROR_WANT_READ:
sockstate = checkwait(space, self.w_socket, False)
elif err == SSL_ERROR_WANT_WRITE:
sockstate = checkwait(space, self.w_socket, True)
elif (err == SSL_ERROR_ZERO_RETURN and libssl_SSL_get_shutdown(
self.ssl) == SSL_RECEIVED_SHUTDOWN):
return space.wrap("")
else:
sockstate = SOCKET_OPERATION_OK
if sockstate == SOCKET_HAS_TIMED_OUT:
raise ssl_error(space, "The read operation timed out")
elif sockstate == SOCKET_IS_NONBLOCKING:
break
if err == SSL_ERROR_WANT_READ or err == SSL_ERROR_WANT_WRITE:
continue
else:
break
if count <= 0:
raise _ssl_seterror(space, self, count)
result = buf.str(count)
return space.wrap(result)
def read(self, space, num_bytes=1024):
"""read([len]) -> string
Read up to len bytes from the SSL socket."""
count = libssl_SSL_pending(self.ssl)
if not count:
sockstate = checkwait(space, self.w_socket, False)
if sockstate == SOCKET_HAS_TIMED_OUT:
raise ssl_error(space, "The read operation timed out")
elif sockstate == SOCKET_TOO_LARGE_FOR_SELECT:
raise ssl_error(space,
"Underlying socket too large for select().")
elif sockstate == SOCKET_HAS_BEEN_CLOSED:
if libssl_SSL_get_shutdown(self.ssl) == SSL_RECEIVED_SHUTDOWN:
return space.wrap('')
raise ssl_error(space,
"Socket closed without SSL shutdown handshake")
with rffi.scoped_alloc_buffer(num_bytes) as buf:
while True:
err = 0
count = libssl_SSL_read(self.ssl, buf.raw, num_bytes)
err = libssl_SSL_get_error(self.ssl, count)
if err == SSL_ERROR_WANT_READ:
sockstate = checkwait(space, self.w_socket, False)
elif err == SSL_ERROR_WANT_WRITE:
sockstate = checkwait(space, self.w_socket, True)
elif (err == SSL_ERROR_ZERO_RETURN and
libssl_SSL_get_shutdown(self.ssl) == SSL_RECEIVED_SHUTDOWN):
return space.wrap("")
else:
sockstate = SOCKET_OPERATION_OK
if sockstate == SOCKET_HAS_TIMED_OUT:
raise ssl_error(space, "The read operation timed out")
elif sockstate == SOCKET_IS_NONBLOCKING:
break
if err == SSL_ERROR_WANT_READ or err == SSL_ERROR_WANT_WRITE:
continue
else:
break
if count <= 0:
raise _ssl_seterror(space, self, count)
result = buf.str(count)
return space.wrap(result)
def _digest(self, space):
ctx = ropenssl.EVP_MD_CTX_new()
if ctx is None:
raise MemoryError
try:
with self.lock:
if not ropenssl.EVP_MD_CTX_copy(ctx, self.ctx):
raise ValueError
digest_size = self.digest_size
with rffi.scoped_alloc_buffer(digest_size) as buf:
ropenssl.EVP_DigestFinal(ctx, buf.raw, None)
return buf.str(digest_size)
finally:
ropenssl.EVP_MD_CTX_free(ctx)
def _digest(self, space):
ctx = ropenssl.EVP_MD_CTX_new()
if ctx is None:
raise MemoryError
try:
with self.lock:
if not ropenssl.EVP_MD_CTX_copy(ctx, self.ctx):
raise ValueError
digest_size = self.digest_size
with rffi.scoped_alloc_buffer(digest_size) as buf:
ropenssl.EVP_DigestFinal(ctx, buf.raw, None)
return buf.str(digest_size)
finally:
ropenssl.EVP_MD_CTX_free(ctx)
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 utf8_encode_mbcs(s, errors, errorhandler, force_replace=True):
# TODO: do the encoding without decoding utf8 -> unicode
uni = s.decode('utf8')
lgt = len(uni)
if not force_replace and errors not in ('strict', 'replace'):
msg = "mbcs encoding does not support errors='%s'" % errors
errorhandler('strict', 'mbcs', msg, s, 0, 0)
if lgt == 0:
return ''
if force_replace or errors == 'replace':
flags = 0
used_default_p = lltype.nullptr(BOOLP.TO)
else:
# strict
flags = rwin32.WC_NO_BEST_FIT_CHARS
used_default_p = lltype.malloc(BOOLP.TO, 1, flavor='raw')
used_default_p[0] = rffi.cast(rwin32.BOOL, False)
try:
with rffi.scoped_nonmoving_unicodebuffer(uni) as dataptr:
# first get the size of the result
mbcssize = WideCharToMultiByte(CP_ACP, flags, dataptr, lgt,
None, 0, None, used_default_p)
if mbcssize == 0:
raise rwin32.lastSavedWindowsError()
# If we used a default char, then we failed!
if (used_default_p
and rffi.cast(lltype.Bool, used_default_p[0])):
errorhandler('strict', 'mbcs', "invalid character", s, 0,
0)
with rffi.scoped_alloc_buffer(mbcssize) as buf:
# do the conversion
if WideCharToMultiByte(CP_ACP, flags, dataptr, lgt,
buf.raw, mbcssize, None,
used_default_p) == 0:
raise rwin32.lastSavedWindowsError()
if (used_default_p
and rffi.cast(lltype.Bool, used_default_p[0])):
errorhandler('strict', 'mbcs', "invalid character", s,
0, 0)
result = buf.str(mbcssize)
assert result is not None
return result
finally:
if used_default_p:
lltype.free(used_default_p, flavor='raw')
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 recv(self, buffersize, flags=0):
"""Receive up to buffersize bytes from the socket. For the optional
flags argument, see the Unix manual. When no data is available, block
until at least one byte is available or until the remote end is closed.
When the remote end is closed and all data is read, return the empty
string."""
timeout = self._select(False)
if timeout == 1:
raise SocketTimeout
elif timeout == 0:
with rffi.scoped_alloc_buffer(buffersize) as buf:
read_bytes = _c.socketrecv(self.fd, rffi.cast(rffi.VOIDP, buf.raw), buffersize, flags)
if read_bytes >= 0:
return buf.str(read_bytes)
raise self.error_handler()
def recv(self, buffersize, flags=0):
"""Receive up to buffersize bytes from the socket. For the optional
flags argument, see the Unix manual. When no data is available, block
until at least one byte is available or until the remote end is closed.
When the remote end is closed and all data is read, return the empty
string."""
timeout = self._select(False)
if timeout == 1:
raise SocketTimeout
elif timeout == 0:
with rffi.scoped_alloc_buffer(buffersize) as buf:
read_bytes = _c.socketrecv(self.fd,
rffi.cast(rffi.VOIDP, buf.raw),
buffersize, flags)
if read_bytes >= 0:
return buf.str(read_bytes)
raise self.error_handler()
def pbkdf2_hmac(space, name, password, salt, rounds, w_dklen):
digest = ropenssl.EVP_get_digestbyname(name)
if not digest:
raise oefmt(space.w_ValueError, "unknown hash function")
if space.is_w(w_dklen, space.w_None):
dklen = ropenssl.EVP_MD_size(digest)
else:
dklen = space.int_w(w_dklen)
if dklen < 1:
raise oefmt(space.w_ValueError,
"key length must be greater than 0.")
with rffi.scoped_alloc_buffer(dklen) as buf:
r = ropenssl.PKCS5_PBKDF2_HMAC(password, len(password), salt,
len(salt), rounds, digest, dklen,
buf.raw)
if not r:
raise ValueError
return space.newbytes(buf.str(dklen))
def pbkdf2_hmac(space, name, password, salt, rounds, w_dklen):
digest = ropenssl.EVP_get_digestbyname(name)
if not digest:
raise oefmt(space.w_ValueError, "unknown hash function")
if space.is_w(w_dklen, space.w_None):
dklen = ropenssl.EVP_MD_size(digest)
else:
dklen = space.int_w(w_dklen)
if dklen < 1:
raise oefmt(space.w_ValueError,
"key length must be greater than 0.")
with rffi.scoped_alloc_buffer(dklen) as buf:
r = ropenssl.PKCS5_PBKDF2_HMAC(
password, len(password), salt, len(salt), rounds, digest,
dklen, buf.raw)
if not r:
raise ValueError
return space.wrap(buf.str(dklen))
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)
with rffi.scoped_alloc_buffer(BUF_SIZE) as buf:
while True:
try:
count = fread(buf.raw, 1, BUF_SIZE, fp)
except OSError:
PyErr_SetFromErrno(space, space.w_IOError)
return
count = rffi.cast(lltype.Signed, count)
source += rffi.charpsize2str(buf.raw, count)
if count < BUF_SIZE:
if feof(fp):
break
PyErr_SetFromErrno(space, space.w_IOError)
return run_string(space, source, filename, start, w_globals, w_locals)
def _unibuf_to_utf8(dataptr, insize):
"""Encode the widechar unicode buffer u to utf8
Should never error, since the buffer comes from a call to
MultiByteToWideChar
"""
flags = 0
cp = rwin32.CP_UTF8
used_default_p = lltype.nullptr(BOOLP.TO)
# first get the size of the result
outsize = WideCharToMultiByte(cp, flags, dataptr, insize, None, 0, None,
used_default_p)
if outsize == 0:
raise rwin32.lastSavedWindowsError()
with rffi.scoped_alloc_buffer(outsize) as buf:
# do the conversion
if WideCharToMultiByte(cp, flags, dataptr, insize, buf.raw, outsize,
None, used_default_p) == 0:
raise rwin32.lastSavedWindowsError()
result = buf.str(outsize)
assert result is not None
return result
def primitiveDecrypt(interp, s_frame, w_rcvr, w_handle, src, start, srclen, w_dst):
_debug_in_interpreter()
if (not isinstance(w_handle, W_SSLHandle) or
w_handle.state != SSL_CONNECTED):
return interp.space.wrap_int(SSL_INVALID_STATE)
assert start >= 0 and srclen >= 0
nbytes = ropenssl.libssl_BIO_write(w_handle.readbio, src[start:start+srclen], srclen)
if nbytes != srclen:
return interp.space.wrap_int(SSL_GENERIC_ERROR)
dstlen = w_dst.size()
with rffi.scoped_alloc_buffer(dstlen) as buf:
nbytes = ropenssl.libssl_SSL_read(w_handle.ssl, buf.raw, dstlen)
if nbytes <= 0:
err = ropenssl.libssl_SSL_get_error(w_handle.ssl, nbytes)
if (err != ropenssl.SSL_ERROR_WANT_READ and
err != ropenssl.SSL_ERROR_ZERO_RETURN):
return interp.space.wrap_int(SSL_GENERIC_ERROR)
else:
nbytes = 0
for idx in range(nbytes):
w_dst.setchar(idx, buf.raw[idx])
return interp.space.wrap_int(nbytes)
def _getrandom(n, result, signal_checker):
if not getrandom_works.status:
return n
while n > 0:
with rffi.scoped_alloc_buffer(n) as buf:
got = syscall(SYS_getrandom, buf.raw, n, GRND_NONBLOCK)
if got >= 0:
s = buf.str(got)
result.append(s)
n -= len(s)
continue
err = get_saved_errno()
if (err == errno.ENOSYS or err == errno.EPERM or
err == errno.EAGAIN): # see CPython 3.5
getrandom_works.status = False
return n
if err == errno.EINTR:
if signal_checker is not None:
signal_checker()
continue
handle_posix_error("getrandom", got)
raise AssertionError("unreachable")
return n
def primitiveDecrypt(interp, s_frame, w_rcvr, w_handle, src, start, srclen,
w_dst):
_debug_in_interpreter()
if (not isinstance(w_handle, W_SSLHandle)
or w_handle.state != SSL_CONNECTED):
return interp.space.wrap_int(SSL_INVALID_STATE)
assert start >= 0 and srclen >= 0
nbytes = ropenssl.libssl_BIO_write(w_handle.readbio,
src[start:start + srclen], srclen)
if nbytes != srclen:
return interp.space.wrap_int(SSL_GENERIC_ERROR)
dstlen = w_dst.size()
with rffi.scoped_alloc_buffer(dstlen) as buf:
nbytes = ropenssl.libssl_SSL_read(w_handle.ssl, buf.raw, dstlen)
if nbytes <= 0:
err = ropenssl.libssl_SSL_get_error(w_handle.ssl, nbytes)
if (err != ropenssl.SSL_ERROR_WANT_READ
and err != ropenssl.SSL_ERROR_ZERO_RETURN):
return interp.space.wrap_int(SSL_GENERIC_ERROR)
else:
nbytes = 0
for idx in range(nbytes):
w_dst.setchar(idx, buf.raw[idx])
return interp.space.wrap_int(nbytes)
def urandom(context, n):
with rffi.scoped_alloc_buffer(n) as buf:
if libssl_RAND_pseudo_bytes(self.raw, n) < 0:
raise ValueError("RAND_pseudo_bytes")
return buf.str(n)
def readline(self, size=-1):
self._check_closed()
if size == 0:
return ""
elif size < 0 and not self._univ_newline:
with rffi.scoped_alloc_buffer(BASE_LINE_SIZE) as buf:
c = self._readline1(buf.raw)
if c >= 0:
return buf.str(c)
# this is the rare case: the line is longer than BASE_LINE_SIZE
s = StringBuilder()
while True:
s.append_charpsize(buf.raw, BASE_LINE_SIZE - 1)
c = self._readline1(buf.raw)
if c >= 0:
break
s.append_charpsize(buf.raw, c)
return s.build()
else: # size > 0 or self._univ_newline
ll_file = self._ll_file
c = 0
s = StringBuilder()
if self._univ_newline:
newlinetypes = self._newlinetypes
skipnextlf = self._skipnextlf
while size < 0 or s.getlength() < size:
c = c_getc(ll_file)
if c == EOF:
break
if skipnextlf:
skipnextlf = False
if c == ord('\n'):
newlinetypes |= NEWLINE_CRLF
c = c_getc(ll_file)
if c == EOF:
break
else:
newlinetypes |= NEWLINE_CR
if c == ord('\r'):
skipnextlf = True
c = ord('\n')
elif c == ord('\n'):
newlinetypes |= NEWLINE_LF
s.append(chr(c))
if c == ord('\n'):
break
if c == EOF:
if skipnextlf:
newlinetypes |= NEWLINE_CR
self._newlinetypes = newlinetypes
self._skipnextlf = skipnextlf
else:
while s.getlength() < size:
c = c_getc(ll_file)
if c == EOF:
break
s.append(chr(c))
if c == ord('\n'):
break
if c == EOF:
if c_ferror(ll_file):
raise _error(ll_file)
return s.build()
def urandom(context, n):
with rffi.scoped_alloc_buffer(n) as buf:
if libssl_RAND_pseudo_bytes(self.raw, n) < 0:
raise ValueError("RAND_pseudo_bytes")
return buf.str(n)
def IP6Name(sockaddr):
size = 46
with rffi.scoped_alloc_buffer(size) as buf:
check("ip6_name", ip6_name(sockaddr, buf.raw, size))
return buf.str(size).split('\x00', 1)[0]
def _init_timezone(space):
timezone = daylight = altzone = 0
tzname = ["", ""]
if _WIN:
c_tzset()
timezone = c_get_timezone()
altzone = timezone - 3600
daylight = c_get_daylight()
with rffi.scoped_alloc_buffer(100) as buf:
s = c_get_tzname(100, 0, buf.raw)
tzname[0] = buf.str(s)
s = c_get_tzname(100, 1, buf.raw)
tzname[1] = buf.str(s)
if _POSIX:
if _CYGWIN:
YEAR = (365 * 24 + 6) * 3600
# about January 11th
t = (((c_time(lltype.nullptr(rffi.TIME_TP.TO))) / YEAR) * YEAR +
10 * 24 * 3600)
# we cannot have reference to stack variable, put it on the heap
t_ref = lltype.malloc(rffi.TIME_TP.TO, 1, flavor='raw')
t_ref[0] = rffi.cast(rffi.TIME_T, t)
p = c_localtime(t_ref)
q = c_gmtime(t_ref)
janzone = (p.c_tm_hour + 24 * p.c_tm_mday) - (q.c_tm_hour +
24 * q.c_tm_mday)
if janzone < -12:
janname = " "
elif janzone > 14:
janname = " "
else:
janname = _time_zones[janzone - 12]
janzone = janzone * 3600
# about July 11th
tt = t + YEAR / 2
t_ref[0] = rffi.cast(rffi.TIME_T, tt)
p = c_localtime(t_ref)
q = c_gmtime(t_ref)
julyzone = (p.c_tm_hour + 24 * p.c_tm_mday) - (q.c_tm_hour +
24 * q.c_tm_mday)
if julyzone < -12:
julyname = " "
elif julyzone > 14:
julyname = " "
else:
julyname = _time_zones[julyzone - 12]
julyzone = julyzone * 3600
lltype.free(t_ref, flavor='raw')
if janzone < julyzone:
# DST is reversed in the southern hemisphere
timezone = julyzone
altzone = janzone
daylight = int(janzone != julyzone)
tzname = [julyname, janname]
else:
timezone = janzone
altzone = julyzone
daylight = int(janzone != julyzone)
tzname = [janname, julyname]
else:
YEAR = (365 * 24 + 6) * 3600
t = (((c_time(lltype.nullptr(rffi.TIME_TP.TO))) / YEAR) * YEAR)
# we cannot have reference to stack variable, put it on the heap
t_ref = lltype.malloc(rffi.TIME_TP.TO, 1, flavor='raw')
t_ref[0] = rffi.cast(rffi.TIME_T, t)
p = c_localtime(t_ref)
janzone = -p.c_tm_gmtoff
tm_zone = rffi.charp2str(p.c_tm_zone)
janname = [" ", tm_zone][bool(tm_zone)]
tt = t + YEAR / 2
t_ref[0] = rffi.cast(rffi.TIME_T, tt)
p = c_localtime(t_ref)
lltype.free(t_ref, flavor='raw')
tm_zone = rffi.charp2str(p.c_tm_zone)
julyzone = -p.c_tm_gmtoff
julyname = [" ", tm_zone][bool(tm_zone)]
if janzone < julyzone:
# DST is reversed in the southern hemisphere
timezone = julyzone
altzone = janzone
daylight = int(janzone != julyzone)
tzname = [julyname, janname]
else:
timezone = janzone
altzone = julyzone
daylight = int(janzone != julyzone)
tzname = [janname, julyname]
_set_module_object(space, "timezone", space.newint(timezone))
_set_module_object(space, 'daylight', space.newint(daylight))
tzname_w = [space.newtext(tzname[0]), space.newtext(tzname[1])]
_set_module_object(space, 'tzname', space.newtuple(tzname_w))
_set_module_object(space, 'altzone', space.newint(altzone))
def f():
with rffi.scoped_alloc_buffer(42) as p:
p.raw[0] = 'X'
s = p.str(1)
return ord(s[0])
def primitiveConnect(interp, s_frame, w_rcvr, w_handle, src, start, srclen, w_dst):
_debug_in_interpreter()
if (not isinstance(w_handle, W_SSLHandle) or
w_handle.state != SSL_UNUSED and
w_handle.state != SSL_CONNECTING):
return interp.space.wrap_int(SSL_INVALID_STATE)
w_handle.log("primitiveConnect: handle %s", w_handle.hash)
if w_handle.state == SSL_UNUSED:
w_handle.state = SSL_CONNECTING
w_handle.log("primitiveConnect: Setting up SSL")
if not w_handle.setup():
return interp.space.wrap_int(SSL_GENERIC_ERROR)
w_handle.log("primitiveConnect: Setting connect state")
ropenssl.libssl_SSL_set_connect_state(w_handle.ssl)
assert start >= 0 and srclen >= 0
w_handle.log("primitiveConnect: BIO_write %s bytes", srclen)
n = ropenssl.libssl_BIO_write(w_handle.readbio, src[start:start+srclen], srclen)
if n < srclen:
w_handle.log("primitiveConnect: BIO too small for input")
return interp.space.wrap_int(SSL_GENERIC_ERROR)
if n < 0:
w_handle.log("primitiveConnect: BIO_write failed", srclen)
return interp.space.wrap_int(SSL_GENERIC_ERROR)
if w_handle.servername:
w_handle.log("primitiveConnect: Using server name %s", w_handle.servername)
ropenssl.libssl_SSL_set_tlsext_host_name(w_handle.ssl, w_handle.servername)
w_handle.log("primitiveConnect: SSL_connect")
result = ropenssl.libssl_SSL_connect(w_handle.ssl)
if result <= 0:
err = ropenssl.libssl_SSL_get_error(w_handle.ssl, result)
if err != ropenssl.SSL_ERROR_WANT_READ:
w_handle.log("primitiveConnect: SSL_connect failed with %s", err)
ropenssl.libssl_pypy_ERR_print_errors_stdout()
return interp.space.wrap_int(-1)
w_handle.log("primitiveConnect: copy_bio_ssl")
c = copy_bio_ssl(w_handle.writebio, w_dst, w_dst.bytesize(),
w_handle.loglevel)
return interp.space.wrap_int(c)
# We are connected. Verify the cert.
w_handle.state = SSL_CONNECTED
w_handle.log("primitiveConnect: SSL_get_peer_certificate")
cert = ropenssl.libssl_SSL_get_peer_certificate(w_handle.ssl)
w_handle.log("primitiveConnect: cert = %s", cert)
if cert:
x509_name = ropenssl.libssl_X509_get_subject_name(cert)
with rffi.scoped_alloc_buffer(256) as buf:
ropenssl.libssl_X509_NAME_get_text_by_NID(
x509_name, NID_commonName, buf.raw, 256)
w_handle.peername = rffi.charp2str(buf.raw)
w_handle.log("primitiveConnect: peerName = %s", w_handle.peername)
ropenssl.libssl_X509_free(cert)
# Check the result of verification
result = ropenssl.libssl_SSL_get_verify_result(w_handle.ssl)
w_handle.log("primitiveConnect: SSL_get_verify_result = %s (%s)", (result, result == X509_V_OK))
if result == X509_V_OK:
w_handle.certflags = SSL_OK
else:
w_handle.certflags = SSL_OTHER_ISSUE
else:
w_handle.certflags = SSL_NO_CERTIFICATE
return interp.space.wrap_int(0)
def IP6Name(sockaddr):
size = 46
with rffi.scoped_alloc_buffer(size) as buf:
check("ip6_name", ip6_name(sockaddr, buf.raw, size))
return buf.str(size).split('\x00', 1)[0]
def IP4Name(sockaddr):
size = 16
with rffi.scoped_alloc_buffer(size) as buf:
check("ip4_name", ip4_name(sockaddr, buf.raw, size))
return buf.str(size).split("\x00", 1)[0]
def multiprocessing_recv(space, handle, buffersize):
with rffi.scoped_alloc_buffer(buffersize) as buf:
read_bytes = socketrecv(handle, buf.raw, buffersize, 0)
if read_bytes >= 0:
return space.newtext(buf.str(read_bytes))
raise getWindowsError(space)
