Network layer — forwarding, routing আর router-এর ভেতর

১ · Network layer-এর কাজ — অনেক link পেরিয়ে host থেকে host

মডিউল ২-এ দেখেছেন একটি link-এর ভেতরের সব কিছু: সংকেত, frame, ত্রুটি ধরা, আর switch কীভাবে MAC দেখে LAN-এর ভেতরে frame পাঠায় (পর্ব ১২)। কিন্তু আপনার ফোন থেকে একটি ওয়েবসাইটের সার্ভার পর্যন্ত পথে থাকে বাসার Wi-Fi, ISP-র fiber, দেশের backbone, হয়তো সমুদ্রের নিচের কেবল — একেকটি আলাদা link, আলাদা প্রযুক্তি। এই পুরো যাত্রা যে স্তর সামলায়, সেটিই network layer (OSI-র স্তর ৩, TCP/IP-তে Internet স্তর; পর্ব ০৩)। ইন্টারনেটে এর protocol IP.

তিনটি স্তরের কাজ পাশাপাশি রাখলে পার্থক্যটি পরিষ্কার হয়:

প্রতিটি host আর router-এ network layer থাকে; সাধারণ switch-এ থাকে না (ব্যতিক্রম layer-3 switch, পর্ব ১৩)। Router সাধারণত নিচের তিন স্তর পর্যন্তই খোলে (পর্ব ০৩-এর encapsulation).

 Host A                 R1             R2              Host B
┌───────────┐                                       ┌───────────┐
│Application│                                       │Application│
│Transport  │                                       │Transport  │
│Network    │──────▶ ┌───────┐ ──▶ ┌───────┐ ─────▶ │Network    │
│Data link  │        │Network│     │Network│        │Data link  │
│Physical   │        │Link   │     │Link   │        │Physical   │
└───────────┘        │Phys   │     │Phys   │        └───────────┘
                     └───────┘     └───────┘
   link 1 (Wi-Fi)    link 2 (fiber)   link 3 (Ethernet)

Network layer-এর দুটি মূল কাজ

বাকি দায়িত্বগুলো এই মডিউলের আলাদা পর্বে: ঠিকানা আর IPv4 header (পর্ব ১৬), subnet (পর্ব ১৭), DHCP ও ARP (পর্ব ১৮), NAT (পর্ব ১৯), ICMP (পর্ব ২০) আর IPv6 (পর্ব ২১)। এই পর্বের লক্ষ্য পুরো স্তরের কাঠামো — বিশেষ করে router ভেতরে আসলে কী করে।

২ · Forwarding বনাম routing — data plane আর control plane

পরীক্ষা আর ইন্টারভিউতে সবচেয়ে বেশি গুলিয়ে ফেলা জোড়া এটি। Forwarding যে টেবিল দেখে কাজ করে তার নাম forwarding table; routing-এর কাজ সেই টেবিল ভরা।

ন্যানোসেকেন্ড কেন — একটি হিসাব

একটি ১০০ Gbps Ethernet port-এ সবচেয়ে ছোট frame (৬৪ byte) একটার পর একটা এলে, তারে প্রতিটি frame নেয় ৬৪ + ৮ (preamble) + ১২ (দুই frame-এর মাঝের ফাঁক) = ৮৪ byte = ৬৭২ bit. তাই প্রতি সেকেন্ডে frame আসে ১০০ × ১০^৯ ÷ ৬৭২ ≈ ১৪ কোটি ৮৮ লক্ষ, আর একটি packet-এর জন্য সময় মাত্র ৬৭২ ÷ (১০০ × ১০^৯) সেকেন্ড = ৬.৭২ ন্যানোসেকেন্ড. এই সময়ের মধ্যে টেবিল খোঁজা, TTL কমানো, checksum বদলানো — সব। কোনো সাধারণ CPU-র software এই গতিতে প্রতিটি packet দেখতে পারে না; তাই forwarding হয় বিশেষ chip-এ। অন্যদিকে routing-এর হিসাব (কোন পথ সবচেয়ে ভালো) কয়েক সেকেন্ডে একবার হলেই চলে — সেটি CPU-তে software.

RIB আর FIB — এক router-এর ভেতরে দুই টেবিল

বাস্তব router-এ দুটি টেবিল থাকে। Routing protocol-গুলো যা শেখে, সব জমা হয় routing processor-এর RIB (Routing Information Base)-এ। সেখান থেকে প্রতিটি গন্তব্যের সেরা পথ বেছে, দ্রুত খোঁজার উপযোগী আকারে কপি হয় প্রতিটি line card-এর FIB (Forwarding Information Base)-এ — forwarding table বলতে সাধারণত এটিই। দৈনন্দিন ভাষায় routing table শব্দটি দুটিকেই বোঝায় (পর্ব ০৬)।

Control plane কোথায় থাকবে — প্রতিটি router-এ, না এক জায়গায়?

৩ · Datagram, virtual circuit আর ইন্টারনেটের service model

