/*
 * Copyright (c)2013-2021 ZeroTier, Inc.
 *
 * Use of this software is governed by the Business Source License included
 * in the LICENSE.TXT file in the project's root directory.
 *
 * Change Date: 2026-01-01
 *
 * On the date above, in accordance with the Business Source License, use
 * of this software will be governed by version 2.0 of the Apache License.
 */
/****/

using System;
using System.Net;
using System.Net.Sockets;
using System.Runtime.InteropServices;

using ZeroTier;

namespace ZeroTier.Sockets
{
    public class Socket {
        /// <summary>No error.</summary>
        public static readonly int ZTS_ERR_OK = 0;
        /// <summary>Socket error, see Socket.ErrNo() for additional context.</summary>
        public static readonly int ZTS_ERR_SOCKET = -1;
        /// <summary>You probably did something at the wrong time.</summary>
        public static readonly int ZTS_ERR_SERVICE = -2;
        /// <summary>Invalid argument.</summary>
        public static readonly int ZTS_ERR_ARG = -3;
        /// <summary>No result. (not necessarily an error.)</summary>
        public static readonly int ZTS_ERR_NO_RESULT = -4;
        /// <summary>Consider filing a bug report.</summary>
        public static readonly int ZTS_ERR_GENERAL = -5;

        int _fd;
        bool _isClosed;
        bool _isListening;
        bool _isBound;
        bool _isConnected;

        int _connectTimeout = 30000;

        AddressFamily _socketFamily;
        SocketType _socketType;
        ProtocolType _socketProtocol;

        internal EndPoint _localEndPoint;
        internal EndPoint _remoteEndPoint;

        private void InitializeInternalFlags()
        {
            _isClosed = false;
            _isListening = false;
        }

        public Socket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType)
        {
            int family = -1;
            int type = -1;
            int protocol = -1;
            // Map .NET socket parameters to ZeroTier equivalents
            switch (addressFamily) {
                case AddressFamily.InterNetwork:
                    family = Constants.AF_INET;
                    break;
                case AddressFamily.InterNetworkV6:
                    family = Constants.AF_INET6;
                    break;
                case AddressFamily.Unknown:
                    family = Constants.AF_UNSPEC;
                    break;
            }
            switch (socketType) {
                case SocketType.Stream:
                    type = Constants.SOCK_STREAM;
                    break;
                case SocketType.Dgram:
                    type = Constants.SOCK_DGRAM;
                    break;
            }
            switch (protocolType) {
                case ProtocolType.Udp:
                    protocol = Constants.IPPROTO_UDP;
                    break;
                case ProtocolType.Tcp:
                    protocol = Constants.IPPROTO_TCP;
                    break;
                case ProtocolType.Unspecified:
                    protocol = 0;   // ?
                    break;
            }
            if ((_fd = zts_bsd_socket(family, type, protocol)) < 0) {
                throw new ZeroTier.Sockets.SocketException((int)_fd);
            }
            _socketFamily = addressFamily;
            _socketType = socketType;
            _socketProtocol = protocolType;
            InitializeInternalFlags();
        }

        private Socket(
            int fileDescriptor,
            AddressFamily addressFamily,
            SocketType socketType,
            ProtocolType protocolType,
            EndPoint localEndPoint,
            EndPoint remoteEndPoint)
        {
            _socketFamily = addressFamily;
            _socketType = socketType;
            _socketProtocol = protocolType;
            _localEndPoint = localEndPoint;
            _remoteEndPoint = remoteEndPoint;
            _fd = fileDescriptor;
            InitializeInternalFlags();
        }

        public void Connect(IPEndPoint remoteEndPoint)
        {
            if (_isClosed) {
                throw new ObjectDisposedException("Socket has been closed");
            }
            if (_fd < 0) {
                // Invalid file descriptor
                throw new ZeroTier.Sockets.SocketException((int)Constants.ERR_SOCKET);
            }
            if (remoteEndPoint == null) {
                throw new ArgumentNullException("remoteEndPoint");
            }
            int err = zts_connect(_fd, remoteEndPoint.Address.ToString(), (ushort)remoteEndPoint.Port, _connectTimeout);
            if (err < 0) {
                throw new ZeroTier.Sockets.SocketException(err, ZeroTier.Core.Node.ErrNo);
            }
            _remoteEndPoint = remoteEndPoint;
            _isConnected = true;
        }

