Networking

/**
 * Create a TCP server with default options
 * @return NetServer instance
 */
NetServer createNetServer();

/**
 * Create a TCP server with custom options
 * @param options Server configuration options
 * @return NetServer instance
 */
NetServer createNetServer(NetServerOptions options);

/**
 * TCP Server interface for handling connections
 */
interface NetServer extends Measured, Closeable {
  /**
   * Set connection handler for incoming connections
   * @param handler Handler for new socket connections
   * @return this for chaining
   */
  NetServer connectHandler(Handler<NetSocket> handler);

  /**
   * Start listening on a port
   * @param port Port to listen on
   * @return Future that completes when server is listening
   */
  Future<NetServer> listen(int port);

  /**
   * Start listening on a specific host and port
   * @param port Port to listen on
   * @param host Host to bind to
   * @return Future that completes when server is listening
   */
  Future<NetServer> listen(int port, String host);

  /**
   * Start listening on a SocketAddress
   * @param localAddress Address to listen on
   * @return Future that completes when server is listening
   */
  Future<NetServer> listen(SocketAddress localAddress);

  /**
   * Get the actual port the server is listening on
   * @return The port number
   */
  int actualPort();

  /**
   * Close the server
   * @return Future that completes when server is closed
   */
  Future<Void> close();

  /**
   * Update SSL options (for servers with SSL enabled)
   * @param options New SSL options
   * @return Future that completes when updated
   */
  Future<Void> updateSSLOptions(SSLOptions options);
}

/**
 * Create a TCP client with default options
 * @return NetClient instance
 */
NetClient createNetClient();

/**
 * Create a TCP client with custom options
 * @param options Client configuration options
 * @return NetClient instance
 */
NetClient createNetClient(NetClientOptions options);

/**
 * TCP Client interface for making connections
 */
interface NetClient extends Measured, Closeable {
  /**
   * Connect to a server
   * @param port Target port
   * @param host Target host
   * @return Future that completes with NetSocket
   */
  Future<NetSocket> connect(int port, String host);

  /**
   * Connect to a server with connect handler
   * @param port Target port
   * @param host Target host
   * @param connectHandler Handler called when connected
   * @return this for chaining
   */
  NetClient connect(int port, String host, Handler<AsyncResult<NetSocket>> connectHandler);

  /**
   * Connect to a SocketAddress
   * @param remoteAddress Address to connect to
   * @return Future that completes with NetSocket
   */
  Future<NetSocket> connect(SocketAddress remoteAddress);

  /**
   * Connect to a SocketAddress from a local address
   * @param remoteAddress Remote address to connect to
   * @param localAddress Local address to bind to
   * @return Future that completes with NetSocket
   */
  Future<NetSocket> connect(SocketAddress remoteAddress, SocketAddress localAddress);

  /**
   * Close the client
   * @return Future that completes when client is closed
   */
  Future<Void> close();

  /**
   * Update SSL options (for clients with SSL enabled)
   * @param options New SSL options
   * @return Future that completes when updated
   */
  Future<Void> updateSSLOptions(SSLOptions options);
}

/**
 * TCP socket connection for data transfer
 */
interface NetSocket extends ReadStream<Buffer>, WriteStream<Buffer> {
  /**
   * Get the write handler ID for event bus integration
   * @return Write handler ID
   */
  String writeHandlerID();

  /**
   * Write data to the socket
   * @param data Data to write
   * @return Future that completes when written
   */
  Future<Void> write(Buffer data);

  /**
   * Write string to the socket
   * @param str String to write
   * @return Future that completes when written
   */
  Future<Void> write(String str);

  /**
   * Write string with encoding to the socket
   * @param str String to write
   * @param enc Character encoding
   * @return Future that completes when written
   */
  Future<Void> write(String str, String enc);

  /**
   * Close the socket
   * @return Future that completes when closed
   */
  Future<Void> close();

  /**
   * Set close handler
   * @param handler Handler called when socket is closed
   * @return this for chaining
   */
  NetSocket closeHandler(Handler<Void> handler);

  /**
   * Get remote address
   * @return Remote socket address
   */
  SocketAddress remoteAddress();

  /**
   * Get local address
   * @return Local socket address
   */
  SocketAddress localAddress();

  /**
   * Check if connection is SSL
   * @return true if SSL
   */
  boolean isSsl();

  /**
   * Get SSL session (if SSL)
   * @return SSL session or null
   */
  SSLSession sslSession();