পর্ব ০৪-এ packet switching-এর দুই ঘরানা দেখেছেন। সংক্ষেপে মনে করিয়ে দিই, কারণ network layer-এর নকশা এই সিদ্ধান্ত থেকেই শুরু:

• Datagram নেটওয়ার্ক (ইন্টারনেটের IP): কোনো আগাম setup নেই। প্রতিটি packet-এ পুরো গন্তব্য ঠিকানা; router প্রতিটি packet আলাদাভাবে দেখে, কোনো সংযোগ মনে রাখে না। একই কথোপকথনের দুটি packet আলাদা পথে যেতে পারে, আগে-পরে পৌঁছাতে পারে।
• Virtual circuit (VC) নেটওয়ার্ক: ডেটার আগে setup; পথের প্রতিটি router সেই সংযোগের একটি টেবিল-লাইন রাখে; packet-এ ছোট একটি VC নম্বর বা label. পুরোনো X.25 (১৯৭০-এর দশকে CCITT-র মান), পরে Frame Relay, নব্বইয়ের দশকে টেলিফোন কোম্পানিগুলোর বড় আশা ATM, আর আজ ISP-র ভেতরে MPLS (স্থাপত্য RFC 3031, ২০০১) এই ঘরানার।

Service model — নেটওয়ার্ক কী কী প্রতিশ্রুতি দেয়

একটি network layer-এর service model বলে, প্রেরকের হাত থেকে packet নিয়ে নেটওয়ার্ক কী কী নিশ্চয়তা দেবে। সম্ভাব্য প্রতিশ্রুতির তালিকা আর ইন্টারনেটের উত্তর:

ইন্টারনেটের উত্তর প্রায় সব ঘরে “না”. একে বলে best effort — “যথাসাধ্য চেষ্টা করব, কিন্তু কিছুর নিশ্চয়তা নেই”. শুনতে দুর্বল লাগে, কিন্তু এটিই ইন্টারনেটের সাফল্যের একটি বড় কারণ:

• সরল মাঝখান, বুদ্ধি প্রান্তে: হারানো packet আবার পাঠানো, ক্রম ঠিক করা, গতি নিয়ন্ত্রণ — এসব দুই প্রান্তের TCP করে (মডিউল ৫), পর্ব ০৩-এর end-to-end principle. Router কোনো সংযোগ মনে রাখে না, তাই সে সস্তা, দ্রুত, আর একটি নষ্ট হলে packet অন্য পথে যায়।
• যেকোনো link-এর ওপর চলে: IP শুধু চায় “একটি packet এক hop পার করানো” — Wi-Fi, fiber, স্যাটেলাইট, মোবাইল, সবাই এটুকু পারে। কঠিন নিশ্চয়তা চাইলে প্রতিটি link-কেও সেই নিশ্চয়তা দিতে হতো।
• বাস্তবে যথেষ্ট ভালো: বেশি bandwidth, CDN (পর্ব ৩৮), TCP-র congestion control (পর্ব ৩২) আর ভিডিও অ্যাপের মান বদলে নেওয়া মিলে best effort-এও ভিডিও কল চলে। অগ্রাধিকার সত্যিই দরকার হলে QoS (পর্ব ২৬)।

৪ · গন্তব্য দেখে forwarding — longest prefix match

IPv4 ঠিকানা ৩২ bit, অর্থাৎ ২^৩২ ≈ ৪৩০ কোটি সম্ভাব্য ঠিকানা। প্রতিটি ঠিকানার জন্য forwarding table-এ একটি সারি রাখা অসম্ভব। তাই টেবিলে থাকে ঠিকানার prefix — ঠিকানার শুরুর কিছু bit, যা একটি পুরো দলকে বোঝায়। ঠিক যেমন ডাকঘরের বাছাইকারী পুরো ঠিকানা না পড়ে শুধু জেলার নাম দেখে বস্তায় চিঠি ফেলেন। লেখার ধরন 198.51.100.0/24: “/24” মানে প্রথম ২৪ bit (এখানে 198.51.100) মিললেই এই সারি প্রযোজ্য; শেষের ৮ bit যা-ই হোক। এই লেখার নিয়ম (CIDR) আর ঠিকানার হিসাব বিস্তারিত পর্ব ১৬–১৭-এ; এখানে শুধু lookup-এর নিয়মটি।

সমস্যা হলো, একটি গন্তব্য টেবিলের একাধিক সারির সাথে মিলতে পারে। নিয়ম: longest prefix match — যে সারির prefix সবচেয়ে লম্বা, অর্থাৎ সবচেয়ে নির্দিষ্ট, সেটিই জেতে। খামে যদি লেখা থাকে “চট্টগ্রাম বিভাগের সব চিঠি কুমিল্লা হয়ে”, আবার আলাদা নির্দেশ থাকে “কক্সবাজার সদরের চিঠি সরাসরি কক্সবাজারের বাসে” — কক্সবাজার সদরের চিঠির জন্য দ্বিতীয় নির্দেশটিই প্রযোজ্য, কারণ তা বেশি নির্দিষ্ট। আর 0.0.0.0/0 (প্রথম ০ bit মিলতে হবে, অর্থাৎ সব ঠিকানা মেলে) হলো default route — “অন্য কিছু না মিললে এদিকে”, পর্ব ০৬-এর default gateway.

