Network layer:   Host-to-host communication
Transport layer: Process-to-process communication

+--------+                    +--------+
| App P1 |                    | App P3 |
| App P2 |                    | App P4 |
+--------+                    +--------+
| Transport | <-- logical --> | Transport |
+--------+   communication   +--------+
| Network |  <-- logical --> | Network |
+--------+   communication   +--------+
  Host A                       Host B

House (Host) A                    House (Host) B
  Ann (process)                     Bob (process)
  Bill (process)                    Carol (process)

  Transport layer = The person in the house who sorts the mail
                    (decides which family member to deliver to)

  Network layer = The postal service
                 (delivers letters from House A to House B)

TCP (Transmission Control Protocol):
  +-- Connection-oriented (3-way handshake)
  +-- Reliable data transfer
  +-- Flow control (receiver protection)
  +-- Congestion control (network protection)
  +-- Order guarantee

UDP (User Datagram Protocol):
  +-- Connectionless
  +-- Unreliable (best-effort delivery)
  +-- No flow/congestion control
  +-- No order guarantee

Multiplexing:
  On the sending side, gather data from multiple sockets,
  add transport-layer headers, and pass to the network layer

Demultiplexing:
  On the receiving side, receive transport-layer segments
  and deliver to the correct socket (process)

Demultiplexing operation:

  Segment received from network layer
       |
       v
  Transport layer: Check port number in segment header
       |
       +--> Port 80  -> Web server process
       +--> Port 25  -> Mail server process
       +--> Port 53  -> DNS server process

Port number range: 0 to 65535

  0 to 1023:      Well-Known Ports
                   HTTP(80), HTTPS(443), DNS(53), SMTP(25)

  1024 to 49151:  Registered Ports

  49152 to 65535: Dynamic/Ephemeral Ports
                   Automatically assigned to clients

Transport layer segment:
+--------------+--------------+
| Source port   | Dest port    |  <- 16 bits each
+--------------+--------------+
|       Other header fields    |
+------------------------------+
|    Application data          |
+------------------------------+

Server: IP=10.0.0.1, Port=46428

Client A (IP=10.0.0.2, source port=9157)
  -> Destination: 10.0.0.1:46428

Client B (IP=10.0.0.3, source port=9157)
  -> Destination: 10.0.0.1:46428

Both datagrams are delivered to the same socket!
(Same destination port, even though source IPs differ)

Server: IP=10.0.0.1, Port=80

Client A (IP=10.0.0.2, source port=9157)
  -> 4-tuple: (10.0.0.2, 9157, 10.0.0.1, 80)
  -> Dedicated connection socket 1

Client B (IP=10.0.0.3, source port=9157)
  -> 4-tuple: (10.0.0.3, 9157, 10.0.0.1, 80)
  -> Dedicated connection socket 2

Same source port but different IPs -> different sockets!

TCP server socket structure:

  Welcome socket (port 80)
       |
       +-- Connection socket 1: (10.0.0.2:9157, 10.0.0.1:80)
       +-- Connection socket 2: (10.0.0.3:9157, 10.0.0.1:80)
       +-- Connection socket 3: (10.0.0.2:5775, 10.0.0.1:80)

  Each connection is distinguished by its unique 4-tuple

What UDP does:
  + Multiplexing/demultiplexing (port numbers)
  + Simple error detection (checksum)

What UDP does not do:
  x Connection setup
  x Reliable delivery
  x Flow control
  x Congestion control
  x Order guarantee

Advantages of UDP:
  1. No connection setup -> Reduced delay (why DNS uses UDP)
  2. No connection state -> Can support more clients
  3. Small header overhead -> Efficient (UDP: 8 bytes, TCP: 20 bytes)
  4. No rate limitation -> Application can send at desired speed

+------------------+------------------+
| Source port (16)  | Dest port (16)   |
+------------------+------------------+
| Length (16)       | Checksum (16)    |
+------------------+------------------+
|                                      |
|    Application data (payload)        |
|                                      |
+--------------------------------------+

Header size: 8 bytes (4 fields x 2 bytes)

Example: Three 16-bit words

  0110 0110 0110 0000
  0101 0101 0101 0101
  1000 1111 0000 1100

Step 1: Add the first two words
  0110 0110 0110 0000
+ 0101 0101 0101 0101
---------------------
  1011 1011 1011 0101

Step 2: Add the third word to the result
  1011 1011 1011 0101
+ 1000 1111 0000 1100
---------------------
  0100 1010 1100 0001  (wraparound on carry)

Step 3: Take the 1's complement
  0100 1010 1100 0001
-> 1011 0101 0011 1110  <- This is the checksum

Sender:
  1. Set checksum field to 0
  2. Add all 16-bit words of the segment
  3. Take the 1's complement and store in checksum field

Receiver:
  1. Add all 16-bit words of the segment (including checksum)
  2. If the result is all 1s -> No error (high probability)
  3. If any bit is 0 -> Error detected!

Verification example (no error):
  Sum of data words + checksum = 1111 1111 1111 1111
  -> All bits are 1 -> Normal

Verification example (error present):
  Due to bit error, sum becomes 1111 1011 1111 1111
  -> Contains a 0 -> Error detected!

Checksum limitations:
  1. Can detect errors but cannot correct them
  2. May miss some errors (e.g., two bits change complementarily)
  3. UDP takes no action even when an error is detected
     - Discards the damaged segment or delivers it with a warning to the application

Application-level reliability implementation:
  +-- Acknowledgment (ACK) mechanism
  +-- Retransmission timer
  +-- Sequence numbers

Example: QUIC protocol (used in HTTP/3)
  - Implements reliable transfer over UDP
  - Faster connection setup than TCP
  - Multiplexing support

Transport layer summary:

  Multiplexing/Demultiplexing:
  +-- UDP: Socket identified by (dest IP, dest port) 2-tuple
  +-- TCP: Socket identified by (src IP, src port, dest IP, dest port) 4-tuple

  UDP:
  +-- Connectionless, unreliable
  +-- 8-byte header (source port, dest port, length, checksum)
  +-- Error detection via checksum
  +-- Suitable for real-time applications