  /**
   * Get indicated server name (SNI)
   * @return Server name or null
   */
  String indicatedServerName();

  /**
   * Get application layer protocol (ALPN)
   * @return Protocol name or null
   */
  String applicationLayerProtocol();

  /**
   * Upgrade connection to SSL
   * @return Future that completes when upgraded
   */
  Future<Void> upgradeToSsl();

  /**
   * Upgrade connection to SSL with server name
   * @param serverName Server name for SNI
   * @return Future that completes when upgraded
   */
  Future<Void> upgradeToSsl(String serverName);

  /**
   * Shutdown the socket for writing
   * @return Future that completes when shutdown
   */
  Future<Void> shutdown();

  /**
   * Shutdown the socket with timeout
   * @param timeout Timeout in milliseconds
   * @return Future that completes when shutdown or timeout
   */
  Future<Void> shutdown(long timeout);
}

/**
 * Network socket address abstraction
 */
interface SocketAddress {
  /**
   * Get the host name
   * @return Host name
   */
  String host();

  /**
   * Get the port number
   * @return Port number
   */
  int port();

  /**
   * Get the path (for domain sockets)
   * @return Path string
   */
  String path();

  /**
   * Check if this is a domain socket address
   * @return true if domain socket
   */
  boolean isDomainSocket();

  /**
   * Check if this is an Internet socket address
   * @return true if Internet socket
   */
  boolean isInetSocket();

  /**
   * Convert to InetSocketAddress
   * @return InetSocketAddress
   */
  InetSocketAddress inetSocketAddress();

  /**
   * Convert to DomainSocketAddress
   * @return DomainSocketAddress
   */
  DomainSocketAddress domainSocketAddress();

  // Static factory methods
  static SocketAddress inetSocketAddress(int port, String host);
  static SocketAddress domainSocketAddress(String path);
}

/**
 * Base SSL configuration options
 */
class SSLOptions {
  SSLOptions setSsl(boolean ssl);
  SSLOptions setKeyCertOptions(KeyCertOptions keyCertOptions);
  SSLOptions setTrustOptions(TrustOptions trustOptions);
  SSLOptions addEnabledCipherSuite(String suite);
  SSLOptions addEnabledSecureTransportProtocol(String protocol);
  SSLOptions setUseAlpn(boolean useAlpn);
  SSLOptions setSslHandshakeTimeout(long sslHandshakeTimeout);
  SSLOptions setSslHandshakeTimeoutUnit(TimeUnit sslHandshakeTimeoutUnit);
}

/**
 * Interface for key certificate options
 */
interface KeyCertOptions extends ClusterSerializable {
  KeyCertOptions copy();
  KeyManagerFactory getKeyManagerFactory(Vertx vertx);
  Function<String, X509Certificate[]> certificateChainFunction(Vertx vertx);
  Function<String, PrivateKey> privateKeyFunction(Vertx vertx);
}

/**
 * Interface for trust options
 */
interface TrustOptions extends ClusterSerializable {
  TrustOptions copy();
  TrustManagerFactory getTrustManagerFactory(Vertx vertx);
  Function<String, X509Certificate[]> certificateChainFunction(Vertx vertx);
}

/**
 * Java KeyStore options
 */
class JksOptions implements KeyCertOptions, TrustOptions {
  JksOptions setPath(String path);
  JksOptions setPassword(String password);
  JksOptions setValue(Buffer value);
}

/**
 * PKCS#12 options
 */
class PfxOptions implements KeyCertOptions, TrustOptions {
  PfxOptions setPath(String path);
  PfxOptions setPassword(String password);
  PfxOptions setValue(Buffer value);
}

/**
 * PEM format key certificate options
 */
class PemKeyCertOptions implements KeyCertOptions {
  PemKeyCertOptions setCertPath(String certPath);
  PemKeyCertOptions setCertPaths(List<String> certPaths);
  PemKeyCertOptions setCertValues(List<Buffer> certValues);
  PemKeyCertOptions setKeyPath(String keyPath);
  PemKeyCertOptions setKeyPaths(List<String> keyPaths);
  PemKeyCertOptions setKeyValues(List<Buffer> keyValues);
}

/**
 * PEM format trust options
 */
class PemTrustOptions implements TrustOptions {
  PemTrustOptions setCertPaths(List<String> certPaths);
  PemTrustOptions setCertValues(List<Buffer> certValues);
}

/**
 * Proxy configuration options
 */
