When a client aborts an HTTP request (via ESC key, browser stop button, or tab closure), the TCP connection gets abruptly terminated through a RST (reset) packet. Modern browsers do not send any explicit cancellation notification to the server - the connection simply drops.

// Example TCP dump showing RST packet
17:42:15.123456 IP client.54321 > server.80: Flags [R], seq 123456, win 0

The server's behavior depends on the web server configuration and application logic:

• Apache: Child process continues processing until completion (wastes resources)
• Nginx: Checks client connection state via proxy_ignore_client_abort directive
• Node.js: request object emits 'close' event when client disconnects

Node.js Express Implementation:

app.post('/long-task', (req, res) => {
  const timer = setInterval(() => {
    if (req.aborted) {
      clearInterval(timer);
      console.log('Client disconnected');
      return;
    }
    // Continue processing...
  }, 1000);

  req.on('close', () => {
    clearInterval(timer);
    // Cleanup resources
  });
});

Python Flask Example:

from flask import Flask, request
import time

app = Flask(__name__)

@app.route('/process')
def long_process():
    def generate():
        try:
            for i in range(10):
                if request.environ.get('werkzeug.server.shutdown'):
                    print("Client disconnected")
                    break
                time.sleep(1)
                yield f"Data chunk {i}\\n"
        finally:
            print("Cleaning up resources")
    
    return app.response_class(generate())

If the server attempts to send response after client disconnection:

1. First packets may reach client's TCP buffer (but won't be processed)
2. Subsequent packets trigger ICMP "Destination Unreachable" errors
3. Router-level buffers may temporarily hold packets before dropping

• Implement heartbeat checks in long-running operations
• Use WebSockets for bidirectional communication when possible
• Set appropriate timeouts (consider TCP keepalive settings)
• Always include connection state verification in loops

// PHP connection status check example
while ($longRunningProcess) {
    if (connection_status() != CONNECTION_NORMAL) {
        cleanup();
        exit;
    }
    // Process data
}

When a browser initiates an HTTP request that gets terminated by the user (via Esc key, stop button, or navigation away), here's what actually happens:

Browser → [TCP SYN] → Server
Browser ← [TCP SYN-ACK] ← Server
Browser → [HTTP GET] → Server
[User presses Stop]
Browser → [TCP RST] → Server (abrupt termination)
OR
Browser → [TCP FIN] → Server (graceful termination)

Modern browsers typically handle request termination in one of these ways:

• Chrome/Firefox: Sends TCP RST packet (immediate connection reset)
• Safari: May attempt graceful FIN handshake
• Edge: Similar to Chrome but with additional cleanup in the networking stack

What happens server-side depends on the web server technology:

// Node.js Express example
app.get('/long-process', (req, res) => {
  const longOperation = setInterval(() => {
    // This keeps running even after client disconnects
    console.log('Processing...');
  }, 1000);

  req.on('close', () => {
    clearInterval(longOperation); // Cleanup callback
    console.log('Client disconnected');
  });
});

Key technical considerations:

For different server technologies:

# Python Flask example
from flask import request

@app.route('/stream')
def stream():
    def generate():
        try:
            while True:
                yield "data\n"
        except GeneratorExit:
            print("Client disconnected")
    return Response(generate())

# PHP example (needs connection_status check)
while (true) {
    if (connection_status() != CONNECTION_NORMAL) {
        cleanup();
        break;
    }
    // Continue processing
}

When a server completes processing after client disconnection:

1. Response packets are still sent by server
2. Intermediate routers may drop packets destined for closed ports
3. TCP stack on client machine rejects packets
4. No application-level notification occurs

Advanced detection techniques:

// Java Servlet example
@WebServlet("/async")
public class AsyncServlet extends HttpServlet {
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        AsyncContext ctx = req.startAsync();
        ctx.addListener(new AsyncListener() {
            public void onComplete(AsyncEvent event) { /* normal finish */ }
            public void onError(AsyncEvent event) { /* error */ }
            public void onTimeout(AsyncEvent event) { /* timeout */ }
            public void onStartAsync(AsyncEvent event) { /* restart */ }
        });
    }
}