ServerSocketChannel

public abstract class ServerSocketChannel
    extends AbstractSelectableChannel
    implements NetworkChannel {
    
    protected ServerSocketChannel(SelectorProvider provider) {
        super(provider);
    }
    
    // Factory methods
    public static ServerSocketChannel open() throws IOException {
        return SelectorProvider.provider().openServerSocketChannel();
    }
    
    public static ServerSocketChannel open(ProtocolFamily family) throws IOException {
        return SelectorProvider.provider().openServerSocketChannel(family);
    }
    
    // Valid operations (only OP_ACCEPT)
    public final int validOps() {
        return SelectionKey.OP_ACCEPT;
    }
    
    // Binding and configuration
    public abstract ServerSocketChannel bind(SocketAddress local, int backlog) throws IOException;
    public abstract ServerSocketChannel bind(SocketAddress local) throws IOException;
    
    // Socket options
    public abstract <T> ServerSocketChannel setOption(SocketOption<T> name, T value) throws IOException;
    
    // Accept connections
    public abstract SocketChannel accept() throws IOException;
    
    // Address information
    public abstract SocketAddress getLocalAddress() throws IOException;
    
    // Legacy socket adapter
    public abstract ServerSocket socket();
}

class ServerSocketChannelImpl extends ServerSocketChannel implements SelChImpl {
    private final ProtocolFamily family;  // INET, INET6, or UNIX
    private final FileDescriptor fd;      // Underlying OS file descriptor
    private final int fdVal;             // Integer FD value for native calls
    
    // Dual-lock synchronization strategy
    private final ReentrantLock acceptLock = new ReentrantLock(); // For accept operations
    private final Object stateLock = new Object();                // For state management
    
    // Channel state machine
    private static final int ST_INUSE = 0;    // Channel open and in use
    private static final int ST_CLOSING = 1;  // Channel closing in progress
    private static final int ST_CLOSED = 2;   // Channel closed
    private int state;                        // Current state
    
    // Thread currently blocked in accept()
    private Thread thread;
    
    // Local address (null if unbound)
    private SocketAddress localAddress;
    
    // Virtual thread integration
    private volatile boolean forcedNonBlocking;
    
    // Legacy socket adapter cache
    private ServerSocket socket;
}

// Basic TCP server on port 8080
try (ServerSocketChannel serverChannel = ServerSocketChannel.open()) {
    // Bind to port 8080 on all interfaces
    serverChannel.bind(new InetSocketAddress(8080));
    
    // Set socket options
    serverChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
    serverChannel.setOption(StandardSocketOptions.SO_RCVBUF, 64 * 1024);
    
    System.out.println("Server listening on " + serverChannel.getLocalAddress());
    
    // Accept connections
    while (true) {
        SocketChannel clientChannel = serverChannel.accept();
        // Handle client connection
        handleClient(clientChannel);
    }
}

// Unix Domain Socket server
try (ServerSocketChannel serverChannel = ServerSocketChannel.open(StandardProtocolFamily.UNIX)) {
    UnixDomainSocketAddress address = UnixDomainSocketAddress.of("/tmp/myserver.sock");
    serverChannel.bind(address);
    
    System.out.println("Unix domain server listening on " + serverChannel.getLocalAddress());
    
    // Accept Unix domain connections
    SocketChannel clientChannel = serverChannel.accept();
    // Handle client
}

// Bind with specific backlog (maximum pending connections)
try (ServerSocketChannel serverChannel = ServerSocketChannel.open()) {
    // Bind to port 8080 with backlog of 100
    serverChannel.bind(new InetSocketAddress(8080), 100);
    
    // Get actual bound address (useful when binding to port 0 for ephemeral port)
    SocketAddress boundAddress = serverChannel.getLocalAddress();
    if (boundAddress instanceof InetSocketAddress) {
        InetSocketAddress inetAddress = (InetSocketAddress) boundAddress;
        System.out.println("Server bound to " + inetAddress.getHostString() + 
                          ":" + inetAddress.getPort());
    }
}

