feat(udp): add DatagramClient and Datagram Server with robust example and full design notes

What
- Added two UDP example programs under package `imrovedversion`:
  1. `DatagramClient` — a simple, single-shot UDP client that sends a text message ("Hello Server") to localhost:2000, waits for a response, prints it, and then closes the socket.
  2. `Server` — a long-running UDP server that listens on port 2000, receives datagrams, reverses the received text, and replies to the sender with the reversed string.

Why
- Provide a minimal, real-world UDP example to demonstrate:
  - DatagramSocket/DatagramPacket usage.
  - Blocking receive semantics for UDP.
  - Bi-directional request/response pattern over UDP.
  - Practical considerations (buffer sizing, trimming packet data, resource closing).
- Helpful for networking lessons, demos, and quick experiments with unreliable, connectionless protocols.

How (overview)
- Client:
  - Creates an unbound DatagramSocket (OS assigns an ephemeral port).
  - Encodes outgoing message to bytes with default platform charset.
  - Sends DatagramPacket to server address `localhost:2000`.
  - Allocates a fixed-size receive buffer (1024 bytes) and blocks on `receive()` until a response arrives.
  - Converts received bytes into a String using `new String(byte[], 0, length)` to avoid trailing zeros.
  - Closes socket.

- Server:
  - Opens a DatagramSocket bound to port 2000.
  - Runs an infinite loop calling `receive()` on a reusable buffer (1024 bytes).
  - Builds a `String` from the received packet using the packet length (avoids junk bytes).
  - Applies a simple processing step (reverse string).
  - Sends back the processed result to the sender's address and port from the received packet.
  - Continues listening (no explicit shutdown in current code).

Detailed implementation notes / rationale
- Buffer sizing:
  - Both client and server use a 1024-byte receive buffer. This is a safe default for small text messages, but for larger payloads you should increase the buffer or implement fragmentation and reassembly at the application level.
- Trimming / packet length:
  - Convert received bytes with `new String(packet.getData(), 0, packet.getLength())` — this is essential because `getData()` returns the entire backing array which may be larger than the actual data.
- Character encoding:
  - Current code uses platform default encoding (`getBytes()` / `new String(byte[])`). For determinism and portability, prefer specifying `StandardCharsets.UTF_8` (e.g., `msg.getBytes(StandardCharsets.UTF_8)` and `new String(..., StandardCharsets.UTF_8)`).
- Blocking semantics & timeouts:
  - `ds.receive()` is blocking. If you expect long waits or want to terminate gracefully, consider `ds.setSoTimeout(timeoutMillis)` and handle `SocketTimeoutException`.
- Concurrency:
  - The server is single-threaded and sequentially handles requests. For higher throughput, consider dispatching processing to a worker thread pool (be mindful of reply ordering and packet sizes).
- Resource management:
  - Client closes its socket when done. Server currently runs forever and does not call `close()` — add shutdown handling if embedding in a larger application (e.g., hook into JVM shutdown or use ExecutorService with an interruptible loop).
- Error handling:
  - Current methods `throws Exception` (main) for brevity. In production code, catch and log `IOException`, `SocketException` and ensure sockets are closed in `finally` blocks or try-with-resources where applicable.
- Port / address configuration:
  - Port and host are hard-coded for clarity; make these configurable (command-line args, environment variables, or config file) for flexible usage.
- Packet size & message boundaries:
  - UDP preserves message boundaries — one `send()` corresponds to one `receive()`. Server uses that to reverse exactly the received message.
- Security considerations:
  - UDP is unauthenticated and spoofable. Do not accept untrusted data without validation. For real deployments, consider applying authentication/encryption (e.g., Datagram TLS-like protocols or application-level signatures).
  - Beware of amplification / reflection attacks when building public UDP services.
- Network reliability:
  - UDP is unreliable (packets can be lost, duplicated, reordered). For guaranteed delivery or ordered streams, use TCP or add retransmission/ACK logic at the application layer.

How to run (example)
1. Start the server (in one terminal / IDE):
   - `java imrovedversion.Server`
   - Expected output:
     ```
     Server: Listening on port 2000...
     ```
2. Start the client (in another terminal / IDE):
   - `java imrovedversion.DatagramClient`
   - Expected output (client):
     ```
     Client: Message sent to Server.
     Client: Response from Server -> <reversed "Hello Server">
     ```
   - Expected output (server console when processing):
     ```
     Server: Received -> Hello Server
     Server: Sent back reversed message.
     ```

Example interaction
- Client sends: `Hello Server`
- Server receives: `Hello Server`
- Server replies: `revreS olleH` (the reversed string)
- Client prints the reply.

Testing notes
- Localhost tests are fine for learning. To test across machines, ensure:
  - Firewalls allow inbound UDP on the chosen port.
  - Use server machine IP instead of `localhost`.
- Test with different payload sizes to validate buffer sizing.
- Test packet loss scenarios with network tools (e.g., `tc` on Linux) to observe and design for loss/retransmission if needed.

Potential improvements / roadmap
- Add charset explicitness: use `StandardCharsets.UTF_8`.
- Add CLI flags: host, port, message, buffer-size, timeout.
- Server improvements:
  - Add graceful shutdown via shutdown hook.
  - Use ExecutorService to offload processing to worker threads and improve throughput.
  - Add request-id correlation if client sends multiple requests and expects matched replies.
