gfwleak/zhangyang-libzt
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Run Python language bindings and example code through a linter and formatter

Browse Source
This commit is contained in:
Joseph Henry
2021-03-07 21:11:21 -08:00
parent e1d0f92d61
commit dd6cf48d61
2 changed files with 526 additions and 467 deletions
Download Patch File Download Diff File Expand all files Collapse all files

214
examples/python/example.py
View File

@@ -1,67 +1,26 @@
import time, sys '''Example low-level socket usage'''
import time
import sys
import libzt import libzt
# Where identity files are stored
keyPath = "."
# Network to join
networkId = 0
# Port used by ZeroTier to send encpryted UDP traffic
# NOTE: Should be different from other instances of ZeroTier
# running on the same machine
ztServicePort = 9997
remoteIP = None
# A port your app logic may use
serverPort = 8080
# Flags to keep state
is_joined = False
is_online = False
mode = None
def print_usage(): def print_usage():
print("\nUsage: <server|client> <id_path> <nwid> <ztServicePort> <remoteIP> <serverPort>\n") '''print help'''
print(" Ex: python3 example.py server . 0123456789abcdef 9994 8080") print(
print(" Ex: python3 example.py client . 0123456789abcdef 9994 192.168.22.1 8080\n") "\nUsage: <server|client> <id_path> <nwid> <zt_service_port> <remote_ip> <remote_port>\n"
if (len(sys.argv) < 6): )
print('Too few arguments') print("Ex: python3 demo.py server . 0123456789abcdef 9994 8080")
if (len(sys.argv) > 7): print("Ex: python3 demo.py client . 0123456789abcdef 9994 192.168.22.1 8080\n")
print('Too many arguments') if len(sys.argv) < 6:
exit(0) print("Too few arguments")
# if len(sys.argv) > 7:
if (len(sys.argv) < 6 or len(sys.argv) > 7): print("Too many arguments")
print_usage() sys.exit(0)
if (sys.argv[1] == 'server' and len(sys.argv) == 6):
mode = sys.argv[1]
keyPath = sys.argv[2]
networkId = int(sys.argv[3],16)
ztServicePort = int(sys.argv[4])
serverPort = int(sys.argv[5])
if (sys.argv[1] == 'client' and len(sys.argv) == 7):
mode = sys.argv[1]
keyPath = sys.argv[2]
networkId = int(sys.argv[3],16)
ztServicePort = int(sys.argv[4])
remoteIP = sys.argv[5]
serverPort = int(sys.argv[6])
if (mode is None):
print_usage()
print('mode = ', mode)
print('path = ', keyPath)
print('networkId = ', networkId)
print('ztServicePort = ', ztServicePort)
print('remoteIP = ', remoteIP)
print('serverPort = ', serverPort)
is_joined = False # Flags to keep state
is_online = False # Flags to keep state
# #
# Event handler # Event handler
@@ -71,89 +30,128 @@ class MyEventCallbackClass(libzt.EventCallbackClass):
global is_online global is_online
global is_joined global is_joined
print("eventCode=", msg.eventCode) print("eventCode=", msg.eventCode)
if (msg.eventCode == libzt.ZTS_EVENT_NODE_ONLINE): if msg.eventCode == libzt.ZTS_EVENT_NODE_ONLINE:
print("ZTS_EVENT_NODE_ONLINE") print("ZTS_EVENT_NODE_ONLINE")
print("nodeId="+hex(msg.node.address)) print("nodeId=" + hex(msg.node.address))
# The node is now online, you can join/leave networks # The node is now online, you can join/leave networks
is_online = True is_online = True
if (msg.eventCode == libzt.ZTS_EVENT_NODE_OFFLINE): if msg.eventCode == libzt.ZTS_EVENT_NODE_OFFLINE:
print("ZTS_EVENT_NODE_OFFLINE") print("ZTS_EVENT_NODE_OFFLINE")
if (msg.eventCode == libzt.ZTS_EVENT_NETWORK_READY_IP4): if msg.eventCode == libzt.ZTS_EVENT_NETWORK_READY_IP4:
print("ZTS_EVENT_NETWORK_READY_IP4") print("ZTS_EVENT_NETWORK_READY_IP4")
is_joined = True is_joined = True
# The node has successfully joined a network and has an address # The node has successfully joined a network and has an address
# you can perform network calls now # you can perform network calls now
if (msg.eventCode == libzt.ZTS_EVENT_PEER_DIRECT): if msg.eventCode == libzt.ZTS_EVENT_PEER_DIRECT:
print("ZTS_EVENT_PEER_DIRECT") print("ZTS_EVENT_PEER_DIRECT")
if (msg.eventCode == libzt.ZTS_EVENT_PEER_RELAY): if msg.eventCode == libzt.ZTS_EVENT_PEER_RELAY:
print("ZTS_EVENT_PEER_RELAY") print("ZTS_EVENT_PEER_RELAY")
# #
# Example start and join logic # Main
# #
print("Starting ZeroTier..."); def main():
eventCallback = MyEventCallbackClass() global is_online
libzt.start(keyPath, eventCallback, ztServicePort) global is_joined
print("Waiting for node to come online...")
while (not is_online): key_file_path = "." # Where identity files are stored
network_id = 0 # Network to join
# Port used by ZeroTier to send encpryted UDP traffic
# NOTE: Should be different from other instances of ZeroTier
# running on the same machine
zt_service_port = 9997
remote_ip = None # ZeroTier IP of remote node
remote_port = 8080 # ZeroTier port your app logic may use
mode = None # client|server
if len(sys.argv) < 6 or len(sys.argv) > 7:
print_usage()
if sys.argv[1] == "server" and len(sys.argv) == 6:
mode = sys.argv[1]
key_file_path = sys.argv[2]
network_id = int(sys.argv[3], 16)
zt_service_port = int(sys.argv[4])
remote_port = int(sys.argv[5])
if sys.argv[1] == "client" and len(sys.argv) == 7:
mode = sys.argv[1]
key_file_path = sys.argv[2]
network_id = int(sys.argv[3], 16)
zt_service_port = int(sys.argv[4])
remote_ip = sys.argv[5]
remote_port = int(sys.argv[6])
if mode is None:
print_usage()
print("mode = ", mode)
print("path = ", key_file_path)
print("network_id = ", network_id)
print("zt_service_port = ", zt_service_port)
print("remote_ip = ", remote_ip)
print("remote_port = ", remote_port)
#
# Example start and join logic
#
print("Starting ZeroTier...")
event_callback = MyEventCallbackClass()
libzt.start(key_file_path, event_callback, zt_service_port)
print("Waiting for node to come online...")
while not is_online:
time.sleep(1) time.sleep(1)
print("Joining network:", hex(networkId)); print("Joining network:", hex(network_id))
libzt.join(networkId) libzt.join(network_id)
while (not is_joined): while not is_joined:
time.sleep(1) # You can ping this app at this point time.sleep(1) # You can ping this app at this point
print('Joined network') print("Joined network")
#
# Example server
# #
# Example server if mode == "server":
#
if (mode == 'server'):
print("Starting server...") print("Starting server...")
serv = libzt.socket(libzt.ZTS_AF_INET, libzt.ZTS_SOCK_STREAM, 0) serv = libzt.socket(libzt.ZTS_AF_INET, libzt.ZTS_SOCK_STREAM, 0)
try: try:
#serv.setblocking(True) # serv.setblocking(True)
serv.bind(('::', serverPort)) serv.bind(("0.0.0.0", remote_port))
serv.listen(5) serv.listen(5)
while True: while True:
conn, addr = serv.accept() conn, addr = serv.accept()
print('Accepted connection from: ', addr) print("Accepted connection from: ", addr)
while True: while True:
print('recv:') print("recv:")
data = conn.recv(4096) data = conn.recv(4096)
if data: if data:
print('data = ', data) print("data = ", data)
#print(type(b'what')) # print(type(b'what'))
#exit(0) # exit(0)
if not data: break if not data:
print('send:') break
#bytes(data, 'ascii') + b'\x00' print("send:")
# bytes(data, 'ascii') + b'\x00'
n_bytes = conn.send(data) # echo back to the server n_bytes = conn.send(data) # echo back to the server
print('sent ' + str(n_bytes) + ' byte(s)') print("sent " + str(n_bytes) + " byte(s)")
conn.close() conn.close()
print('client disconnected') print("client disconnected")
except Exception as e: except Exception as ex:
print(e) print(ex)
print('errno=',libzt.errno()) # See include/ZeroTierSockets.h for codes print("errno=", libzt.errno()) # See include/ZeroTierSockets.h for codes
#
# # Example client
# Example client #
# if mode == "client":
if (mode == 'client'):
print("Starting client...") print("Starting client...")
client = libzt.socket(libzt.ZTS_AF_INET, libzt.ZTS_SOCK_STREAM, 0) client = libzt.socket(libzt.ZTS_AF_INET, libzt.ZTS_SOCK_STREAM, 0)
try: try:
print("connecting...") print("connecting...")
client.connect((remoteIP, serverPort)) client.connect((remote_ip, remote_port))
print("send:") print("send:")
data = 'Hello, world!' data = "Hello, world!"
client.send(data) client.send(data)
data = client.recv(1024) data = client.recv(1024)
print('Received', repr(data)) print("Received", repr(data))
except Exception as e: except Exception as ex:
print(e) print(ex)
print('errno=',libzt.errno()) print("errno=", libzt.errno())
if __name__ == "__main__":
main()