class ProxyOptions {
  ProxyOptions setType(ProxyType type);
  ProxyOptions setHost(String host);
  ProxyOptions setPort(int port);
  ProxyOptions setUsername(String username);
  ProxyOptions setPassword(String password);
}

/**
 * Types of proxy servers
 */
enum ProxyType {
  HTTP,    // HTTP proxy
  SOCKS4,  // SOCKS4 proxy
  SOCKS5   // SOCKS5 proxy
}

/**
 * TCP Server configuration options
 */
class NetServerOptions extends TCPSSLOptions {
  NetServerOptions setPort(int port);
  NetServerOptions setHost(String host);
  NetServerOptions setBacklog(int backlog);
  NetServerOptions setRegisterWriteHandler(boolean registerWriteHandler);
  NetServerOptions setClientAuth(ClientAuth clientAuth);
  NetServerOptions setSni(boolean sni);
  NetServerOptions setUseProxyProtocol(boolean useProxyProtocol);
  NetServerOptions setProxyProtocolTimeout(long proxyProtocolTimeout);
  NetServerOptions setProxyProtocolTimeoutUnit(TimeUnit proxyProtocolTimeoutUnit);
}

/**
 * TCP Client configuration options
 */
class NetClientOptions extends TCPSSLOptions {
  NetClientOptions setReconnectAttempts(int attempts);
  NetClientOptions setReconnectInterval(long interval);
  NetClientOptions setHostnameVerificationAlgorithm(String hostnameVerificationAlgorithm);
  NetClientOptions addApplicationLayerProtocol(String protocol);
  NetClientOptions setApplicationLayerProtocols(List<String> protocols);
  NetClientOptions setRegisterWriteHandler(boolean registerWriteHandler);
  NetClientOptions setNonProxyHosts(List<String> nonProxyHosts);
  NetClientOptions setProxyOptions(ProxyOptions proxyOptions);
}

/**
 * Base TCP and SSL options
 */
class TCPSSLOptions extends NetworkOptions {
  TCPSSLOptions setTcpNoDelay(boolean tcpNoDelay);
  TCPSSLOptions setTcpKeepAlive(boolean tcpKeepAlive);
  TCPSSLOptions setSoLinger(int soLinger);
  TCPSSLOptions setIdleTimeout(int idleTimeout);
  TCPSSLOptions setIdleTimeoutUnit(TimeUnit idleTimeoutUnit);
  TCPSSLOptions setReadIdleTimeout(int idleTimeout);
  TCPSSLOptions setWriteIdleTimeout(int idleTimeout);
  TCPSSLOptions setSsl(boolean ssl);
  TCPSSLOptions setKeyCertOptions(KeyCertOptions options);
  TCPSSLOptions setTrustOptions(TrustOptions options);
  TCPSSLOptions addEnabledCipherSuite(String suite);
  TCPSSLOptions addEnabledSecureTransportProtocol(String protocol);
  TCPSSLOptions setUseAlpn(boolean useAlpn);
  TCPSSLOptions setSslHandshakeTimeout(long timeout);
  TCPSSLOptions setSslHandshakeTimeoutUnit(TimeUnit timeoutUnit);
}

/**
 * Base network options
 */
class NetworkOptions {
  NetworkOptions setSendBufferSize(int sendBufferSize);
  NetworkOptions setReceiveBufferSize(int receiveBufferSize);
  NetworkOptions setReuseAddress(boolean reuseAddress);
  NetworkOptions setReusePort(boolean reusePort);
  NetworkOptions setTrafficClass(int trafficClass);
  NetworkOptions setTcpNoDelay(boolean tcpNoDelay);
  NetworkOptions setTcpKeepAlive(boolean tcpKeepAlive);
  NetworkOptions setSoLinger(int soLinger);
  NetworkOptions setTcpUserTimeout(int tcpUserTimeout);
  NetworkOptions setTcpFastOpen(boolean tcpFastOpen);
  NetworkOptions setTcpCork(boolean tcpCork);
  NetworkOptions setTcpQuickAck(boolean tcpQuickAck);
}

/**
 * Client authentication modes for SSL
 */
enum ClientAuth {
  NONE,     // No client authentication
  REQUEST,  // Request client authentication
  REQUIRED  // Require client authentication
}

import io.vertx.core.Vertx;
import io.vertx.core.net.NetServer;
import io.vertx.core.net.NetSocket;

Vertx vertx = Vertx.vertx();
NetServer server = vertx.createNetServer();