        public void Bind(IPEndPoint localEndPoint)
        {
            if (_isClosed) {
                throw new ObjectDisposedException("Socket has been closed");
            }
            if (_fd < 0) {
                // Invalid file descriptor
                throw new ZeroTier.Sockets.SocketException((int)Constants.ERR_SOCKET);
            }
            if (localEndPoint == null) {
                throw new ArgumentNullException("localEndPoint");
            }
            int err = Constants.ERR_OK;
            if (localEndPoint.AddressFamily == AddressFamily.InterNetwork) {
                err = zts_bind(_fd, "0.0.0.0", (ushort)localEndPoint.Port);
            }
            if (localEndPoint.AddressFamily == AddressFamily.InterNetworkV6) {
                // Todo: detect IPAddress.IPv6Any
                err = zts_bind(_fd, "::", (ushort)localEndPoint.Port);
            }
            if (err < 0) {
                throw new ZeroTier.Sockets.SocketException((int)err);
            }
            _localEndPoint = localEndPoint;
            _isBound = true;
        }

        public void Listen(int backlog)
        {
            if (_isClosed) {
                throw new ObjectDisposedException("Socket has been closed");
            }
            if (_fd < 0) {
                // Invalid file descriptor
                throw new ZeroTier.Sockets.SocketException((int)Constants.ERR_SOCKET);
            }
            int err = Constants.ERR_OK;
            if ((err = zts_bsd_listen(_fd, backlog)) < 0) {
                // Invalid backlog value perhaps?
                throw new ZeroTier.Sockets.SocketException((int)Constants.ERR_SOCKET);
            }
            _isListening = true;
        }

        public Socket Accept()
        {
            if (_isClosed) {
                throw new ObjectDisposedException("Socket has been closed");
            }
            if (_fd < 0) {
                // Invalid file descriptor
                throw new ZeroTier.Sockets.SocketException((int)Constants.ERR_SOCKET);
            }
            if (_isListening == false) {
                throw new InvalidOperationException("Socket is not in a listening state. Call Listen() first");
            }
            IntPtr lpBuffer = Marshal.AllocHGlobal(ZeroTier.Constants.INET6_ADDRSTRLEN);
            int port = 0;
            int accepted_fd = zts_accept(_fd, lpBuffer, ZeroTier.Constants.INET6_ADDRSTRLEN, ref port);
            // Convert buffer to managed string
            string str = Marshal.PtrToStringAnsi(lpBuffer);
            Marshal.FreeHGlobal(lpBuffer);
            lpBuffer = IntPtr.Zero;
            IPEndPoint clientEndPoint = new IPEndPoint(IPAddress.Parse(str), port);
            // Create new socket by providing file descriptor returned from zts_bsd_accept call.
            Socket clientSocket =
                new Socket(accepted_fd, _socketFamily, _socketType, _socketProtocol, _localEndPoint, clientEndPoint);
            return clientSocket;
        }

        public void Shutdown(SocketShutdown how)
        {
            if (_isClosed) {
                throw new ObjectDisposedException("Socket has been closed");
            }
            int ztHow = 0;
            switch (how) {
                case SocketShutdown.Receive:
                    ztHow = Constants.O_RDONLY;
                    break;
                case SocketShutdown.Send:
                    ztHow = Constants.O_WRONLY;
                    break;
                case SocketShutdown.Both:
                    ztHow = Constants.O_RDWR;
                    break;
            }
            zts_bsd_shutdown(_fd, ztHow);
        }

        public void Close()
        {
            Close(0);
        }

        public void Close(int timeout)
        {
            // TODO: Timeout needs to be implemented
            if (_isClosed) {
                throw new ObjectDisposedException("Socket has already been closed");
            }
            zts_bsd_close(_fd);
            _isClosed = true;
        }

        public bool Blocking
        {
            get {
                return Convert.ToBoolean(zts_get_blocking(_fd));
            }
            set {
                zts_set_blocking(_fd, Convert.ToInt32(value));
            }
        }

