def Timer_start(self, delay, repeat):
if repeat is None:
rep = 0
else:
rep = int(repeat.number * 1000)
check(uv.timer_start(self.timer, _on_tick_, int(delay.number * 1000), 0))
return null
def ip6_name(addr):
res_length = uv.INET6_ADDRSTRLEN
res = lltype.malloc(rffi.CCHARP.TO, res_length, flavor="raw")
sockaddr = as_sockaddr(addr)
try:
check(uv.ip6_name(sockaddr, res, res_length))
return from_cstring(rffi.charp2str(res))
finally:
lltype.free(res, flavor='raw')
def Stream_try_write(self, data):
self.check_closed()
bufs, nbufs = uv_callback.obj2bufs(data)
try:
status = uv.try_write(self.stream, bufs, nbufs)
check(status)
return Integer(rffi.r_long(status))
finally:
lltype.free(bufs, flavor='raw')
def TCP_getpeername(self):
self.check_closed()
array = alloc_uint8array(rffi.sizeof(uv.sockaddr_storage))
namelen = lltype.malloc(rffi.INTP.TO, 1, flavor="raw", zero=True)
try:
check(uv.tcp_getpeername(self.tcp, as_sockaddr(array), namelen))
finally:
lltype.free(namelen, flavor='raw')
return array
def Stream_shutdown(self):
self.check_closed()
req = lltype.malloc(uv.shutdown_ptr.TO, flavor='raw', zero=True)
try:
response = uv_callback.shutdown(req)
check(
response.wait(
uv.shutdown(req, self.stream, uv_callback.shutdown.cb))[0])
return null
finally:
lltype.free(req, flavor='raw')
def inet_pton(af, src):
af = af.value
if af == uv.AF_INET:
res = alloc_uint8array(4)
elif af == uv.AF_INET6:
res = alloc_uint8array(16)
else:
raise unwind(
LError(u"first argument must be either AF_INET or AF_INET6"))
check(uv.inet_ntop(af, src.string.encode('utf-8'), res.uint8data))
return res
def Pipe_connect(self, name):
self.check_closed()
string = name.string.encode('utf-8')
req = lltype.malloc(uv.connect_ptr.TO, flavor='raw', zero=True)
try:
response = uv_callback.connect(req)
uv.pipe_connect(req, self.pipe, string, uv_callback.connect.cb)
check(response.wait()[0])
return null
finally:
lltype.free(req, flavor='raw')
def Stream_accept(self):
self.check_closed()
if self.listen_count > 0:
if self.accept_greenlet is not None:
raise unwind(LError(u"async collision"))
ec = core.get_ec()
self.accept_greenlet = ec.current
core.switch([ec.eventloop])
check(self.listen_status)
self.listen_count -= 1
client = self.new_stream()
check(uv.accept(self.stream, client.stream))
return client
def TTY_set_mode(self, modename_obj):
self.check_closed()
modename = string_upper(modename_obj.string)
if modename == u"NORMAL":
mode = uv.TTY_MODE_NORMAL
elif modename == u"RAW":
mode = uv.TTY_MODE_RAW
elif modename == u"IO":
mode = uv.TTY_MODE_IO
else:
raise unwind(LError(u"unknown mode: " + modename_obj.repr()))
check(uv.tty_set_mode(self.tty, mode))
return null
def UDP_try_send(self, data, addr):
self.check_closed()
bufs, nbufs = uv_callback.obj2bufs(data)
req = lltype.malloc(uv.udp_send_ptr.TO, flavor='raw', zero=True)
sockaddr = as_sockaddr(addr)
try:
check(
uv.udp_try_send(req, self.udp, bufs, nbufs, sockaddr,
uv_callback.udp_send.cb))
return null
finally:
lltype.free(bufs, flavor='raw')
lltype.free(req, flavor='raw')
def TCP_connect(self, addr):
self.check_closed()
req = lltype.malloc(uv.connect_ptr.TO, flavor='raw', zero=True)
sockaddr = as_sockaddr(addr)
try:
response = uv_callback.connect(req)
check(
response.wait(
uv.tcp_connect(req, self.tcp, sockaddr,
uv_callback.connect.cb))[0])
return null
finally:
lltype.free(req, flavor='raw')
def Stream_write(self, data):
self.check_closed()
bufs, nbufs = uv_callback.obj2bufs(data)
req = lltype.malloc(uv.write_ptr.TO, flavor='raw', zero=True)
try:
response = uv_callback.write(req)
check(
response.wait(
uv.write(req, self.stream, bufs, nbufs,
uv_callback.write.cb))[0])
return null
finally:
lltype.free(bufs, flavor='raw')
lltype.free(req, flavor='raw')
def Pipe_accept(self):
tp = uv.pipe_pending_type(self.pipe)
if tp == uv.NAMED_PIPE or tp == uv.UNKNOWN_HANDLE or tp == uv.FILE:
client = alloc_pipe(
1
) # The libuv reports an external_memory file handle as UNKNOWN_HANDLE
elif tp == uv.TCP: # I guess it might be safe to alloc a pipe when that happens.
client = stdlib.net.tcp_alloc()
elif tp == uv.UDP:
client = stdlib.net.udp_alloc()
else:
raise OldError(u"got fd of type=" + str(tp).decode('utf-8'))
check(uv.accept(self.stream, client.stream))
return client
def TTY_get_winsize(self):
self.check_closed()
width = lltype.malloc(rffi.INTP.TO, 1, flavor='raw', zero=True)
height = lltype.malloc(rffi.INTP.TO, 1, flavor='raw', zero=True)
try:
check(uv.tty_get_winsize(self.tty, width, height))
w = rffi.r_long(width[0])
h = rffi.r_long(height[0])
obj = Exnihilo()
obj.setattr(u"width", Integer(w))
obj.setattr(u"height", Integer(h))
return obj
finally:
lltype.free(width, flavor='raw')
lltype.free(height, flavor='raw')
def inet_ntop(af, src):
af = af.value
if af == uv.AF_INET:
L = 4
elif af == uv.AF_INET6:
L = 16
else:
raise unwind(
LError(u"first argument must be either AF_INET or AF_INET6"))
if src.length < L:
raise unwind(LError(u"argument too short to be an address"))
res_length = uv.INET6_ADDRSTRLEN
res = lltype.malloc(rffi.CCHARP.TO, res_length, flavor="raw")
try:
check(uv.inet_ntop(af, src.uint8data, res, res_length))
return from_cstring(rffi.charp2str(res))
finally:
lltype.free(res, flavor='raw')
def TCP_bind(self, addr, flags):
self.check_closed()
flags = 0 if flags is None else flags.value
sockaddr = as_sockaddr(addr)
check(uv.tcp_bind(self.tcp, sockaddr, flags))
return null
def TCP_nodelay(self, enable):
self.check_closed()
check(uv.tcp_simultaneous_accepts(self.tcp, 1 if is_true(enable) else 0))
return null
def TCP_nodelay(self, enable, delay):
self.check_closed()
check(
uv.tcp_keepalive(self.tcp, 1 if is_true(enable) else 0,
0 if delay is None else delay.value))
return null
def Timer_stop(self):
check(uv.timer_stop(self.timer))
return null
def Spawn_kill(self, signum):
check(uv.process_kill(self.process, signum.value))
return null
def Pipe_bind(self, name):
self.check_closed()
string = name.string.encode('utf-8')
check(uv.pipe_bind(self.pipe, string))
return null
def ip6_addr(address, port):
res = alloc_uint8array(rffi.sizeof(uv.sockaddr_storage))
check(
uv.ip6_addr(address.string.encode('utf-8'), port.value, res.uint8data))
return res
def kill_(pid, signum):
check(uv.kill(pid.value, signum.value))
return null
def UDP_set_ttl(self, ttl):
self.check_closed()
check(uv.udp_set_ttl(self.udp, ttl.value))
return null
def UDP_set_broadcast(self, on):
self.check_closed()
check(uv.udp_set_broadcast(self.udp, 1 if is_true(on) else 0))
return null
def UDP_set_multicast_loop(self, enable):
self.check_closed()
check(uv.udp_set_multicast_loop(self.udp, 1 if is_true(enable) else 0))
return null
def Stream_stop(self):
check(uv.read_stop(self.stream))
return null
def Timer_again(self):
check(uv.timer_again(self.timer))
return null
def TCP_nodelay(self, enable):
self.check_closed()
check(uv.tcp_nodelay(self.tcp, 1 if is_true(enable) else 0))
return null
def Pipe_pending_count(self):
self.check_closed()
result = uv.pipe_pending_count(self.pipe)
check(result)
return Integer(rffi.r_long(result))