// Bind to specific network interface
try (ServerSocketChannel serverChannel = ServerSocketChannel.open()) {
    // Bind to specific IP address
    InetAddress localIp = InetAddress.getByName("192.168.1.100");
    serverChannel.bind(new InetSocketAddress(localIp, 8080), 50);
    
    // Or bind to all IPv4 addresses
    serverChannel.bind(new InetSocketAddress("0.0.0.0", 8080));
    
    // Or bind to all IPv6 addresses
    serverChannel.bind(new InetSocketAddress("::", 8080));
}

// Simple blocking server
try (ServerSocketChannel serverChannel = ServerSocketChannel.open()) {
    serverChannel.bind(new InetSocketAddress(8080));
    
    System.out.println("Waiting for connections...");
    
    while (true) {
        // accept() blocks until a connection arrives
        SocketChannel clientChannel = serverChannel.accept();
        
        // Get client information
        SocketAddress clientAddress = clientChannel.getRemoteAddress();
        System.out.println("Accepted connection from " + clientAddress);
        
        // Handle client in separate thread
        new Thread(() -> handleClient(clientChannel)).start();
    }
}

// Blocking server with timeout using legacy socket adapter
try (ServerSocketChannel serverChannel = ServerSocketChannel.open()) {
    serverChannel.bind(new InetSocketAddress(8080));
    
    // Get legacy ServerSocket adapter for timeout support
    ServerSocket serverSocket = serverChannel.socket();
    serverSocket.setSoTimeout(5000); // 5 second accept timeout
    
    while (true) {
        try {
            SocketChannel clientChannel = serverChannel.accept();
            handleClient(clientChannel);
        } catch (SocketTimeoutException e) {
            // Accept timed out, check for shutdown condition
            if (shouldShutdown) {
                break;
            }
            // Continue waiting
        }
    }
}

// Scalable non-blocking server using selector
try (ServerSocketChannel serverChannel = ServerSocketChannel.open();
     Selector selector = Selector.open()) {
    
    serverChannel.configureBlocking(false);
    serverChannel.bind(new InetSocketAddress(8080));
    
    // Register for accept events
    serverChannel.register(selector, SelectionKey.OP_ACCEPT);
    
    System.out.println("Non-blocking server ready");
    
    while (true) {
        // Wait for events
        selector.select();
        
        Set<SelectionKey> selectedKeys = selector.selectedKeys();
        Iterator<SelectionKey> iter = selectedKeys.iterator();
        
        while (iter.hasNext()) {
            SelectionKey key = iter.next();
            iter.remove();
            
            if (key.isAcceptable()) {
                // Accept the connection
                ServerSocketChannel server = (ServerSocketChannel) key.channel();
                SocketChannel clientChannel = server.accept();
                
                if (clientChannel != null) {
                    // Configure client channel
                    clientChannel.configureBlocking(false);
                    
                    // Register for read events
                    clientChannel.register(selector, SelectionKey.OP_READ);
                    
                    System.out.println("Accepted connection from " + 
                                      clientChannel.getRemoteAddress());
                }
            }
            
            if (key.isReadable()) {
                // Handle client data
                SocketChannel clientChannel = (SocketChannel) key.channel();
                handleClientData(clientChannel);
            }
        }
    }
}

// Server using virtual threads for connection handling
try (ServerSocketChannel serverChannel = ServerSocketChannel.open();
     var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    
    serverChannel.bind(new InetSocketAddress(8080));
    
    System.out.println("Virtual thread server ready");
    
    while (true) {
        // accept() yields virtual thread if no connection pending
        SocketChannel clientChannel = serverChannel.accept();
        
        // Submit client handling to virtual thread
        executor.submit(() -> {
            try (clientChannel) {
                handleClient(clientChannel);
            } catch (IOException e) {
                System.err.println("Client handling error: " + e.getMessage());
            }
        });
    }
}