        public bool Poll(int microSeconds, System.Net.Sockets.SelectMode mode)
        {
            if (_isClosed) {
                throw new ObjectDisposedException("Socket has been closed");
            }
            zts_pollfd poll_set = new zts_pollfd();
            poll_set.fd = _fd;
            if (mode == SelectMode.SelectRead) {
                poll_set.events = (short)((byte)ZeroTier.Constants.POLLIN);
            }
            if (mode == SelectMode.SelectWrite) {
                poll_set.events = (short)((byte)ZeroTier.Constants.POLLOUT);
            }
            if (mode == SelectMode.SelectError) {
                poll_set.events = (short)((byte)ZeroTier.Constants.POLLERR | (byte)ZeroTier.Constants.POLLNVAL);
            }
            IntPtr poll_fd_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(zts_pollfd)));
            Marshal.StructureToPtr(poll_set, poll_fd_ptr, false);
            int result = 0;
            int timeout_ms = (microSeconds / 1000);
            uint numfds = 1;
            if ((result = zts_bsd_poll(poll_fd_ptr, numfds, timeout_ms)) < 0) {
                throw new ZeroTier.Sockets.SocketException(result, ZeroTier.Core.Node.ErrNo);
            }
            poll_set = (zts_pollfd)Marshal.PtrToStructure(poll_fd_ptr, typeof(zts_pollfd));
            if (result != 0) {
                if (mode == SelectMode.SelectRead) {
                    result = Convert.ToInt32(((byte)poll_set.revents & (byte)ZeroTier.Constants.POLLIN) != 0);
                }
                if (mode == SelectMode.SelectWrite) {
                    result = Convert.ToInt32(((byte)poll_set.revents & (byte)ZeroTier.Constants.POLLOUT) != 0);
                }
                if (mode == SelectMode.SelectError) {
                    result = Convert.ToInt32(
                        ((poll_set.revents & (byte)ZeroTier.Constants.POLLERR) != 0)
                        || ((poll_set.revents & (byte)ZeroTier.Constants.POLLNVAL) != 0));
                }
            }
            Marshal.FreeHGlobal(poll_fd_ptr);
            return result > 0;
        }

        public Int32 Send(Byte[] buffer)
        {
            return Send(buffer, 0, buffer != null ? buffer.Length : 0, SocketFlags.None);
        }

        public Int32 Send(Byte[] buffer, int offset, int size, SocketFlags socketFlags)
        {
            if (_isClosed) {
                throw new ObjectDisposedException("Socket has been closed");
            }
            if (_fd < 0) {
                throw new ZeroTier.Sockets.SocketException((int)ZeroTier.Constants.ERR_SOCKET);
            }
            if (buffer == null) {
                throw new ArgumentNullException("buffer");
            }
            if (size < 0 || size > buffer.Length - offset) {
                throw new ArgumentOutOfRangeException("size");
            }
            if (offset < 0 || offset > buffer.Length) {
                throw new ArgumentOutOfRangeException("offset");
            }
            int flags = 0;
            IntPtr bufferPtr = Marshal.UnsafeAddrOfPinnedArrayElement(buffer, 0);
            return zts_bsd_send(_fd, bufferPtr + offset, (uint)Buffer.ByteLength(buffer), (int)flags);
        }

        public int Available
        {
            get {
                return zts_get_data_available(_fd);
            }
        }

        public Int32 Receive(Byte[] buffer)
        {
            return Receive(buffer, 0, buffer != null ? buffer.Length : 0, SocketFlags.None);
        }

        public Int32 Receive(byte[] buffer, int offset, int size, SocketFlags socketFlags)
        {
            if (_isClosed) {
                throw new ObjectDisposedException("Socket has been closed");
            }
            if (_fd < 0) {
                throw new ZeroTier.Sockets.SocketException((int)ZeroTier.Constants.ERR_SOCKET);
            }
            if (buffer == null) {
                throw new ArgumentNullException("buffer");
            }
            if (size < 0 || size > buffer.Length - offset) {
                throw new ArgumentOutOfRangeException("size");
            }
            if (offset < 0 || offset > buffer.Length) {
                throw new ArgumentOutOfRangeException("offset");
            }
            int flags = 0;
            IntPtr bufferPtr = Marshal.UnsafeAddrOfPinnedArrayElement(buffer, 0);
            return zts_bsd_recv(_fd, bufferPtr + offset, (uint)Buffer.ByteLength(buffer), (int)flags);
        }

        public int ReceiveTimeout
        {
            get {
                return zts_get_recv_timeout(_fd);
            }
            // TODO: microseconds
            set {
                zts_set_recv_timeout(_fd, value, 0);
            }
        }

        public int SendTimeout
        {
            get {
                return zts_get_send_timeout(_fd);
            }
            // TODO: microseconds
            set {
                zts_set_send_timeout(_fd, value, 0);
            }
        }

        public int ConnectTimeout
        {
            get {
                return _connectTimeout;
            }
            set {
                _connectTimeout = value;
            }
        }

        public int ReceiveBufferSize
        {
            get {
                return zts_get_recv_buf_size(_fd);
            }
            set {
                zts_set_recv_buf_size(_fd, value);
            }
        }

        public int SendBufferSize
        {
            get {
                return zts_get_send_buf_size(_fd);
            }
            set {
                zts_set_send_buf_size(_fd, value);
            }
        }

        public short Ttl
        {
            get {
                return Convert.ToInt16(zts_get_ttl(_fd));
            }
            set {
                zts_set_ttl(_fd, value);
            }
        }

        public LingerOption LingerState
        {
            get {
                LingerOption lo =
                    new LingerOption(Convert.ToBoolean(zts_get_linger_enabled(_fd)), zts_get_linger_value(_fd));
                return lo;
            }
            set {
                zts_set_linger(_fd, Convert.ToInt32(value.Enabled), value.LingerTime);
            }
        }

        public bool NoDelay
        {
            get {
                return Convert.ToBoolean(zts_get_no_delay(_fd));
            }
            set {
                zts_set_no_delay(_fd, Convert.ToInt32(value));
            }
        }

        public bool KeepAlive
        {
            get {
                return Convert.ToBoolean(zts_get_keepalive(_fd));
            }
            set {
                zts_set_keepalive(_fd, Convert.ToInt32(value));
            }
        }

        public bool Connected
        {
            get {
                return _isConnected;
            }
        }

        public bool IsBound
        {
            get {
                return _isBound;
            }
        }

        public AddressFamily AddressFamily
        {
            get {
                return _socketFamily;
            }
        }

        public SocketType SocketType
        {
            get {
                return _socketType;
            }
        }

        public ProtocolType ProtocolType
        {
            get {
                return _socketProtocol;
            }
        }

        /* .NET has moved to OSSupportsIPv* but libzt isn't an OS so we keep this old convention */
        public static bool SupportsIPv4
        {
            get {
                return true;
            }
        }

        /* .NET has moved to OSSupportsIPv* but libzt isn't an OS so we keep this old convention */
        public static bool SupportsIPv6
        {
            get {
                return true;
            }
        }

        public EndPoint RemoteEndPoint
        {
            get {
                return _remoteEndPoint;
            }
        }

        public EndPoint LocalEndPoint
        {
            get {
                return _localEndPoint;
            }
        }

        /* Structures and functions used internally to communicate with
        lower-level C API defined in include/ZeroTierSockets.h */

        [DllImport(
            "libzt",
            CharSet = CharSet.Ansi,
            EntryPoint = "CSharp_zts_bsd_gethostbyname")] public static extern global::System.IntPtr
        zts_bsd_gethostbyname(string jarg1);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_select")]
        static extern int zts_bsd_select(int jarg1, IntPtr jarg2, IntPtr jarg3, IntPtr jarg4, IntPtr jarg5);

        [DllImport("libzt", EntryPoint = "CSharp_zts_get_all_stats")]
        static extern int zts_get_all_stats(IntPtr arg1);

        [DllImport("libzt", EntryPoint = "CSharp_zts_get_protocol_stats")]
        static extern int zts_get_protocol_stats(int arg1, IntPtr arg2);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_socket")]
        static extern int zts_bsd_socket(int arg1, int arg2, int arg3);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_connect")]
        static extern int zts_bsd_connect(int arg1, IntPtr arg2, ushort arg3);

        [DllImport("libzt", CharSet = CharSet.Ansi, EntryPoint = "CSharp_zts_bsd_connect_easy")]
        static extern int zts_bsd_connect_easy(int arg1, int arg2, string arg3, ushort arg4, int arg5);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_bind")]
        static extern int zts_bsd_bind(int arg1, IntPtr arg2, ushort arg3);

        [DllImport("libzt", CharSet = CharSet.Ansi, EntryPoint = "CSharp_zts_bsd_bind_easy")]
        static extern int zts_bsd_bind_easy(int arg1, int arg2, string arg3, ushort arg4);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_listen")]
        static extern int zts_bsd_listen(int arg1, int arg2);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_accept")]
        static extern int zts_bsd_accept(int arg1, IntPtr arg2, IntPtr arg3);

        [DllImport("libzt", CharSet = CharSet.Ansi, EntryPoint = "CSharp_zts_bsd_accept_easy")]
        static extern int zts_bsd_accept_easy(int arg1, IntPtr remoteAddrStr, int arg2, ref int arg3);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_setsockopt")]
        static extern int zts_bsd_setsockopt(int arg1, int arg2, int arg3, IntPtr arg4, ushort arg5);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_getsockopt")]
        static extern int zts_bsd_getsockopt(int arg1, int arg2, int arg3, IntPtr arg4, IntPtr arg5);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_getsockname")]
        static extern int zts_bsd_getsockname(int arg1, IntPtr arg2, IntPtr arg3);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_getpeername")]
        static extern int zts_bsd_getpeername(int arg1, IntPtr arg2, IntPtr arg3);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_close")]
        static extern int zts_bsd_close(int arg1);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_fcntl")]
        static extern int zts_bsd_fcntl(int arg1, int arg2, int arg3);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_poll")]
        static extern int zts_bsd_poll(IntPtr arg1, uint arg2, int arg3);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_ioctl")]
        static extern int zts_bsd_ioctl(int arg1, uint arg2, IntPtr arg3);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_send")]
        static extern int zts_bsd_send(int arg1, IntPtr arg2, uint arg3, int arg4);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_sendto")]
        static extern int zts_bsd_sendto(int arg1, IntPtr arg2, uint arg3, int arg4, IntPtr arg5, ushort arg6);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_sendmsg")]
        static extern int zts_bsd_sendmsg(int arg1, IntPtr arg2, int arg3);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_recv")]
        static extern int zts_bsd_recv(int arg1, IntPtr arg2, uint arg3, int arg4);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_recvfrom")]
        static extern int zts_bsd_recvfrom(int arg1, IntPtr arg2, uint arg3, int arg4, IntPtr arg5, IntPtr arg6);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_recvmsg")]
        static extern int zts_bsd_recvmsg(int arg1, IntPtr arg2, int arg3);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_read")]
        static extern int zts_bsd_read(int arg1, IntPtr arg2, uint arg3);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_readv")]
        static extern int zts_bsd_readv(int arg1, IntPtr arg2, int arg3);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_write")]
        static extern int zts_bsd_write(int arg1, IntPtr arg2, uint arg3);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_writev")]
        static extern int zts_bsd_writev(int arg1, IntPtr arg2, int arg3);

        [DllImport("libzt", EntryPoint = "CSharp_zts_bsd_shutdown")]
        static extern int zts_bsd_shutdown(int arg1, int arg2);

        [DllImport("libzt", EntryPoint = "CSharp_zts_get_data_available")]
        static extern int zts_get_data_available(int fd);

        [DllImport("libzt", EntryPoint = "CSharp_zts_set_no_delay")]
        static extern int zts_set_no_delay(int fd, int enabled);

        [DllImport("libzt", EntryPoint = "CSharp_zts_get_no_delay")]
        static extern int zts_get_no_delay(int fd);

        [DllImport("libzt", EntryPoint = "CSharp_zts_set_linger")]
        static extern int zts_set_linger(int fd, int enabled, int value);

        [DllImport("libzt", EntryPoint = "CSharp_zts_get_linger_enabled")]
        static extern int zts_get_linger_enabled(int fd);

        [DllImport("libzt", EntryPoint = "CSharp_zts_get_linger_value")]
        static extern int zts_get_linger_value(int fd);

        [DllImport("libzt", EntryPoint = "CSharp_zts_set_reuse_addr")]
        static extern int zts_set_reuse_addr(int fd, int enabled);

        [DllImport("libzt", EntryPoint = "CSharp_zts_get_reuse_addr")]
        static extern int zts_get_reuse_addr(int fd);

        [DllImport("libzt", EntryPoint = "CSharp_zts_set_recv_timeout")]
        static extern int zts_set_recv_timeout(int fd, int seconds, int microseconds);

        [DllImport("libzt", EntryPoint = "CSharp_zts_get_recv_timeout")]
        static extern int zts_get_recv_timeout(int fd);

        [DllImport("libzt", EntryPoint = "CSharp_zts_set_send_timeout")]
        static extern int zts_set_send_timeout(int fd, int seconds, int microseconds);

        [DllImport("libzt", EntryPoint = "CSharp_zts_get_send_timeout")]
        static extern int zts_get_send_timeout(int fd);

        [DllImport("libzt", EntryPoint = "CSharp_zts_set_send_buf_size")]
        static extern int zts_set_send_buf_size(int fd, int size);

        [DllImport("libzt", EntryPoint = "CSharp_zts_get_send_buf_size")]
        static extern int zts_get_send_buf_size(int fd);

        [DllImport("libzt", EntryPoint = "CSharp_zts_set_recv_buf_size")]
        static extern int zts_set_recv_buf_size(int fd, int size);

        [DllImport("libzt", EntryPoint = "CSharp_zts_get_recv_buf_size")]
        static extern int zts_get_recv_buf_size(int fd);

        [DllImport("libzt", EntryPoint = "CSharp_zts_set_ttl")]
        static extern int zts_set_ttl(int fd, int ttl);

        [DllImport("libzt", EntryPoint = "CSharp_zts_get_ttl")]
        static extern int zts_get_ttl(int fd);

        [DllImport("libzt", EntryPoint = "CSharp_zts_set_blocking")]
        static extern int zts_set_blocking(int fd, int enabled);

        [DllImport("libzt", EntryPoint = "CSharp_zts_get_blocking")]
        static extern int zts_get_blocking(int fd);

        [DllImport("libzt", EntryPoint = "CSharp_zts_set_keepalive")]
        static extern int zts_set_keepalive(int fd, int enabled);

        [DllImport("libzt", EntryPoint = "CSharp_zts_get_keepalive")]
        static extern int zts_get_keepalive(int fd);

        [DllImport("libzt", EntryPoint = "CSharp_zts_add_dns_nameserver")]
        static extern int zts_add_dns_nameserver(IntPtr arg1);

        [DllImport("libzt", EntryPoint = "CSharp_zts_del_dns_nameserver")]
        static extern int zts_del_dns_nameserver(IntPtr arg1);

        [DllImport("libzt", EntryPoint = "CSharp_zts_errno_get")]
        static extern int zts_errno_get();

        [DllImport("libzt", CharSet = CharSet.Ansi, EntryPoint = "CSharp_zts_accept")]
        static extern int zts_accept(int jarg1, IntPtr jarg2, int jarg3, ref int jarg4);

        [DllImport("libzt", CharSet = CharSet.Ansi, EntryPoint = "CSharp_zts_tcp_client")]
        static extern int zts_tcp_client(string jarg1, int jarg2);

        [DllImport("libzt", CharSet = CharSet.Ansi, EntryPoint = "CSharp_zts_tcp_server")]
        static extern int zts_tcp_server(string jarg1, int jarg2, string jarg3, int jarg4, IntPtr jarg5);

        [DllImport("libzt", CharSet = CharSet.Ansi, EntryPoint = "CSharp_zts_udp_server")]
        static extern int zts_udp_server(string jarg1, int jarg2);

        [DllImport("libzt", CharSet = CharSet.Ansi, EntryPoint = "CSharp_zts_udp_client")]
        static extern int zts_udp_client(string jarg1);

        [DllImport("libzt", CharSet = CharSet.Ansi, EntryPoint = "CSharp_zts_bind")]
        static extern int zts_bind(int jarg1, string jarg2, int jarg3);

        [DllImport("libzt", CharSet = CharSet.Ansi, EntryPoint = "CSharp_zts_connect")]
        static extern int zts_connect(int jarg1, string jarg2, int jarg3, int jarg4);

        [DllImport("libzt", EntryPoint = "CSharp_zts_stats_get_all")]
        static extern int zts_stats_get_all(IntPtr jarg1);

        /*
                [DllImport("libzt", EntryPoint = "CSharp_zts_set_no_delay")]
                static extern int zts_set_no_delay(int jarg1, int jarg2);

                [DllImport("libzt", EntryPoint = "CSharp_zts_get_no_delay")]
                static extern int zts_get_no_delay(int jarg1);

                [DllImport("libzt", EntryPoint = "CSharp_zts_set_linger")]
                static extern int zts_set_linger(int jarg1, int jarg2, int jarg3);

                [DllImport("libzt", EntryPoint = "CSharp_zts_get_linger_enabled")]
                static extern int zts_get_linger_enabled(int jarg1);

                [DllImport("libzt", EntryPoint = "CSharp_zts_get_linger_value")]
                static extern int zts_get_linger_value(int jarg1);

                [DllImport("libzt", EntryPoint = "CSharp_zts_set_reuse_addr")]
                static extern int zts_set_reuse_addr(int jarg1, int jarg2);

                [DllImport("libzt", EntryPoint = "CSharp_zts_get_reuse_addr")]
                static extern int zts_get_reuse_addr(int jarg1);

                [DllImport("libzt", EntryPoint = "CSharp_zts_set_recv_timeout")]
                static extern int zts_set_recv_timeout(int jarg1, int jarg2, int jarg3);

                [DllImport("libzt", EntryPoint = "CSharp_zts_get_recv_timeout")]
                static extern int zts_get_recv_timeout(int jarg1);

                [DllImport("libzt", EntryPoint = "CSharp_zts_set_send_timeout")]
                static extern int zts_set_send_timeout(int jarg1, int jarg2, int jarg3);

                [DllImport("libzt", EntryPoint = "CSharp_zts_get_send_timeout")]
                static extern int zts_get_send_timeout(int jarg1);

                [DllImport("libzt", EntryPoint = "CSharp_zts_set_send_buf_size")]
                static extern int zts_set_send_buf_size(int jarg1, int jarg2);

                [DllImport("libzt", EntryPoint = "CSharp_zts_get_send_buf_size")]
                static extern int zts_get_send_buf_size(int jarg1);

                [DllImport("libzt", EntryPoint = "CSharp_zts_set_recv_buf_size")]
                static extern int zts_set_recv_buf_size(int jarg1, int jarg2);

                [DllImport("libzt", EntryPoint = "CSharp_zts_get_recv_buf_size")]
                static extern int zts_get_recv_buf_size(int jarg1);

                [DllImport("libzt", EntryPoint = "CSharp_zts_set_ttl")]
                static extern int zts_set_ttl(int jarg1, int jarg2);

                [DllImport("libzt", EntryPoint = "CSharp_zts_get_ttl")]
                static extern int zts_get_ttl(int jarg1);

                [DllImport("libzt", EntryPoint = "CSharp_zts_set_blocking")]
                static extern int zts_set_blocking(int jarg1, int jarg2);

                [DllImport("libzt", EntryPoint = "CSharp_zts_get_blocking")]
                static extern int zts_get_blocking(int jarg1);

                [DllImport("libzt", EntryPoint = "CSharp_zts_set_keepalive")]
                static extern int zts_set_keepalive(int jarg1, int jarg2);

                [DllImport("libzt", EntryPoint = "CSharp_zts_get_keepalive")]
                static extern int zts_get_keepalive(int jarg1);



        */

        [DllImport("libzt", EntryPoint = "CSharp_zts_util_delay")]
        public static extern void zts_util_delay(int jarg1);

        [DllImport("libzt", CharSet = CharSet.Ansi, EntryPoint = "CSharp_zts_util_get_ip_family")]
        static extern int zts_util_get_ip_family(string jarg1);

        [DllImport("libzt", CharSet = CharSet.Ansi, EntryPoint = "CSharp_zts_util_ipstr_to_saddr")]
        static extern int zts_util_ipstr_to_saddr(string jarg1, int jarg2, IntPtr jarg3, IntPtr jarg4);

        /// <value>The value of errno for the low-level socket layer</value>
        public static int ErrNo
        {
            get {
                return zts_errno_get();
            }
        }

        [StructLayout(LayoutKind.Sequential)] struct zts_sockaddr {
            public byte sa_len;
            public byte sa_family;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 14)]
            public byte[] sa_data;
        }

        [StructLayout(LayoutKind.Sequential)]
        struct zts_in_addr {
            public uint s_addr;
        }

        [StructLayout(LayoutKind.Sequential)]
        struct zts_sockaddr_in {
            public byte sin_len;
            public byte sin_family;
            public short sin_port;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
            public byte[] sin_addr;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
            public char[] sin_zero;   // SIN_ZERO_LEN
        }

        [StructLayout(LayoutKind.Sequential)]
        struct zts_pollfd {
            public int fd;
            public short events;
            public short revents;
        }

        [StructLayout(LayoutKind.Sequential)]
        struct zts_timeval {
            public long tv_sec;
            public long tv_usec;
        }
    }
}