Server Component

public class ServerTcpProtocl {
    private DatagramSocket connectionSocket;  // Main listening socket
    private static HashMap<InetAddress, DatagramSocket> socketMapping;  // Per-client sockets
    private static String directory;          // Server root directory
    private static boolean verbose;           // Logging flag
    
    private static int lastackRec = 0;        // Last acknowledged packet
    private static int windowRec = 100;       // Sliding window size
    private static List<DatagramPacket> packets = new ArrayList<>();
    
    public ServerTcpProtocl(int port, String directory, boolean verbose)
    public void handShake() throws IOException
    public static class clientHandler implements Runnable
}

public ServerTcpProtocl(int port, String directory, boolean verbose) throws IOException {
    this.connectionSocket = new DatagramSocket(port);
    socketMapping = new HashMap<>();
    ServerTcpProtocl.directory = directory;
    ServerTcpProtocl.verbose = verbose;
    handShake();  // Start listening for connections
}

public String getRequestFromPacket(DatagramSocket socket, int totalPackets) {
    int expseqNum = 2;        // Expected sequence number (starting after packet count)
    int maxWindow = 100;       // Maximum window size
    HashMap<Integer, byte[]> data = new HashMap<>();  // Buffer for out-of-order packets
    
    while (expseqNum <= totalPackets) {
        DatagramPacket req = new DatagramPacket(new byte[1024], 1024);
        socket.receive(req);
        Packet p = Packet.fromBytes(req.getData());
        int pSeq = (int) p.getSequenceNumber();
        
        if (pSeq <= maxWindow) {  // Within window
            if (pSeq == expseqNum) {
                // In-order packet
                data.put(expseqNum, p.getPayload());
                
                // Check for consecutive packets in buffer
                for (int i = expseqNum; i <= totalPackets; i++) {
                    if (data.containsKey(i)) {
                        expseqNum++;
                        maxWindow++;
                    } else {
                        // Send cumulative ACK
                        Packet ack = new Packet(1, i-1, clientAddress, clientPort, new byte[0]);
                        socket.send(new DatagramPacket(ack.toBytes(), ack.toBytes().length, 
                                                       rAddress, rPort));
                        break;
                    }
                }
            } 
            else if (pSeq > expseqNum) {
                // Out-of-order packet (future packet)
                data.put(pSeq, p.getPayload());
                
                // Send NACK for missing packets
                for (int i = expseqNum; i < pSeq; i++) {
                    if (!data.containsKey(i)) {
                        Packet nack = new Packet(4, i, clientAddress, clientPort, new byte[0]);
                        socket.send(new DatagramPacket(nack.toBytes(), nack.toBytes().length,
                                                       rAddress, rPort));
                    }
                }
            }
            else if (pSeq < expseqNum) {
                // Duplicate packet (already received)
                Packet ack = new Packet(1, pSeq, clientAddress, clientPort, new byte[0]);
                socket.send(new DatagramPacket(ack.toBytes(), ack.toBytes().length,
                                               rAddress, rPort));
            }
        }
    }
    
    // Reassemble data from chunks
    byte[] reqArr = new byte[(totalPackets - 1) * 1013];
    int k = 0;
    for (int i = 2; i <= totalPackets; i++) {
        byte[] tmp = data.get(i);
        for (int j = 0; j < tmp.length; j++) {
            reqArr[k++] = tmp[j];
        }
    }
    
    return new String(reqArr).trim();
}

static boolean checkPath(String path, String dir) throws IOException {
    File f = new File(String.valueOf(Paths.get(dir + path)));
    String c = f.getCanonicalPath();  // Resolve .. and symlinks
    
    File f1 = new File(dir);
    String d = f1.getCanonicalPath();
    
    // Ensure requested path is within server directory
    if (c.startsWith(d)) {
        return true;
    } else {
        return false;  // Block access outside root directory
    }
}

String headers = "Httfc/1.0 " + code + " " + status + System.lineSeparator() +
                 "Date :" + java.time.LocalDate.now() + System.lineSeparator() +
                 "Server : Httpfc/1.0.0" + System.lineSeparator() +
                 "Content-Length: " + data.length() + System.lineSeparator() +
                 "Connection: Closed" + System.lineSeparator() +
                 "Content-type: Application/text";

return headers + "\n\n" + data;

public static void main(String[] args) throws IOException {
    ServerTcpProtocl server = new ServerTcpProtocl(
        8000,       // Listen on port 8000
        "./data",   // Serve files from ./data directory
        true        // Enable verbose logging
    );
    // Server runs indefinitely, handling client connections
}