// Mixed mode: non-blocking accept with virtual thread workers
try (ServerSocketChannel serverChannel = ServerSocketChannel.open();
     Selector selector = Selector.open();
     var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    
    serverChannel.configureBlocking(false);
    serverChannel.bind(new InetSocketAddress(8080));
    serverChannel.register(selector, SelectionKey.OP_ACCEPT);
    
    while (true) {
        selector.select();
        
        Set<SelectionKey> selectedKeys = selector.selectedKeys();
        for (SelectionKey key : selectedKeys) {
            if (key.isAcceptable()) {
                ServerSocketChannel server = (ServerSocketChannel) key.channel();
                SocketChannel clientChannel = server.accept();
                
                if (clientChannel != null) {
                    // Submit to virtual thread pool
                    executor.submit(() -> handleClient(clientChannel));
                }
            }
        }
        selectedKeys.clear();
    }
}

// Configure server socket options
try (ServerSocketChannel serverChannel = ServerSocketChannel.open()) {
    // Enable address reuse (allows quick restart)
    serverChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
    
    // Enable port reuse (Linux only, for multiple listeners on same port)
    try {
        serverChannel.setOption(StandardSocketOptions.SO_REUSEPORT, true);
    } catch (UnsupportedOperationException e) {
        // Option not supported on this platform
    }
    
    // Set receive buffer size
    serverChannel.setOption(StandardSocketOptions.SO_RCVBUF, 128 * 1024);
    
    // Set IP Type of Service (TOS) for accepted connections
    serverChannel.setOption(StandardSocketOptions.IP_TOS, 0x10); // Low delay
    
    // Bind after configuration
    serverChannel.bind(new InetSocketAddress(8080));
    
    // Read back option values
    boolean reuseAddr = serverChannel.getOption(StandardSocketOptions.SO_REUSEADDR);
    int rcvBuf = serverChannel.getOption(StandardSocketOptions.SO_RCVBUF);
    
    System.out.println("SO_REUSEADDR: " + reuseAddr + ", SO_RCVBUF: " + rcvBuf);
}

// Unix domain socket options
try (ServerSocketChannel serverChannel = ServerSocketChannel.open(StandardProtocolFamily.UNIX)) {
    // Unix domain sockets support fewer options
    serverChannel.setOption(StandardSocketOptions.SO_RCVBUF, 64 * 1024);
    
    UnixDomainSocketAddress address = UnixDomainSocketAddress.of("/tmp/server.sock");
    serverChannel.bind(address);
}

// Protocol family detection and selection
public static ServerSocketChannel createServerChannel(SocketAddress address) 
        throws IOException {
    if (address instanceof InetSocketAddress) {
        // Determine IP version preference
        String preferIPv4Stack = System.getProperty("java.net.preferIPv4Stack");
        String preferIPv6Addresses = System.getProperty("java.net.preferIPv6Addresses");
        
        if ("true".equals(preferIPv4Stack)) {
            // Force IPv4
            return ServerSocketChannel.open(StandardProtocolFamily.INET);
        } else if ("true".equals(preferIPv6Addresses)) {
            // Prefer IPv6
            return ServerSocketChannel.open(StandardProtocolFamily.INET6);
        } else {
            // System default (dual-stack where available)
            return ServerSocketChannel.open();
        }
    } else if (address instanceof UnixDomainSocketAddress) {
        return ServerSocketChannel.open(StandardProtocolFamily.UNIX);
    } else {
        throw new IllegalArgumentException("Unsupported address type");
    }
}

// Using specific protocol families
try (ServerSocketChannel serverChannel = ServerSocketChannel.open(StandardProtocolFamily.INET)) {
    // IPv4 only
    serverChannel.bind(new InetSocketAddress("0.0.0.0", 8080));
}

try (ServerSocketChannel serverChannel = ServerSocketChannel.open(StandardProtocolFamily.INET6)) {
    // IPv6 only
    serverChannel.bind(new InetSocketAddress("::", 8080));
}

public class ThreadPerConnectionServer {
    private final ExecutorService executor;
    private volatile boolean running = true;
    
    public ThreadPerConnectionServer(int threadPoolSize) {
        this.executor = Executors.newFixedThreadPool(threadPoolSize);
    }
    