server.connectHandler(socket -> {
  System.out.println("Client connected: " + socket.remoteAddress());
  
  socket.handler(buffer -> {
    System.out.println("Received: " + buffer.toString());
    // Echo back to client
    socket.write("Echo: " + buffer.toString());
  });
  
  socket.closeHandler(v -> {
    System.out.println("Client disconnected");
  });
});

server.listen(8080).onSuccess(server -> {
  System.out.println("TCP server started on port 8080");
});

import io.vertx.core.net.NetClient;

NetClient client = vertx.createNetClient();

client.connect(8080, "localhost").onSuccess(socket -> {
  System.out.println("Connected to server");
  
  // Send data
  socket.write("Hello Server!");
  
  // Handle response
  socket.handler(buffer -> {
    System.out.println("Server response: " + buffer.toString());
  });
  
  socket.closeHandler(v -> {
    System.out.println("Connection closed");
  });
}).onFailure(err -> {
  System.err.println("Failed to connect: " + err.getMessage());
});

import io.vertx.core.net.NetServerOptions;
import io.vertx.core.net.PemKeyCertOptions;

NetServerOptions options = new NetServerOptions()
  .setSsl(true)
  .setKeyCertOptions(new PemKeyCertOptions()
    .setKeyPath("server-key.pem")
    .setCertPath("server-cert.pem"))
  .setPort(8443);

NetServer server = vertx.createNetServer(options);

server.connectHandler(socket -> {
  System.out.println("SSL client connected: " + socket.remoteAddress());
  System.out.println("SSL session: " + socket.sslSession());
});

server.listen();

import io.vertx.core.net.NetClientOptions;
import io.vertx.core.net.ProxyOptions;
import io.vertx.core.net.ProxyType;

NetClientOptions options = new NetClientOptions()
  .setProxyOptions(new ProxyOptions()
    .setType(ProxyType.HTTP)
    .setHost("proxy.example.com")
    .setPort(8080)
    .setUsername("user")
    .setPassword("pass"));

NetClient client = vertx.createNetClient(options);

client.connect(80, "example.com").onSuccess(socket -> {
  System.out.println("Connected through proxy");
  socket.write("GET / HTTP/1.1\r\nHost: example.com\r\n\r\n");
});

/**
 * Create a DNS client with default options (uses system DNS configuration)
 * @return DnsClient instance
 */
DnsClient createDnsClient();

/**
 * Create a DNS client connecting to a specific DNS server
 * @param port DNS server port
 * @param host DNS server host address
 * @return DnsClient instance
 */
DnsClient createDnsClient(int port, String host);

/**
 * Create a DNS client with custom options
 * @param options DNS client configuration
 * @return DnsClient instance
 */
DnsClient createDnsClient(DnsClientOptions options);

/**
 * DNS Client interface for asynchronous DNS operations
 */
interface DnsClient {
  // Basic address resolution
  Future<String> lookup(String name);
  Future<String> lookup4(String name);
  Future<String> lookup6(String name);
  
  // Multi-record resolution
  Future<List<String>> resolveA(String name);
  Future<List<String>> resolveAAAA(String name);
  Future<List<String>> resolveCNAME(String name);
  Future<List<String>> resolveTXT(String name);
  Future<List<String>> resolveNS(String name);
  Future<String> resolvePTR(String name);
  
  // Structured record types
  Future<List<MxRecord>> resolveMX(String name);
  Future<List<SrvRecord>> resolveSRV(String name);
  
  // Reverse DNS lookup
  Future<String> reverseLookup(String ipaddress);
  
  // Client management
  Future<Void> close();
}

/**
 * Mail Exchange record
 */
interface MxRecord {
  int priority();
  String name();
}

/**
 * Service record
 */
interface SrvRecord {
  int priority();
  int weight();
  int port();
  String name();
  String protocol();
  String service();
  String target();
}

/**
 * DNS client configuration options
 */
class DnsClientOptions {
  DnsClientOptions setPort(int port);
  DnsClientOptions setHost(String host);
  DnsClientOptions setQueryTimeout(long queryTimeout);
  DnsClientOptions setLogActivity(boolean logActivity);
  DnsClientOptions setRecursionDesired(boolean recursionDesired);
}

/**
 * Create a datagram socket with default options
 * @return DatagramSocket instance
 */
DatagramSocket createDatagramSocket();

/**
 * Create a datagram socket with custom options
 * @param options Datagram socket configuration
 * @return DatagramSocket instance
 */