- Reliability:
  - Implement simple ACK/retry or sequence numbers if reliable delivery is required.
- Metrics & logging:
  - Integrate a logging framework (SLF4J/Logback) and add basic metrics (requests/sec, bytes processed, errors).
- Security:
  - Validate input size and content to avoid resource exhaustion.
  - If appropriate, layer DTLS or use encrypted channels.

Real-world use cases
- Low-latency, fire-and-forget telemetry (sensor data, syslog, metrics like StatsD).
- Simple UDP-based RPC for lightweight services (e.g., game servers exchanging quick state updates).
- Discovery protocols (e.g., service discovery broadcast/announce).
- Learning and teaching networking primitives in Java.

Compatibility & portability
- The code uses only JDK standard classes (`java.net.DatagramSocket`, `DatagramPacket`, `InetAddress`) — compatible with any Java SE runtime (8+).
- Recommend using UTF-8 for cross-platform string encoding.

Notes & cautions
- UDP is not connection-oriented — no `connect()` call is used; server replies to the packet's source address & port.
- There is no built-in backpressure: rapid sends can overflow receiver buffers or cause packet loss.
- For production-grade systems, choose TCP, QUIC, or add application-level reliability depending on requirements.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section27NetworkProgramming/DataGramReverseEchoServer/src/imrovedversion/DatagramClient.java renamed to Section27NetworkProgramming/DataGramReverseEchoServer/src/ImprovedVersion/DatagramClient.java

@@ -1,4 +1,4 @@
-package imrovedversion;
+package ImprovedVersion;
 
 import java.net.*;
 
@@ -26,4 +26,4 @@ public static void main(String[] args) throws Exception {
 
         ds.close();
     }
-}
+}

Section27NetworkProgramming/DataGramReverseEchoServer/src/ImprovedVersion/Logic.txt

@@ -0,0 +1,39 @@
+1. DatagramSocket:
+   - UDP protocol ke liye use hota hai (connectionless).
+   - Client side: `new DatagramSocket()` → system automatic free port allocate karta hai.
+   - Server side: `new DatagramSocket(2000)` → explicitly port bind kiya jata hai.
+
+2. DatagramPacket:
+   - Ek packet = data + destination address + port.
+   - Client `send()` karta hai → packet server ke port tak pahunchta hai.
+   - Server `receive()` karta hai → blocking call (jab tak data nahi aata, rukta hai).
+
+3. Client Flow:
+   - Message `"Hello Server"` ko byte[] me convert kiya.
+   - `DatagramPacket` banaya with `serverAddress = localhost, port=2000`.
+   - `ds.send(dp)` → message server tak chala gaya.
+   - Fir ek naya empty packet bana → server ka response receive kiya.
+   - `response.getData()` se byte[] nikaal kar string me convert kiya.
+
+4. Server Flow:
+   - Port `2000` pe continuously listen karta hai.
+   - Har aane wale packet ko `dp.getData()` se String banata hai.
+   - Message ko reverse karta hai → `"Hello Server"` → `"revreS olleH"`.
+   - Response packet bana ke wapas client ke address + port pe send karta hai.
+
+5. Output Pattern (Example):
+
+Server:   
+Server: Listening on port 2000…
+Server: Received -> Hello Server
+Server: Sent back reversed message.
+
+Client:
+Client: Message sent to Server.
+Client: Response from Server -> revreS olleH
+
+✔ UDP = fast, lightweight, but connectionless (no guarantee).  
+✔ DatagramSocket (server bind to port, client no bind needed).  
+✔ DatagramPacket = actual container of data.  
+✔ Example: client sends message → server reverses → sends back.  
+✔ Real-world: chat apps, multiplayer games, DNS, where speed > reliability.

Section27NetworkProgramming/DataGramReverseEchoServer/src/imrovedversion/Server.java renamed to Section27NetworkProgramming/DataGramReverseEchoServer/src/ImprovedVersion/Server.java

@@ -1,25 +1,27 @@
-package imrovedversion;
+package ImprovedVersion;
 
 import java.net.*;
 
 public class Server {
     public static void main(String[] args) throws Exception {
-        DatagramSocket ds = new DatagramSocket(2000); // Server listening on port 2000
+        DatagramSocket ds = new DatagramSocket(2000);
+        // Server listening on port 2000
+
         System.out.println("Server: Listening on port 2000...");
 
         byte[] buffer = new byte[1024];
 
         while (true) { // Continuous listening mode
             DatagramPacket dp = new DatagramPacket(buffer, buffer.length);
-            ds.receive(dp); // Receiving message
+            ds.receive(dp); // Receiving a message.
 
-            String receivedMsg = new String(dp.getData(), 0, dp.getLength()); // Trim excess bytes
+            String receivedMsg = new String(dp.getData(), 0, dp.getLength()); // Trim excess bytes.
             System.out.println("Server: Received -> " + receivedMsg);
 
-            // Reverse the received message
+            // Reverse the received message.
             String reversedMsg = new StringBuilder(receivedMsg).reverse().toString();
 
-            // Send response back to client
+            // Send a response back to a client.
             DatagramPacket response = new DatagramPacket(
                     reversedMsg.getBytes(), reversedMsg.length(),
                     dp.getAddress(), dp.getPort()