    public void start(int port) throws IOException {
        try (ServerSocketChannel serverChannel = ServerSocketChannel.open()) {
            serverChannel.bind(new InetSocketAddress(port));
            
            System.out.println("Server started on port " + port);
            
            while (running) {
                SocketChannel clientChannel = serverChannel.accept();
                executor.submit(() -> handleConnection(clientChannel));
            }
        }
    }
    
    private void handleConnection(SocketChannel clientChannel) {
        try (clientChannel) {
            SocketAddress clientAddress = clientChannel.getRemoteAddress();
            System.out.println("Handling connection from " + clientAddress);
            
            // Simple echo server
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            while (clientChannel.read(buffer) != -1) {
                buffer.flip();
                clientChannel.write(buffer);
                buffer.clear();
            }
            
            System.out.println("Connection closed from " + clientAddress);
        } catch (IOException e) {
            System.err.println("Error handling connection: " + e.getMessage());
        }
    }
    
    public void stop() {
        running = false;
        executor.shutdown();
    }
}

public class ReactorServer {
    private final Selector selector;
    private final Map<SocketChannel, ClientSession> sessions;
    
    public ReactorServer() throws IOException {
        this.selector = Selector.open();
        this.sessions = new ConcurrentHashMap<>();
    }
    
    public void start(int port) throws IOException {
        try (ServerSocketChannel serverChannel = ServerSocketChannel.open()) {
            serverChannel.configureBlocking(false);
            serverChannel.bind(new InetSocketAddress(port));
            serverChannel.register(selector, SelectionKey.OP_ACCEPT);
            
            System.out.println("Reactor server started on port " + port);
            
            // Main reactor loop
            while (true) {
                selector.select();
                Set<SelectionKey> selectedKeys = selector.selectedKeys();
                
                for (SelectionKey key : selectedKeys) {
                    if (!key.isValid()) {
                        continue;
                    }
                    
                    if (key.isAcceptable()) {
                        acceptConnection(key);
                    } else if (key.isReadable()) {
                        readData(key);
                    } else if (key.isWritable()) {
                        writeData(key);
                    }
                }
                selectedKeys.clear();
            }
        }
    }
    
    private void acceptConnection(SelectionKey key) throws IOException {
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
        SocketChannel clientChannel = serverChannel.accept();
        
        if (clientChannel != null) {
            clientChannel.configureBlocking(false);
            
            // Register for read operations
            SelectionKey clientKey = clientChannel.register(selector, SelectionKey.OP_READ);
            
            // Create session for this client
            ClientSession session = new ClientSession(clientChannel);
            sessions.put(clientChannel, session);
            clientKey.attach(session);
            
            System.out.println("Accepted connection from " + 
                              clientChannel.getRemoteAddress());
        }
    }
    
    private void readData(SelectionKey key) throws IOException {
        SocketChannel clientChannel = (SocketChannel) key.channel();
        ClientSession session = (ClientSession) key.attachment();
        
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int bytesRead = clientChannel.read(buffer);
        
        if (bytesRead == -1) {
            // Connection closed
            closeConnection(clientChannel, key);
        } else if (bytesRead > 0) {
            buffer.flip();
            session.processInput(buffer);
            
            // If we have data to write, register for write ops too
            if (session.hasOutput()) {
                key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
            }
        }
    }
    
    private void writeData(SelectionKey key) throws IOException {
        SocketChannel clientChannel = (SocketChannel) key.channel();
        ClientSession session = (ClientSession) key.attachment();
        
        boolean wroteAll = session.writeOutput(clientChannel);
        
        if (wroteAll) {
            // No more data to write, only interested in reads
            key.interestOps(SelectionKey.OP_READ);
        }
    }
    
    private void closeConnection(SocketChannel clientChannel, SelectionKey key) {
        try {
            System.out.println("Connection closed from " + 
                              clientChannel.getRemoteAddress());
            sessions.remove(clientChannel);
            clientChannel.close();
            key.cancel();
        } catch (IOException e) {
            System.err.println("Error closing connection: " + e.getMessage());
        }
    }
    
    private static class ClientSession {
        // Session state management
    }
}

