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)