Router R1-এর forwarding table (সব ঠিকানা documentation-এর জন্য সংরক্ষিত range থেকে):

গন্তব্য 198.51.100.200-এর জন্য R1 কী করে, bit ধরে দেখি। প্রথম ২৪ bit সব 198.51.100-এর সারিতে একই, তাই আসল লড়াই শেষ byte-এ: ২০০ = বাইনারি 11001000.

এবার একই টেবিল দিয়ে ছয়টি গন্তব্যের lookup একসাথে। Simulator প্রতিটি গন্তব্যের সাথে কোন কোন prefix মিলল আর কোনটি জিতল, তা ছাপে। mask(len) প্রথম lenটি bit ১ রেখে বাকিগুলো ০ করে; গন্তব্যের সাথে AND করলে যদি সারির network ঠিকানা পাওয়া যায়, তবে মিল।

// Forwarding table of router R1: prefix -> output interface.
const table = [
  ["0.0.0.0/0", "eth0"],          // default route (towards the ISP)
  ["198.51.100.0/24", "eth1"],
  ["198.51.100.128/25", "eth2"],
  ["198.51.100.192/26", "eth3"],
  ["198.51.100.224/27", "eth4"],
  ["203.0.113.0/24", "eth4"],
];
const toInt = ip => ip.split(".").reduce((a, o) => a * 256 + Number(o), 0);
const mask = len => len === 0 ? 0 : (0xffffffff << (32 - len)) >>> 0;
const rows = table.map(([p, ifc]) => {
  const [net, len] = p.split("/");
  return { p, ifc, len: Number(len), net: toInt(net) };
});
function lookup(dst) {
  const d = toInt(dst);
  const hits = rows.filter(r => ((d & mask(r.len)) >>> 0) === r.net);
  const best = hits.reduce((a, b) => (b.len > a.len ? b : a));
  console.log(dst.padEnd(15) + " matches: " + hits.map(h => "/" + h.len).join(" ").padEnd(18) +
    " -> " + best.p.padEnd(18) + " " + best.ifc);
}
["198.51.100.200", "198.51.100.230", "198.51.100.150",
 "198.51.100.10", "203.0.113.9", "192.0.2.99"].forEach(lookup);

198.51.100.200  matches: /0 /24 /25 /26     -> 198.51.100.192/26  eth3
198.51.100.230  matches: /0 /24 /25 /26 /27 -> 198.51.100.224/27  eth4
198.51.100.150  matches: /0 /24 /25         -> 198.51.100.128/25  eth2
198.51.100.10   matches: /0 /24             -> 198.51.100.0/24    eth1
203.0.113.9     matches: /0 /24             -> 203.0.113.0/24     eth4
192.0.2.99      matches: /0                 -> 0.0.0.0/0          eth0

বড় ISP-র router-এর টেবিলে প্রায় দশ লক্ষ IPv4 prefix, আর lookup করতে হয় কয়েক ন্যানোসেকেন্ডে — সারি একে একে দেখা চলে না। তাই ব্যবহার হয় TCAM নামের বিশেষ মেমরি, যা এক ধাপে সব সারির সাথে তুলনা করে, অথবা bit ধরে নিচে নামা গাছের মতো কাঠামো (trie) — Linux kernel-ও trie ব্যবহার করে (/proc/net/fib_trie). Static route আর lookup-এর algorithm পর্ব ২২-এ।

আপনার কম্পিউটারও একটি ছোট router

প্রতিটি host-এরও একটি forwarding table আছে — সাধারণত দুটি-তিনটি সারি: নিজের LAN সরাসরি, আর বাকি সব default gateway দিয়ে। Linux-এ ip route দেখায় মূল টেবিল (main), আর ip -4 route show table all দেখায় সব টেবিল, এমনকি kernel-এর নিজের ঠিকানাগুলোর “local” টেবিলও। ip route get kernel-কে জিজ্ঞেস করে, “এই ঠিকানায় packet পাঠালে কোন সারি জিতবে?” — কোনো packet না পাঠিয়েই। নিচের স্ক্রিপ্ট এই পাতার কোড-চালানোর container-এ এগুলো চালায়, তারপর /proc/net/route-এর hex নিজের হাতে decode করে (পর্ব ০৬-এর মতো উল্টো byte ক্রমে, আর mask-এর ১ bit গুনে prefix-এর দৈর্ঘ্য):