public class WorkerPoolServer {
    private final ExecutorService acceptPool;
    private final ExecutorService workerPool;
    private final BlockingQueue<SocketChannel> connectionQueue;
    private volatile boolean running = true;
    
    public WorkerPoolServer(int acceptThreads, int workerThreads, int queueSize) {
        this.acceptPool = Executors.newFixedThreadPool(acceptThreads);
        this.workerPool = Executors.newFixedThreadPool(workerThreads);
        this.connectionQueue = new ArrayBlockingQueue<>(queueSize);
    }
    
    public void start(int port) throws IOException {
        // Start acceptor threads
        for (int i = 0; i < 2; i++) {
            acceptPool.submit(() -> acceptConnections(port));
        }
        
        // Start worker threads
        for (int i = 0; i < 10; i++) {
            workerPool.submit(this::processConnections);
        }
    }
    
    private void acceptConnections(int port) {
        try (ServerSocketChannel serverChannel = ServerSocketChannel.open()) {
            serverChannel.bind(new InetSocketAddress(port));
            
            while (running) {
                SocketChannel clientChannel = serverChannel.accept();
                if (!connectionQueue.offer(clientChannel, 100, TimeUnit.MILLISECONDS)) {
                    // Queue full, reject connection
                    System.err.println("Queue full, rejecting connection");
                    clientChannel.close();
                }
            }
        } catch (Exception e) {
            System.err.println("Acceptor error: " + e.getMessage());
        }
    }
    
    private void processConnections() {
        while (running) {
            try {
                SocketChannel clientChannel = connectionQueue.poll(100, TimeUnit.MILLISECONDS);
                if (clientChannel != null) {
                    handleConnection(clientChannel);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            } catch (Exception e) {
                System.err.println("Worker error: " + e.getMessage());
            }
        }
    }
    
    private void handleConnection(SocketChannel clientChannel) {
        try (clientChannel) {
            // Process client request
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int bytesRead = clientChannel.read(buffer);
            
            while (bytesRead != -1) {
                buffer.flip();
                // Process request
                buffer.clear();
                bytesRead = clientChannel.read(buffer);
            }
        } catch (IOException e) {
            System.err.println("Connection handling error: " + e.getMessage());
        }
    }
    
    public void stop() {
        running = false;
        acceptPool.shutdown();
        workerPool.shutdown();
    }
}

public class UnixDomainServer {
    private final Path socketPath;
    
    public UnixDomainServer(Path socketPath) {
        this.socketPath = socketPath;
    }
    
    public void start() throws IOException {
        // Clean up any existing socket file
        Files.deleteIfExists(socketPath);
        
        try (ServerSocketChannel serverChannel = ServerSocketChannel.open(StandardProtocolFamily.UNIX)) {
            UnixDomainSocketAddress address = UnixDomainSocketAddress.of(socketPath);
            serverChannel.bind(address);
            
            System.out.println("Unix domain server listening on " + socketPath);
            
            // Set file permissions (Unix only)
            if (System.getProperty("os.name").toLowerCase().contains("linux") ||
                System.getProperty("os.name").toLowerCase().contains("mac")) {
                Files.setPosixFilePermissions(socketPath, 
                    EnumSet.of(PosixFilePermission.OWNER_READ,
                               PosixFilePermission.OWNER_WRITE,
                               PosixFilePermission.GROUP_READ,
                               PosixFilePermission.OTHERS_READ));
            }
            
            while (true) {
                SocketChannel clientChannel = serverChannel.accept();
                new Thread(() -> handleUnixClient(clientChannel)).start();
            }
        } finally {
            // Clean up socket file on exit
            Files.deleteIfExists(socketPath);
        }
    }
    
    private void handleUnixClient(SocketChannel clientChannel) {
        try (clientChannel) {
            // Unix domain sockets are much faster for local communication
            ByteBuffer buffer = ByteBuffer.allocate(8192);
            
            while (clientChannel.read(buffer) != -1) {
                buffer.flip();
                // Process IPC request
                processRequest(buffer);
                buffer.clear();
            }
        } catch (IOException e) {
            System.err.println("Unix domain client error: " + e.getMessage());
        }
    }
    