DatagramSocket createDatagramSocket(DatagramSocketOptions options);

/**
 * Datagram Socket interface for UDP communication
 */
interface DatagramSocket extends Measured, Closeable {
  /**
   * Send a packet to a remote address
   * @param packet Buffer containing packet data
   * @param port Destination port
   * @param host Destination host
   * @return Future that completes when packet is sent
   */
  Future<DatagramSocket> send(Buffer packet, int port, String host);
  
  /**
   * Send a packet to a socket address
   * @param packet Buffer containing packet data
   * @param recipient Destination socket address
   * @return Future that completes when packet is sent
   */
  Future<DatagramSocket> send(Buffer packet, SocketAddress recipient);
  
  /**
   * Send a string as packet data
   * @param str String to send
   * @param port Destination port
   * @param host Destination host
   * @return Future that completes when packet is sent
   */
  Future<DatagramSocket> send(String str, int port, String host);
  
  /**
   * Send a string to a socket address
   * @param str String to send
   * @param recipient Destination socket address
   * @return Future that completes when packet is sent
   */
  Future<DatagramSocket> send(String str, SocketAddress recipient);
  
  /**
   * Bind socket to listen on a port
   * @param port Port to bind to
   * @param host Host to bind to
   * @return Future that completes when socket is bound
   */
  Future<DatagramSocket> listen(int port, String host);
  
  /**
   * Set handler for incoming packets
   * @param handler Handler for received packets
   * @return this for chaining
   */
  DatagramSocket handler(Handler<DatagramPacket> handler);
  
  /**
   * Set exception handler
   * @param handler Exception handler
   * @return this for chaining
   */
  DatagramSocket exceptionHandler(Handler<Throwable> handler);
  
  /**
   * Get local socket address
   * @return Local socket address or null if not bound
   */
  SocketAddress localAddress();
  
  /**
   * Close the socket
   * @return Future that completes when socket is closed
   */
  Future<Void> close();
}

/**
 * Represents a datagram packet
 */
interface DatagramPacket {
  /**
   * Get sender address
   * @return Sender socket address
   */
  SocketAddress sender();
  
  /**
   * Get packet data
   * @return Buffer containing packet data
   */
  Buffer data();
}

/**
 * Datagram socket configuration options
 */
class DatagramSocketOptions {
  DatagramSocketOptions setSendBufferSize(int sendBufferSize);
  DatagramSocketOptions setReceiveBufferSize(int receiveBufferSize);
  DatagramSocketOptions setReuseAddress(boolean reuseAddress);
  DatagramSocketOptions setReusePort(boolean reusePort);
  DatagramSocketOptions setBroadcast(boolean broadcast);
  DatagramSocketOptions setMulticastNetworkInterface(String iface);
  DatagramSocketOptions setMulticastTimeToLive(int ttl);
  DatagramSocketOptions setLogActivity(boolean logActivity);
}

import io.vertx.core.dns.DnsClient;

DnsClient client = vertx.createDnsClient();

client.lookup("example.com").onComplete(ar -> {
  if (ar.succeeded()) {
    String ip = ar.result();
    System.out.println("Resolved IP: " + ip);
  } else {
    System.err.println("DNS lookup failed: " + ar.cause());
  }
});

import io.vertx.core.dns.DnsClientOptions;

DnsClient client = vertx.createDnsClient(new DnsClientOptions()
  .setHost("8.8.8.8")
  .setPort(53)
  .setQueryTimeout(10000));

client.resolveMX("example.com").onSuccess(mxRecords -> {
  for (MxRecord mx : mxRecords) {
    System.out.println("MX: " + mx.name() + " (priority: " + mx.priority() + ")");
  }
});

import io.vertx.core.datagram.DatagramSocket;
import io.vertx.core.datagram.DatagramSocketOptions;

// Create UDP server
DatagramSocket server = vertx.createDatagramSocket(new DatagramSocketOptions()
  .setReuseAddress(true));

server.handler(packet -> {
  System.out.println("Received from " + packet.sender() + ": " + packet.data().toString());
  
  // Echo back to sender
  server.send(packet.data(), packet.sender());
});

server.listen(1234, "localhost").onSuccess(socket -> {
  System.out.println("UDP server listening on " + socket.localAddress());
});

// Create UDP client
DatagramSocket client = vertx.createDatagramSocket();

client.send("Hello UDP!", 1234, "localhost").onSuccess(v -> {
  System.out.println("UDP packet sent");
});