hex2ip() { local h=$1; printf '%d.%d.%d.%d' "0x${h:6:2}" "0x${h:4:2}" "0x${h:2:2}" "0x${h:0:2}"; }
masklen() { local m=$(( 16#$1 )) n=0; while [ "$m" -gt 0 ]; do n=$(( n + (m & 1) )); m=$(( m >> 1 )); done; echo "$n"; }
if command -v ip >/dev/null; then
  echo "== ip route  (main table) =="
  ip route
  echo "== ip -4 route show table all =="
  ip -4 route show table all
  echo "== ip route get: which entry wins? =="
  for d in 10.0.2.77 192.0.2.1 127.8.8.8; do ip route get "$d" | head -n 1; done
else
  echo "ip নেই — শুধু /proc/net/route দেখানো হচ্ছে"
fi
echo "== /proc/net/route decoded by hand =="
printf '  %-6s %-15s %-12s %-4s %s\n' Iface Destination Gateway Flags Prefix
while read -r ifc dst gw flags _ _ _ msk _; do
  printf '  %-6s %-15s %-12s %-4s /%s  (raw %s %s %s)\n' "$ifc" "$(hex2ip "$dst")" \
    "$(hex2ip "$gw")" "$flags" "$(masklen "$msk")" "$dst" "$gw" "$msk"
done < <(tail -n +2 /proc/net/route)

== ip route  (main table) ==
default via 10.0.2.2 dev tap0
10.0.2.0/24 dev tap0 proto kernel scope link src 10.0.2.100
== ip -4 route show table all ==
default via 10.0.2.2 dev tap0
10.0.2.0/24 dev tap0 proto kernel scope link src 10.0.2.100
local 10.0.2.100 dev tap0 table local proto kernel scope host src 10.0.2.100
broadcast 10.0.2.255 dev tap0 table local proto kernel scope link src 10.0.2.100
local 127.0.0.0/8 dev lo table local proto kernel scope host src 127.0.0.1
local 127.0.0.1 dev lo table local proto kernel scope host src 127.0.0.1
broadcast 127.255.255.255 dev lo table local proto kernel scope link src 127.0.0.1
== ip route get: which entry wins? ==
10.0.2.77 dev tap0 src 10.0.2.100 uid 999
192.0.2.1 via 10.0.2.2 dev tap0 src 10.0.2.100 uid 999
local 127.8.8.8 dev lo src 127.0.0.1 uid 999
== /proc/net/route decoded by hand ==
  Iface  Destination     Gateway      Flags Prefix
  tap0   0.0.0.0         10.0.2.2     0003 /0  (raw 00000000 0202000A 00000000)
  tap0   10.0.2.0        0.0.0.0      0001 /24  (raw 0002000A 00000000 00FFFFFF)

গন্তব্য ছাড়িয়ে — generalised forwarding (match-plus-action)

এতক্ষণ forwarding মানে ছিল “গন্তব্য IP দেখে port বাছাই”. কিন্তু একটু বড় করে ভাবলে switch, router, firewall আর NAT — সবাই একই কাজ করে: packet-এর header-এর কিছু ঘর মেলানো, তারপর একটি কাজ করা। Switch মেলায় গন্তব্য MAC, router গন্তব্য IP, firewall port নম্বর, NAT ঠিকানা মিলিয়ে বদলে দেয়। এই সাধারণ ধারণার নাম match-plus-action, আর এভাবে forwarding-কে বলে generalised forwarding. ২০০৮ সালের OpenFlow প্রস্তাব এই ধারণাকে একটি খোলা মানে রূপ দেয়: যন্ত্রের ভেতরে একটি flow table, যার প্রতিটি সারিতে মেলানোর ঘর, অগ্রাধিকার, কাজ আর counter, আর সারিগুলো বসায় SDN controller.

নিয়ম মেলে অগ্রাধিকার ধরে, আর প্রতিটি সারির counter গোনে কতগুলো packet মিলেছে। SDN আর OpenFlow-এর বিস্তারিত পর্ব ৫৩-এ।

৫ · Router-এর ভেতরে — চারটি অংশ

বাইরে থেকে router একটি বাক্স, পেছনে অনেকগুলো port. ভেতরে চারটি অংশ, আর বড় router-এ প্রতিটি port-এর দল একটি আলাদা বোর্ডে থাকে, যার নাম line card.

                   ┌──────────────────────┐
                   │  Routing processor   │  control plane: OSPF/BGP, RIB,
                   │  (CPU, software)     │  FIB হিসাব করে line card-এ পাঠায়
                   └──────────┬───────────┘
                              │ FIB-এর কপি
 ┌─────────────────┐   ┌──────┴───────┐   ┌──────────────────┐
 │ Input port eth1 │──▶│              │──▶│ Output port eth3 │──▶ তার
 │ line term. │ L2 │   │  Switching   │   │ queue │ L2 │ tx  │
 │ lookup │ queue  │   │   fabric     │   └──────────────────┘
 └─────────────────┘   │              │   ┌──────────────────┐
 ┌─────────────────┐   │ (memory/bus/ │──▶│ Output port eth4 │──▶ তার
 │ Input port eth2 │──▶│  crossbar)   │   └──────────────────┘
 └─────────────────┘   └──────────────┘
 ◀──────────────── data plane (hardware, ns) ─────────────────▶

লক্ষ করুন, lookup হয় প্রতিটি input port-এর নিজস্ব FIB-কপিতে — তাই কেন্দ্রীয় CPU bottleneck হয় না। এবার একটি packet-কে R1-এর ভেতর দিয়ে অনুসরণ করি — গন্তব্য সেই 198.51.100.200, ঢুকছে eth1 দিয়ে।

Switching fabric তিন রকম

৬ · Queue কোথায় জমে — head-of-line blocking, buffer আর bufferbloat

পর্ব ০৫-এ দেখেছেন, queuing delay আর packet loss আসে লাইনে দাঁড়ানো থেকে। Router-এর ভেতরে লাইন জমতে পারে দুই জায়গায়।

Output queue — যখন সবাই একই দরজায়

ধরুন তিনটি ১০ Gbps input port একই মুহূর্তে একই ১০ Gbps output port-এ পাঠাচ্ছে। Fabric যত দ্রুতই হোক, output-এর তার সেকেন্ডে ১০ Gbit-এর বেশি পাঠাতে পারে না। আসছে ৩০, যাচ্ছে ১০ — প্রতি সেকেন্ডে ২০ Gbit জমার কথা; buffer কয়েক মিলিসেকেন্ডেই ভরে যায়, তারপর packet ফেলা। ঢাকার মোড়ে তিন দিক থেকে গাড়ি এক দিকে গেলে লাইন হবেই — পর্ব ০৫-এর traffic intensity ১-এর বেশি।

Input queue আর head-of-line blocking

Fabric যদি সব input-এর মিলিত গতির সমান দ্রুত না হয়, packet input port-এই অপেক্ষা করে। সমস্যা হয় যখন input port-এ একটিই লাইন (FIFO): লাইনের সামনের packet-টি যে output চায় তা ব্যস্ত হলে, তার পেছনের packet-টি — যার output হয়তো সম্পূর্ণ ফাঁকা — সেটিও আটকে থাকে। একে বলে head-of-line (HOL) blocking. সরু গলিতে সামনের রিকশা ডানে ঢোকার জন্য দাঁড়িয়ে, পেছনের রিকশা বামে যাবে — রাস্তা ফাঁকা, তবু যেতে পারছে না।

নিচে একটি ৩ × ৩ crossbar. প্রতি সময়-ধাপে (slot) প্রতিটি output একটির বেশি packet নিতে পারে না; দুটি input একই output চাইলে কম নম্বরের input জেতে। প্রতিটি input-এ দুটি packet, লাইনের সামনেরটি আগে লেখা।

এটি শুধু খেলনা উদাহরণের সমস্যা নয়। ১৯৮৭ সালে Karol, Hluchyj আর Morgan দেখান, প্রতিটি packet-এর output এলোমেলোভাবে সমান সম্ভাবনায় বাছা হলে আর port অনেক হলে FIFO input queue-র switch সর্বোচ্চ প্রায় ২ − √২ ≈ ৫৮.৬% ক্ষমতায় চলতে পারে — বাকিটা HOL blocking-এ নষ্ট। তাই আধুনিক উচ্চগতির router-এ VOQ প্রায় সর্বজনীন, সাথে প্রতিটি slot-এ input আর output-এর জোড়া মেলানোর দ্রুত algorithm (যেমন ১৯৯৯ সালে প্রকাশিত iSLIP), আর অনেক সময় fabric-কে port-এর চেয়ে কিছুটা দ্রুত রাখা (speedup).

Buffer কত বড় হবে — RTT × C আর √N

Buffer ছোট হলে ঝাপটায় packet হারায় আর link ফাঁকা পড়ে থাকে; বড় হলে delay বাড়ে। বহু বছর প্রচলিত হাতের নিয়ম (সাধারণত ১৯৯৪ সালের Villamizar আর Song-এর কাজকে উৎস ধরা হয়):

RTT একটি সাধারণ সংযোগের round-trip time, C link-এর গতি — অর্থাৎ একটি bandwidth-delay product (পর্ব ০৫)। যুক্তি: TCP loss দেখলে গতি অর্ধেক করে (পর্ব ৩২); সেই বিরতিতে link ব্যস্ত রাখতে এক RTT-র মতো জমা packet লাগে। হিসাব: RTT ২৫০ ms, C = ১০ Gbps → B = ২.৫ × ১০^৯ bit = ৩১২.৫ MB — প্রতিটি port-এ এত দ্রুত মেমরি খুব দামি।

২০০৪ সালে Appenzeller, Keslassy আর McKeown দেখান: link-এ একসাথে N টি দীর্ঘস্থায়ী, পরস্পর-স্বাধীন TCP সংযোগ থাকলে যথেষ্ট B = RTT × C ÷ √N. N = ১০,০০০ হলে √N = ১০০, তাই B ≈ ৩.১২৫ MB. তবে এর শর্ত সব জায়গায় খাটে না — বাসার মতো কম সংযোগের link-এ পুরোনো নিয়মটিই কাছাকাছি — আর সঠিক আকার নিয়ে গবেষণা আজও চলছে।

কাকে ফেলব — tail drop থেকে AQM

সবচেয়ে সরল নিয়ম tail drop: buffer ভরা থাকলে নতুন packet ফেলে দেওয়া। সমস্যা: queue প্রায় সবসময় ভরা (delay বেশি), আর অনেক TCP একসাথে loss দেখে একসাথে গতি কমায়-বাড়ায়, ঢেউয়ের মতো। সমাধান active queue management (AQM): buffer ভরার আগেই বুদ্ধি করে কিছু packet ফেলা বা চিহ্ন দেওয়া।

• RED (Random Early Detection, Floyd আর Jacobson, ১৯৯৩): গড় queue-র দৈর্ঘ্য একটি নিচের সীমা পেরোলে ছোট সম্ভাবনায় এলোমেলো packet ফেলা শুরু; দৈর্ঘ্য যত বাড়ে, সম্ভাবনা তত বাড়ে; ওপরের সীমা পেরোলে সব ফেলা। ফেলার বদলে header-এ “ভিড় আছে” চিহ্নও দেওয়া যায় (ECN, পর্ব ৩২)। সমস্যা: সঠিক সীমা ঠিক করা কঠিন, তাই অনেক জায়গায় RED বন্ধই থাকত।
• CoDel (Controlled Delay, Nichols আর Jacobson, ২০১২; RFC 8289): queue-র দৈর্ঘ্য নয়, প্রতিটি packet buffer-এ কতক্ষণ ছিল তা মাপে। একটি নির্দিষ্ট সময় (ডিফল্ট ১০০ ms) ধরে সবচেয়ে কম অপেক্ষাও লক্ষ্যমাত্রার (ডিফল্ট ৫ ms) বেশি থাকলে packet ফেলা শুরু করে। প্রায় কোনো সেটিং লাগে না। প্রতিটি সংযোগের জন্য আলাদা ছোট লাইনসহ এর রূপ fq_codel (RFC 8290) অনেক Linux distribution-এ ডিফল্ট queue নিয়ম।

Bufferbloat — বড় buffer-এর লুকানো দাম

পর্ব ০৫-এর bufferbloat-এর হিসাব এবার। বাসার router-এর upload ১০ Mbps, buffer ১ MB = ৮ Mbit. কেউ Google Drive-এ বড় ফাইল তুললে buffer ভরে থাকে, আর প্রতিটি নতুন packet অপেক্ষা করে ৮ ÷ ১০ = ০.৮ সেকেন্ড. পাশের ঘরের ভিডিও কল কেটে কেটে যায়, গেমের ping বাড়ে — অথচ কোনো packet হারায়নি, speed test-ও “ভালো”. Jim Gettys ২০১০-এর দিকে এই সমস্যাকে bufferbloat নামে সামনে আনেন। সমাধান AQM — buffer ঝাপটা সামলাবে, কিন্তু স্থায়ীভাবে ভরে থাকবে না।

৭ · Packet scheduling — লাইনে কে আগে যাবে

Output queue-তে কয়েকটি packet অপেক্ষায়। পরের packet কোনটি যাবে, ঠিক করে packet scheduling. হাসপাতালের কাউন্টারের মতো ভাবুন — নিয়ম কয়েক রকম হতে পারে:

WFQ-র একটি হিসাব: ৬০ Mbps link-এ তিন শ্রেণি, ওজন ৩ : ২ : ১. সবাই ব্যস্ত হলে তারা পায় ৬০ × ৩/৬ = ৩০, ৬০ × ২/৬ = ২০ আর ৬০ × ১/৬ = ১০ Mbps. তৃতীয় শ্রেণি ফাঁকা হয়ে গেলে প্রথম দুটি ভাগ করে ৩ : ২ অনুপাতে — ৩৬ আর ২৪ Mbps. অর্থাৎ ওজন হলো ভিড়ের সময়ের ন্যূনতম নিশ্চয়তা, সর্বোচ্চ সীমা নয়। (Fair queueing-এর মূল ধারণা Demers, Keshav আর Shenker-এর ১৯৮৯ সালের কাজে; প্রতিটি byte-কে আলাদাভাবে ভাগ করার আদর্শ রূপটির তাত্ত্বিক বিশ্লেষণ Parekh আর Gallager-এর।)

এবার একটি output port-এ FIFO আর priority পাশাপাশি চালাই। প্রতি slot-এ একটি packet পাঠানো যায়, buffer-এ সর্বোচ্চ ৩টি packet অপেক্ষা করতে পারে, আর ভরা থাকলে tail drop. H মানে উচ্চ অগ্রাধিকার (ভয়েস), L নিম্ন (ফাইল ডাউনলোড)। দুই রানে আগমন হুবহু এক। “waited” = কত slot অপেক্ষা করে পাঠানো হলো।

// One output port: sends 1 packet per time slot; buffer holds at most 3 waiting packets.
// H = high priority (voice), L = low priority (file download). Same arrivals for both runs.
const arrivals = ["L1 L2 L3", "H1 L4", "L5 H2", "L6", "H3", "", "", ""];
const B = 3;
function run(policy) {
  console.log(`\n=== ${policy} ===  slot | arrive   | sent (waited) | queue (len) | dropped`);
  const q = [], wait = { H: [], L: [] }, dropped = [];
  arrivals.forEach((a, i) => {
    const t = i + 1, drop = [];
    for (const name of a.split(" ").filter(Boolean)) {
      if (q.length < B) q.push({ name, cls: name[0], t });
      else { drop.push(name); dropped.push(name); }          // tail drop
    }
    let sent = "-";
    if (q.length) {
      let k = 0;
      if (policy === "PRIORITY") { const h = q.findIndex(p => p.cls === "H"); if (h >= 0) k = h; }
      const p = q.splice(k, 1)[0];
      wait[p.cls].push(t - p.t);
      sent = `${p.name} (${t - p.t})`;
    }
    console.log(`  ${String(t).padStart(4)} | ${(a || "-").padEnd(8)} | ${sent.padEnd(13)} | ` +
      `${(q.length + ": " + (q.map(p => p.name).join(" ") || "empty")).padEnd(11)} | ${drop.join(" ") || "-"}`);
  });
  const avg = xs => (xs.reduce((s, x) => s + x, 0) / xs.length).toFixed(2);
  console.log(`  avg wait: H = ${avg(wait.H)} slots, L = ${avg(wait.L)} slots;` +
    ` dropped: ${dropped.join(" ") || "none"}`);
}
run("FIFO");
run("PRIORITY");

=== FIFO ===  slot | arrive   | sent (waited) | queue (len) | dropped
     1 | L1 L2 L3 | L1 (0)        | 2: L2 L3    | -
     2 | H1 L4    | L2 (1)        | 2: L3 H1    | L4
     3 | L5 H2    | L3 (2)        | 2: H1 L5    | H2
     4 | L6       | H1 (2)        | 2: L5 L6    | -
     5 | H3       | L5 (2)        | 2: L6 H3    | -
     6 | -        | L6 (2)        | 1: H3       | -
     7 | -        | H3 (2)        | 0: empty    | -
     8 | -        | -             | 0: empty    | -
  avg wait: H = 2.00 slots, L = 1.40 slots; dropped: L4 H2

=== PRIORITY ===  slot | arrive   | sent (waited) | queue (len) | dropped
     1 | L1 L2 L3 | L1 (0)        | 2: L2 L3    | -
     2 | H1 L4    | H1 (0)        | 2: L2 L3    | L4
     3 | L5 H2    | L2 (2)        | 2: L3 L5    | H2
     4 | L6       | L3 (3)        | 2: L5 L6    | -
     5 | H3       | H3 (0)        | 2: L5 L6    | -
     6 | -        | L5 (3)        | 1: L6       | -
     7 | -        | L6 (3)        | 0: empty    | -
     8 | -        | -             | 0: empty    | -
  avg wait: H = 0.00 slots, L = 2.20 slots; dropped: L4 H2

কোন packet কোন শ্রেণির, router তা জানে IP header-এর DSCP ঘর দেখে বা নিজের নিয়মে মিলিয়ে। এক ISP-র দেওয়া চিহ্ন অন্য ISP সাধারণত মানে না — তাই ইন্টারনেট মোটের ওপর best effort থেকে যায়। QoS-এর পুরো কাঠামো পর্ব ২৬-এ।

৮ · একটি datagram-এর hop-by-hop যাত্রা

পর্ব ০৩-এ encapsulation-এর ছবিতে দেখেছেন, router frame খুলে IP packet বের করে আবার নতুন frame-এ ভরে। আর পর্ব ১৩-এর router-on-a-stick-এ দেখেছেন, MAC বদলায় কিন্তু IP থাকে। এবার পুরো পথ ধরে একটি নিয়মে বাঁধি — একটি router পার হলে কী বদলায়, কী বদলায় না:

নিচের simulator একটি ping-এর আকারের (৮৪ byte) IPv4 packet-কে host A (192.0.2.10) থেকে তিনটি router পেরিয়ে host B (203.0.113.80)-এ নেয়। প্রতিটি router TTL কমিয়ে পুরো header-এর checksum নতুন করে হিসাব করে (১৬ bit-এর word যোগ, উপচে পড়া অংশ ঘুরিয়ে যোগ, শেষে উল্টানো — পর্ব ০৯), আর মিলিয়ে দেখে শুধু বদলানো word থেকে হিসাবের দ্রুত পদ্ধতিটিও (RFC 1624) একই উত্তর দেয় কি না।

// A ping-sized IPv4 packet 192.0.2.10 -> 203.0.113.80 crosses routers R1, R2, R3.
const hdr = [0x45,0x00,0x00,0x54, 0x1c,0x46,0x40,0x00, 64,0x01,0,0,
             192,0,2,10, 203,0,113,80];                  // bytes 10-11 = checksum
function checksum(h) {                                  // RFC 791 / RFC 1071
  let sum = 0;
  for (let i = 0; i < 20; i += 2) if (i !== 10) sum += (h[i] << 8) | h[i + 1];
  while (sum > 0xffff) sum = (sum & 0xffff) + (sum >>> 16); // end-around carry
  return ~sum & 0xffff;
}
const hex = n => "0x" + n.toString(16).padStart(4, "0");
const mac = s => "02:00:00:00:" + s;
// each link: [who sends, src MAC, dst MAC]
const links = [["host A", mac("00:0a"), mac("01:01")], ["R1", mac("01:02"), mac("02:01")],
               ["R2", mac("02:02"), mac("03:01")], ["R3", mac("03:02"), mac("00:0b")]];
let ck = checksum(hdr);
console.log("link  sender  TTL  checksum  src MAC -> dst MAC");
links.forEach(([who, s, d], i) => {
  if (i > 0) {                                          // a router forwards it
    const oldWord = (hdr[8] << 8) | hdr[9];
    hdr[8] -= 1;                                        // TTL - 1
    const newWord = (hdr[8] << 8) | hdr[9];
    let inc = (~ck & 0xffff) + (~oldWord & 0xffff) + newWord;  // RFC 1624 update
    while (inc > 0xffff) inc = (inc & 0xffff) + (inc >>> 16);
    inc = ~inc & 0xffff;
    ck = checksum(hdr);                                 // full recompute
    if (inc !== ck) console.log("  incremental update disagrees!");
  }
  console.log(`  ${i + 1}   ${who.padEnd(6)}  ${String(hdr[8]).padStart(3)}  ${hex(ck)}    ${s} -> ${d}`);
});
console.log("src/dst IP never changed: 192.0.2.10 -> 203.0.113.80");

link  sender  TTL  checksum  src MAC -> dst MAC
  1   host A   64  0x2008    02:00:00:00:00:0a -> 02:00:00:00:01:01
  2   R1       63  0x2108    02:00:00:00:01:02 -> 02:00:00:00:02:01
  3   R2       62  0x2208    02:00:00:00:02:02 -> 02:00:00:00:03:01
  4   R3       61  0x2308    02:00:00:00:03:02 -> 02:00:00:00:00:0b
src/dst IP never changed: 192.0.2.10 -> 203.0.113.80

MTU ছোট হলে — fragmentation আছে

প্রতিটি link-এর একটি সর্বোচ্চ আকার আছে (MTU) — Ethernet-এ সাধারণত ১,৫০০ byte, কোনো tunnel বা পুরোনো link-এ কম। পথে ছোট MTU-র link পড়লে IPv4 router বড় packet-কে কয়েকটি টুকরোয় ভাগ করতে পারে — fragmentation; টুকরোগুলো জোড়া লাগে শুধু গন্তব্য host-এ। Header-এ “Don’t Fragment” bit চালু থাকলে router ভাগ না করে packet ফেলে দেয় আর উৎসকে ICMP-তে জানায় — এটিই path MTU discovery-র ভিত্তি (পর্ব ২০)। Fragmentation-এর ঘর আর হিসাব পর্ব ১৬-এ; আর IPv6-এ router কখনো ভাগ করে না (পর্ব ২১)।

৯ · AI-এর যুগে network layer

“আমার router-এর routing table বুঝিয়ে দিন” বা “এই packet কোন route-এ যাবে?” — AI এসব প্রশ্নে আত্মবিশ্বাসী, গোছানো উত্তর দেয়। কিন্তু network layer-এ কিছু ভুল AI বারবার করে, আর সেগুলো দেখতে নির্ভুল লাগে:

AI-এর উত্তর মানার আগে — চেকলিস্ট

• প্রতিটি prefix-এর মিল নিজে বাইনারিতে বা ip route get দিয়ে মিলিয়েছি
• Forwarding (longest prefix) আর ACL বা firewall (first match)-এর নিয়ম আলাদা রেখেছি
• কমান্ডগুলো আমার OS বা vendor-এর ডকুমেন্টেশন আর man page-এ আছে কি না দেখেছি
• Route বদলানোর আগে বর্তমান টেবিল সংরক্ষণ করেছি, আর আগে VM বা ল্যাবে চালিয়ে দেখেছি
• Buffer, QoS বা AQM-এর পরামর্শ লোডের সময় ping আর throughput মেপে যাচাই করেছি — শুধু নিজের বা অনুমতিপ্রাপ্ত নেটওয়ার্কে