219
src/bindings/python/sockets.py
View File

@@ -1,64 +1,68 @@
"""ZeroTier low-level socket interface"""
import libzt import libzt
class EventCallbackClass(libzt.PythonDirectorCallbackClass): class EventCallbackClass(libzt.PythonDirectorCallbackClass):
"""ZeroTier event callback class"""
pass pass
# Convert libzt error code to exception
def handle_error(err): def handle_error(err):
if (err == libzt.ZTS_ERR_SOCKET): """Convert libzt error code to exception"""
raise Exception('ZTS_ERR_SOCKET (' + str(err) + ')') if err == libzt.ZTS_ERR_SOCKET:
if (err == libzt.ZTS_ERR_SERVICE): raise Exception("ZTS_ERR_SOCKET (" + str(err) + ")")
raise Exception('ZTS_ERR_SERVICE (' + str(err) + ')') if err == libzt.ZTS_ERR_SERVICE:
if (err == libzt.ZTS_ERR_ARG): raise Exception("ZTS_ERR_SERVICE (" + str(err) + ")")
raise Exception('ZTS_ERR_ARG (' + str(err) + ')') if err == libzt.ZTS_ERR_ARG:
raise Exception("ZTS_ERR_ARG (" + str(err) + ")")
# ZTS_ERR_NO_RESULT isn't strictly an error # ZTS_ERR_NO_RESULT isn't strictly an error
#if (err == libzt.ZTS_ERR_NO_RESULT): # if (err == libzt.ZTS_ERR_NO_RESULT):
# raise Exception('ZTS_ERR_NO_RESULT (' + err + ')') # raise Exception('ZTS_ERR_NO_RESULT (' + err + ')')
if (err == libzt.ZTS_ERR_GENERAL): if err == libzt.ZTS_ERR_GENERAL:
raise Exception('ZTS_ERR_GENERAL (' + str(err) + ')') raise Exception("ZTS_ERR_GENERAL (" + str(err) + ")")
# This implementation of errno is NOT thread safe # This implementation of errno is NOT thread safe
# That is, this value is shared among all lower-level socket calls # That is, this value is shared among all lower-level socket calls
# and may change for any reason at any time if you have multiple # and may change for any reason at any time if you have multiple
# threads making socket calls. # threads making socket calls.
def errno(): def errno():
"""Return errno value of low-level socket layer"""
return libzt.cvar.zts_errno return libzt.cvar.zts_errno
# Start the ZeroTier service
def start(path, callback, port): def start(path, callback, port):
"""Start the ZeroTier service"""
libzt.zts_start(path, callback, port) libzt.zts_start(path, callback, port)
# Stop the ZeroTier service
def stop(): def stop():
"""Stop the ZeroTier service"""
libzt.zts_stop() libzt.zts_stop()
# [debug] Restarts the ZeroTier service and network stack
def restart(): def restart():
"""[debug] Restarts the ZeroTier service and network stack"""
libzt.zts_restart() libzt.zts_restart()
# Permenantly shuts down the network stack.
def free(): def free():
"""Permenantly shuts down the network stack"""
libzt.zts_free() libzt.zts_free()
# Join a ZeroTier network def join(network_id):
def join(networkId): """Join a ZeroTier network"""
libzt.zts_join(networkId) libzt.zts_join(network_id)
# Leave a ZeroTier network def leave(network_id):
def leave(networkId): """Leave a ZeroTier network"""
libzt.zts_leave(networkId) libzt.zts_leave(network_id)
# Orbit a moon def zts_orbit(moon_world_id, moon_seed):
def zts_orbit(moonWorldId, moonSeed): """Orbit a moon"""
return libzt.zts_orbit(moonWorldId, moonSeed) return libzt.zts_orbit(moon_world_id, moon_seed)
# De-orbit a moon def zts_deorbit(moon_world_id):
def zts_deorbit(moonWorldId): """De-orbit a moon"""
return libzt.zts_deorbit(moonWorldId) return libzt.zts_deorbit(moon_world_id)
# Pythonic class that wraps low-level sockets
class socket():
class socket:
"""Pythonic class that wraps low-level sockets"""
_fd = -1 # native layer file descriptor _fd = -1 # native layer file descriptor
_family = -1 _family = -1
_type = -1 _type = -1
@@ -74,274 +78,331 @@ class socket():
self._family = sock_family self._family = sock_family
# Only create native socket if no fd was provided. We may have # Only create native socket if no fd was provided. We may have
# accepted a connection # accepted a connection
if (sock_fd == None): if sock_fd is None:
self._fd = libzt.zts_socket(sock_family, sock_type, sock_proto) self._fd = libzt.zts_socket(sock_family, sock_type, sock_proto)
def has_dualstack_ipv6(): def has_dualstack_ipv6(self):
"""Return whether libzt supports dual stack sockets: yes"""
return True return True
@property @property
def family(self): def family(self):
return _family """Return family of socket"""
return self._family
@property @property
def type(self): def type(self):
return _type """Return type of socket"""
return self._type
@property @property
def proto(self): def proto(self):
return _proto """Return protocol of socket"""
return self._proto
# Intentionally not supported def socketpair(self, sock_family, sock_type, sock_proto):
def socketpair(self, family, type, proto): """Intentionally not supported"""
raise NotImplementedError("socketpair(): libzt does not support AF_UNIX sockets") raise NotImplementedError(
"socketpair(): libzt does not support AF_UNIX sockets"
)
# Convenience function to create a connection to a remote host
def create_connection(self, remote_address): def create_connection(self, remote_address):
"""Convenience function to create a connection to a remote host"""
# TODO: implement timeout # TODO: implement timeout
conn = socket(libzt.ZTS_AF_INET, libzt.ZTS_SOCK_STREAM, 0) conn = socket(libzt.ZTS_AF_INET, libzt.ZTS_SOCK_STREAM, 0)
conn.connect(remote_address) conn.connect(remote_address)
return conn return conn
# Convenience function to create a listening socket def create_server(self, local_address, sock_family=libzt.ZTS_AF_INET, backlog=None):
def create_server(self, local_address, family=libzt.ZTS_AF_INET, backlog=None): """Convenience function to create a listening socket"""
# TODO: implement reuse_port # TODO: implement reuse_port
conn = socket(libzt.ZTS_AF_INET, libzt.ZTS_SOCK_STREAM, 0) conn = socket(sock_family, libzt.ZTS_SOCK_STREAM, 0)
conn.bind(local_address) conn.bind(local_address)
conn.listen(backlog) conn.listen(backlog)
return conn return conn
def fromfd(self, fd, family, type, proto=0): def fromfd(self, fd, sock_family, sock_type, sock_proto=0):
raise NotImplementedError("fromfd(): Not supported. OS File descriptors aren't used in libzt.") """libzt does not support this (yet)"""
raise NotImplementedError(
"fromfd(): Not supported. OS File descriptors aren't used in libzt."
)
def fromshare(self, data): def fromshare(self, data):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def close(self, fd): def getaddrinfo(self, host, port, sock_family=0, sock_type=0, sock_proto=0, flags=0):
raise NotImplementedError("close(fd): Not supported OS File descriptors aren't used in libzt.") """libzt does not support this (yet)"""
def getaddrinfo(self, host, port, family=0, type=0, proto=0, flags=0):
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def getfqdn(self, name): def getfqdn(self, name):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def gethostbyname(self, hostname): def gethostbyname(self, hostname):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def gethostbyname_ex(self, hostname): def gethostbyname_ex(self, hostname):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def gethostname(self): def gethostname(self):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def gethostbyaddr(self, ip_address): def gethostbyaddr(self, ip_address):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def getnameinfo(self, sockaddr, flags): def getnameinfo(self, sockaddr, flags):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def getprotobyname(self, protocolname): def getprotobyname(self, protocolname):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def getservbyname(self, servicename, protocolname): def getservbyname(self, servicename, protocolname):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def getservbyport(self, port, protocolname): def getservbyport(self, port, protocolname):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def ntohl(x): def ntohl(x):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def ntohs(x): def ntohs(x):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def htonl(x): def htonl(x):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def htons(x): def htons(x):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def inet_aton(ip_string): def inet_aton(ip_string):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def inet_ntoa(packed_ip): def inet_ntoa(packed_ip):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def inet_pton(address_family, ip_string): def inet_pton(address_family, ip_string):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def inet_ntop(address_family, packed_ip): def inet_ntop(address_family, packed_ip):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def CMSG_LEN(length): def CMSG_LEN(length):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def CMSG_SPACE(length): def CMSG_SPACE(length):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def getdefaulttimeout(self): def getdefaulttimeout(self):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def setdefaulttimeout(self, timeout): def setdefaulttimeout(self, timeout):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def sethostname(self, name): def sethostname(self, name):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def if_nameindex(self): def if_nameindex(self):
raise NotImplementedError("libzt does not support this (yet?)") """libzt does not support this"""
raise NotImplementedError("if_nameindex(): libzt does not name interfaces.")
def if_nametoindex(self, if_name): def if_nametoindex(self, if_name):
"""libzt does not support this"""
raise NotImplementedError("if_nametoindex(): libzt does not name interfaces.") raise NotImplementedError("if_nametoindex(): libzt does not name interfaces.")
def if_indextoname(self, if_index): def if_indextoname(self, if_index):
"""libzt does not support this"""
raise NotImplementedError("if_indextoname(): libzt does not name interfaces.") raise NotImplementedError("if_indextoname(): libzt does not name interfaces.")
# Accept connection on the socket
def accept(self): def accept(self):
"""Accept connection on the socket"""
new_conn_fd, addr, port = libzt.zts_py_accept(self._fd) new_conn_fd, addr, port = libzt.zts_py_accept(self._fd)
if (new_conn_fd < 0): if new_conn_fd < 0:
handle_error(new_conn_fd) handle_error(new_conn_fd)
return None return None
return ztsocket(self._family, self._type, self._proto, new_conn_fd), addr return socket(self._family, self._type, self._proto, new_conn_fd), addr
# Bind the socket to a local interface address
def bind(self, local_address): def bind(self, local_address):
"""Bind the socket to a local interface address"""
err = libzt.zts_py_bind(self._fd, self._family, self._type, local_address) err = libzt.zts_py_bind(self._fd, self._family, self._type, local_address)
if (err < 0): if err < 0:
handle_error(err) handle_error(err)
# Close the socket
def close(self): def close(self):
"""Close the socket"""
err = libzt.zts_py_close(self._fd) err = libzt.zts_py_close(self._fd)
if (err < 0): if err < 0:
handle_error(err) handle_error(err)
# Connect the socket to a remote address
def connect(self, remote_address): def connect(self, remote_address):
"""Connect the socket to a remote address"""
err = libzt.zts_py_connect(self._fd, self._family, self._type, remote_address) err = libzt.zts_py_connect(self._fd, self._family, self._type, remote_address)
if (err < 0): if err < 0:
handle_error(err) handle_error(err)
# Connect to remote host but return low-level result code, and errno on failure
# This uses a non-thread-safe implementation of errno
def connect_ex(self, remote_address): def connect_ex(self, remote_address):
"""Connect to remote host but return low-level result code, and errno on failure
This uses a non-thread-safe implementation of errno
"""
err = libzt.zts_py_connect(self._fd, self._family, self._type, remote_address) err = libzt.zts_py_connect(self._fd, self._family, self._type, remote_address)
if (err < 0): if err < 0:
return errno() return errno()
return err return err
def detach(self): def detach(self):
raise NotImplementedError("detach(): Not supported. OS File descriptors aren't used in libzt.") """libzt does not support this"""
raise NotImplementedError(
"detach(): Not supported. OS File descriptors aren't used in libzt.")
def dup(self): def dup(self):
"""libzt does not support this"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def fileno(self): def fileno(self):
"""libzt does not support this"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def get_inheritable(self): def get_inheritable(self):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def getpeername(self): def getpeername(self):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def getsockname(self): def getsockname(self):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def getsockopt(self, level, optname, buflen): def getsockopt(self, level, optname, buflen):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
# Get whether this socket is in blocking or non-blocking mode
def getblocking(self): def getblocking(self):
"""Get whether this socket is in blocking or non-blocking mode"""
return libzt.zts_py_getblocking(self._fd) return libzt.zts_py_getblocking(self._fd)
def gettimeout(self): def gettimeout(self):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def ioctl(self, control, option): def ioctl(self, control, option):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
# Put the socket in a listening state (with an optional backlog argument)
def listen(self, backlog): def listen(self, backlog):
"""Put the socket in a listening state (with an optional backlog argument)"""
err = libzt.zts_py_listen(self._fd, backlog) err = libzt.zts_py_listen(self._fd, backlog)
if (err < 0): if err < 0:
handle_error(err) handle_error(err)
def makefile(mode='r', buffering=None, *, encoding=None, errors=None, newline=None): def makefile(mode="r", buffering=None, *, encoding=None, errors=None, newline=None):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
# Read data from the socket
def recv(self, n_bytes, flags=0): def recv(self, n_bytes, flags=0):
"""Read data from the socket"""
err, data = libzt.zts_py_recv(self._fd, n_bytes, flags) err, data = libzt.zts_py_recv(self._fd, n_bytes, flags)
if (err < 0): if err < 0:
handle_error(err) handle_error(err)
return None return None
return data return data
def recvfrom(self, bufsize, flags): def recvfrom(self, bufsize, flags):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def recvmsg(self, bufsize, ancbufsize, flags): def recvmsg(self, bufsize, ancbufsize, flags):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def recvmsg_into(self, buffers, ancbufsize, flags): def recvmsg_into(self, buffers, ancbufsize, flags):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def recvfrom_into(self, buffer, nbytes, flags): def recvfrom_into(self, buffer, n_bytes, flags):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def recv_into(self, buffer, nbytes, flags): def recv_into(self, buffer, n_bytes, flags):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
# Write data to the socket
def send(self, data, flags=0): def send(self, data, flags=0):
"""Write data to the socket"""
err = libzt.zts_py_send(self._fd, data, len(data), flags) err = libzt.zts_py_send(self._fd, data, len(data), flags)
if (err < 0): if err < 0:
handle_error(err) handle_error(err)
return err return err
def sendall(self, bytes, flags): def sendall(self, n_bytes, flags):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def sendto(self, bytes, address): def sendto(self, n_bytes, flags, address):
raise NotImplementedError("libzt does not support this (yet?)") """libzt does not support this (yet)"""
def sendto(self, bytes, flags, address):
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def sendmsg(self, buffers, ancdata, flags, address): def sendmsg(self, buffers, ancdata, flags, address):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def sendmsg_afalg(self, msg, *, op, iv, assoclen, flags): def sendmsg_afalg(self, msg, *, op, iv, assoclen, flags):
"""libzt does not support this (yet)"""
raise NotImplementedError("sendmsg_afalg(): libzt does not support AF_ALG") raise NotImplementedError("sendmsg_afalg(): libzt does not support AF_ALG")
def send_fds(self, sock, buffers, fds, flags, address): def send_fds(self, sock, buffers, fds, flags, address):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def recv_fds(self, sock, bufsize, maxfds, flags): def recv_fds(self, sock, bufsize, maxfds, flags):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def sendfile(self, file, offset=0, count=None): def sendfile(self, file, offset=0, count=None):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def set_inheritable(self, inheritable): def set_inheritable(self, inheritable):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
# Set whether this socket is in blocking or non-blocking mode
def setblocking(self, flag): def setblocking(self, flag):
"""Set whether this socket is in blocking or non-blocking mode"""
libzt.zts_py_setblocking(self._fd, flag) libzt.zts_py_setblocking(self._fd, flag)
def settimeout(self, value): def settimeout(self, value):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
def setsockopt(self, level, optname, value):
# TODO: value: buffer # TODO: value: buffer
# TODO: value: int # TODO: value: int
# TODO: value: None -> optlen required # TODO: value: None -> optlen required
def setsockopt(self, level, optname, value):
"""libzt does not support this (yet)"""
raise NotImplementedError("libzt does not support this (yet?)") raise NotImplementedError("libzt does not support this (yet?)")
# Shut down one or more aspects (rx/tx) of the socket
def shutdown(self, how): def shutdown(self, how):
libzt.shutdown(self._fd, how) """Shut down one or more aspects (rx/tx) of the socket"""
libzt.zts_shutdown(self._fd, how)