    // Unix domain client example
    public static void sendRequest(Path socketPath, ByteBuffer request) throws IOException {
        try (SocketChannel clientChannel = SocketChannel.open(StandardProtocolFamily.UNIX)) {
            UnixDomainSocketAddress address = UnixDomainSocketAddress.of(socketPath);
            clientChannel.connect(address);
            
            // Send request
            while (request.hasRemaining()) {
                clientChannel.write(request);
            }
            
            // Receive response
            ByteBuffer response = ByteBuffer.allocate(4096);
            clientChannel.read(response);
            response.flip();
            // Process response
        }
    }
}

// acceptLock - protects the accept() operation
private int accept() throws IOException {
    acceptLock.lock();  // Only one thread can accept at a time
    try {
        ensureOpen();
        // Perform accept operation
        return implAccept(fd, newfd, saa);
    } finally {
        acceptLock.unlock();
    }
}

// stateLock - protects channel state fields
private void updateState(int newState) {
    synchronized (stateLock) {
        // Update state machine
        this.state = newState;
        // Notify any waiters if needed
    }
}

// Automatic non-blocking configuration for virtual threads
private void configureSocketNonBlockingIfVirtualThread() throws IOException {
    assert acceptLock.isHeldByCurrentThread();
    if (!forcedNonBlocking && Thread.currentThread().isVirtual()) {
        synchronized (stateLock) {
            ensureOpen();
            IOUtil.configureBlocking(fd, false);  // Switch to non-blocking
            forcedNonBlocking = true;  // Cannot revert
        }
    }
}

// Called in accept() before blocking operations
public SocketChannel accept() throws IOException {
    acceptLock.lock();
    try {
        configureSocketNonBlockingIfVirtualThread();  // Auto-configure for VT
        // ... rest of accept logic
    } finally {
        acceptLock.unlock();
    }
}

// Channel state transitions
private static final int ST_INUSE = 0;    // Normal operation
private static final int ST_CLOSING = 1;  // Close initiated
private static final int ST_CLOSED = 2;   // Fully closed

// State transition methods
private void transitionToClosing() {
    synchronized (stateLock) {
        if (state == ST_INUSE) {
            state = ST_CLOSING;
        }
    }
}

private void transitionToClosed() {
    synchronized (stateLock) {
        state = ST_CLOSED;
    }
}

// State checking
private void ensureOpen() throws ClosedChannelException {
    synchronized (stateLock) {
        if (state >= ST_CLOSING) {
            throw new ClosedChannelException();
        }
    }
}

// Platform-specific accept implementation
private int implAccept(FileDescriptor ssfd, FileDescriptor newfd, SocketAddress[] saa)
    throws IOException {
    
    if (isNetSocket()) {
        // Internet socket acceptance
        InetSocketAddress[] isaa = new InetSocketAddress[1];
        int n = Net.accept(ssfd, newfd, isaa);
        if (n > 0) {
            saa[0] = isaa[0];
        }
        return n;
    } else {
        // Unix domain socket acceptance
        UnixDomainSocketAddress[] udsaa = new UnixDomainSocketAddress[1];
        int n = UnixDomainSockets.accept(ssfd, newfd, udsaa);
        if (n > 0) {
            saa[0] = udsaa[0];
        }
        return n;
    }
}

// Calculate optimal backlog based on expected connection rate
public static int calculateOptimalBacklog(int expectedConnectionsPerSecond, 
                                          double targetAcceptLatencyMs) {
    // Little's Law: L = λW
    // L = backlog size, λ = arrival rate, W = processing time
    double backlog = expectedConnectionsPerSecond * (targetAcceptLatencyMs / 1000.0);
    
    // Add safety margin
    backlog *= 1.5;
    
    // Clamp to reasonable bounds
    return (int) Math.min(Math.max(backlog, 50), 1000);
}

// Usage
int backlog = calculateOptimalBacklog(1000, 10.0); // 1000 req/sec, 10ms latency
serverChannel.bind(address, backlog);