IPv4 ঠিকানা আর header — class থেকে CIDR

১ · IPv4 ঠিকানা কী চেনায় — বাড়ি নয়, দরজা

পর্ব ১৫-এ দেখেছেন, network স্তরের কাজ হলো packet-কে নেটওয়ার্কের পর নেটওয়ার্ক পেরিয়ে গন্তব্যে পৌঁছানো। পৌঁছাতে হলে প্রথমে দরকার ঠিকানা। ইন্টারনেটের সবচেয়ে প্রচলিত ঠিকানা-ব্যবস্থা হলো IPv4 — Internet Protocol-এর চতুর্থ সংস্করণ, যার মান ১৯৮১ সালের RFC 791. চল্লিশ বছরেরও বেশি পরে, IPv6 (পর্ব ২১) থাকা সত্ত্বেও, আজও ইন্টারনেটের বড় অংশ IPv4-এর ওপর চলে।

এখান থেকেই প্রথম গুরুত্বপূর্ণ কথা: IP ঠিকানা একটি host-কে নয়, host-এর একটি interface-কে চেনায়। কয়েকটি উদাহরণ:

• আপনার ল্যাপটপে Wi-Fi আর Ethernet দুটোই চালু থাকলে ল্যাপটপের দুটি IPv4 ঠিকানা থাকতে পারে — দুই interface-এ দুটি।
• বাসার Wi-Fi router-এর ভেতরের দিকে একটি ঠিকানা (যেমন 192.168.0.1), আর ISP-র দিকে আরেকটি।
• প্রতিটি Linux, Windows বা macOS মেশিনে একটি কাল্পনিক loopback interface থাকে, যার ঠিকানা 127.0.0.1.

আরেকটি সূক্ষ্মতা: IP ঠিকানা বলে যন্ত্রটি কোথায় যুক্ত, যন্ত্রটি কে তা নয়। একই ল্যাপটপ বাসা থেকে অফিসে নিয়ে গেলে নতুন নেটওয়ার্ক থেকে নতুন ঠিকানা পায় (সাধারণত DHCP দিয়ে — পর্ব ১৮)। এর বিপরীতে MAC ঠিকানা (পর্ব ১২) NIC-এর সাথে বাঁধা পরিচয়ের মতো, যদিও আধুনিক ফোন গোপনীয়তার জন্য তা-ও বদলায়।

৩২ বিট আর dotted decimal

৩২ বিটের একটি সংখ্যা মনে রাখা মানুষের পক্ষে কঠিন: 11000000101010000000101001001101. তাই বিটগুলোকে ৮টি করে চার ভাগে ভাগ করা হয়। প্রতিটি ভাগকে বলে octet (৮ বিট = ১ বাইট)। প্রতিটি octet-কে দশমিকে লিখে মাঝে বিন্দু দিলে পাওয়া যায় dotted decimal রূপ:

binary   11000000 . 10101000 . 00001010 . 01001101
decimal     192   .    168   .     10   .     77      =  192.168.10.77
hex          c0        a8         0a         4d       =  0xc0a80a4d
integer  192×2^24 + 168×2^16 + 10×2^8 + 77           =  3232238157

প্রতিটি octet ৮ বিট, তাই এর মান ০ থেকে ২৫৫. মোট ঠিকানা 2³² = ৪,২৯,৪৯,৬৭,২৯৬ — প্রায় ৪২৯ কোটি। ১৯৮০-র দশকে সংখ্যাটি বিশাল মনে হয়েছিল; আজ পৃথিবীর মানুষের সংখ্যাই এর চেয়ে বেশি, আর একেকজনের হাতে ফোন, ল্যাপটপ, স্মার্ট টিভি। ঠিকানার ঘাটতির গল্প অংশ ৬-এ।

২ · Binary ↔ দশমিক — octet-এর হিসাব হাতে

Subnet-এর সব হিসাব আসলে binary-র হিসাব। তাই আগে octet-কে binary-তে আর binary-কে দশমিকে আনার অভ্যাস করে নিই। একটি octet-এর ৮টি বিটের স্থানীয় মান (বাঁ থেকে ডানে):

দশমিক → binary (বিয়োগ পদ্ধতি): বাঁ দিক থেকে প্রতিটি স্থানীয় মান নিয়ে প্রশ্ন করুন — “এটি বাকি সংখ্যা থেকে বিয়োগ করা যায়?” যায় হলে বিট ১, বিয়োগ করুন; না গেলে বিট ০. যেমন ৭৭: ১২৮ যায় না (০); ৬৪ যায় — বাকি ১৩ (১); ৩২ না (০); ১৬ না (০); ৮ যায় — বাকি ৫ (১); ৪ যায় — বাকি ১ (১); ২ না (০); ১ যায় — বাকি ০ (১)। ফল 01001101.

Binary → দশমিক: যে বিটগুলো ১, শুধু তাদের মান যোগ করুন। 10101100 = ১২৮ + ৩২ + ৮ + ৪ = ১৭২. আরও দুটি নিজে মিলিয়ে দেখুন: ২০০ = 11001000 (১২৮ + ৬৪ + ৮), আর 11110000 = ২৪০.

Mask-এর হিসাবে বারবার আসে এমন octet, যেখানে বাঁ দিক থেকে কয়েকটি বিট টানা ১ আর বাকি সব ০. এই আটটি মান মুখস্থ রাখলে পরীক্ষায় অনেক সময় বাঁচে:

শেষ কলামের “block size” পরের অংশে কাজে লাগবে: mask-এর যে octet-এ ১ আর ০ মিশেছে, সেই octet-এ নেটওয়ার্কগুলো ঠিক block size-এর গুণিতকে শুরু হয়। Binary আর সংখ্যা-পদ্ধতির ভিত্তি ঝালাই করতে চাইলে দেখুন Computer Fundamentals-এর সংখ্যা পদ্ধতির পর্ব, আর AND/OR দিয়ে বিট বাছাইয়ের কৌশল C-এর bitwise পর্বে।

৩ · Network অংশ, host অংশ আর classful যুগ

কেন ঠিকানাকে দুই ভাগে ভাগ করা? কারণ router প্রতিটি host-এর জন্য আলাদা নিয়ম রাখতে পারে না — ইন্টারনেটে শত কোটি interface. Router-এর routing table-এ থাকে শুধু নেটওয়ার্কের তালিকা: “192.168.10.x-এর সব ঠিকানা এই দিকে”। ডাকঘরের বাছাই-কর্মী যেমন প্রথমে জেলা দেখে বস্তা ঠিক করেন, বাড়ির নম্বর দেখেন শুধু শেষ ডাকঘর। ঠিকানার শুরুর অংশ (network অংশ) দেখে পথ, শেষের অংশ (host অংশ) দেখে শেষ ধাপের ডেলিভারি।

এবার সেই টেবিল, যা বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় বারবার আসে:

সংখ্যাগুলো কোথা থেকে এলো? Class A-তে network অংশ ৮ বিট, কিন্তু প্রথম বিট বাঁধা (০), তাই স্বাধীন বিট ৭টি — 2⁷ = ১২৮টি নেটওয়ার্ক। এর মধ্যে 0.x.x.x (“এই নেটওয়ার্ক”) আর 127.x.x.x (loopback) সংরক্ষিত, তাই ব্যবহারযোগ্য ১২৬টি। Class B-তে network অংশ ১৬ বিট, প্রথম দুটি বাঁধা (১০), স্বাধীন ১৪ — 2¹⁴. Class C-তে ২৪ − ৩ = ২১. Host অংশ h বিট হলে ঠিকানা 2^hটি, কিন্তু সব-০ (নেটওয়ার্কের নিজের নাম) আর সব-১ (broadcast) বাদ — তাই 2^h − 2. পুরো ঠিকানা-ভান্ডারের অর্ধেক class A, এক-চতুর্থাংশ B, এক-অষ্টমাংশ C, আর D ও E প্রতিটি ১৬ ভাগের এক ভাগ।

দ্রুত class চেনা: শুধু প্রথম octet দেখুন। 10.20.30.40 → ১০, তাই A. 172.20.5.9 → ১৭২, ১২৮–১৯১-এর মধ্যে, তাই B. 203.0.113.200 → C. 224.0.0.5 → D (এটি OSPF router-দের multicast ঠিকানা, পর্ব ২৪)।

Classful ব্যবস্থা কেন ভেঙে পড়ল

সমস্যাটা ছিল মাপের — অনেকটা দর্জির দোকানে শুধু তিনটি সাইজের জামা থাকার মতো: ছোট, বিশাল আর দৈত্যাকার। একটি বিশ্ববিদ্যালয়ের ২,০০০ যন্ত্রের জন্য class C (২৫৪ host) খুব ছোট, তাই দেওয়া হতো class B (৬৫,৫৩৪ host). ব্যবহার হতো ২,০০০ ÷ ৬৫,৫৩৪ ≈ ৩%, বাকি প্রায় ৯৭% ঠিকানা অলস পড়ে থাকত — অথচ অন্য কেউ সেগুলো ব্যবহার করতে পারত না। ১৯৯০-এর দশকের শুরুতে IETF সতর্ক করেছিল যে class B ফুরিয়ে আসছে।

বিকল্প ছিল ২,০০০ যন্ত্রের জন্য ৮টি class C দেওয়া। তাতে অপচয় কমে, কিন্তু নতুন সমস্যা: ইন্টারনেটের প্রতিটি বড় router-এর routing table-এ এই প্রতিষ্ঠানের জন্য একটির বদলে ৮টি লাইন। Routing table-এর দ্রুত বৃদ্ধি তখনকার router-এর মেমরি আর CPU-র জন্য বাস্তব হুমকি ছিল। অর্থাৎ classful ব্যবস্থায় একসাথে দুটি রোগ — ঠিকানার অপচয় আর routing table-এর স্ফীতি। দুটির একটিই ওষুধ এলো: CIDR.

৪ · CIDR — prefix /n, mask, network আর broadcast

CIDR (Classless Inter-Domain Routing, উচ্চারণ “সাইডার”) এসেছে ১৯৯৩ সালের দিকে RFC 1519-এ, আর ২০০৬ সালে RFC 4632 তাকে হালনাগাদ করে। মূল কথা একটাই: network আর host অংশের সীমা আর class দিয়ে বাঁধা নয় — যেকোনো বিটের পরে হতে পারে। সীমা কোথায়, তা ঠিকানার পাশে লিখে দেওয়া হয়:

স্ল্যাশের পরের সংখ্যাকে বলে prefix length. একই তথ্য আরেকভাবে লেখা যায় subnet mask দিয়ে — ৩২ বিটের একটি সংখ্যা, যার প্রথম nটি বিট ১, বাকি সব ০. /26-এর mask: ২৬টি ১, তারপর ৬টি ০ = 11111111.11111111.11111111.11000000 = 255.255.255.192. Linux লেখে prefix (/26), Windows-এর ipconfig দেখায় dotted mask, আর macOS-এর ifconfig mask দেখায় hex-এ (0xffffffc0) — তিনটিই একই জিনিস।

চারটি সূত্র — আর কেন কাজ করে

• Network ঠিকানা = ঠিকানা AND mask. Mask-এর যেখানে ১, সেখানে ঠিকানার বিট টিকে থাকে; যেখানে ০, সেখানে বিট মুছে ০ হয়। অর্থাৎ host অংশ সব-০ — এটি নেটওয়ার্কের “নাম”, routing table-এ এটিই লেখা থাকে।
• Broadcast ঠিকানা = network ঠিকানা OR (NOT mask). Host অংশের সব বিট ১. এই ঠিকানায় পাঠানো packet ওই নেটওয়ার্কের সবার জন্য।
• ব্যবহারযোগ্য পরিসর = network + ১ থেকে broadcast − ১.
• ব্যবহারযোগ্য host-এর সংখ্যা = 2^h − 2, যেখানে h = ৩২ − n. মোট ঠিকানা 2^h, তার দুটি (সব-০ আর সব-১) সংরক্ষিত।

এবার একটি উদাহরণ ধাপে ধাপে। “পরে” চেপে দেখুন 192.168.10.77/26 থেকে কীভাবে network, broadcast আর host-এর পরিসর বের হয়:

সাধারণ prefix-গুলোর একটি টেবিল মনে রাখা কাজের:

/31 আর /32 — সূত্রের ব্যতিক্রম

সূত্র অনুযায়ী /31-এ 2¹ − 2 = ০টি host — অর্থহীন। কিন্তু দুই router-এর মাঝের একটি তারের (point-to-point link) দুই প্রান্তে ঠিক দুটি interface; সেখানে broadcast-এর দরকারই নেই, কারণ “সবাই” মানে তো অন্য প্রান্তের একজন। প্রচলিত /30 দিলে ৪টি ঠিকানার ২টি নষ্ট হয়। তাই ২০০০ সালের RFC 3021 নিয়ম দেয়: point-to-point link-এ /31 ব্যবহার করা যায়, আর দুটি ঠিকানাই host-এর। বড় ISP-তে হাজার হাজার এমন link থাকলে এতে ঠিকানার অর্ধেক বাঁচে। /32 মানে একটিমাত্র ঠিকানা — একটি নির্দিষ্ট host-এর route, বা router-এর কাল্পনিক loopback interface-এর ঠিকানা, যা কোনো একটি তারের ওপর নির্ভর করে না।

হাতে করা হিসাব যন্ত্রে মেলানো যাক। নিচের calculator কয়েকটি CIDR ইনপুটের জন্য binary, mask, network, broadcast, ব্যবহারযোগ্য পরিসর, class আর বিশেষ-ব্লকের নাম ছাপে — Run চাপুন:

// IPv4 calculator: CIDR -> binary, mask, network, broadcast, hosts, class, label.
const toInt = s => s.split(".").reduce((a, o) => a * 256 + Number(o), 0);
const toIp = n => [24, 16, 8, 0].map(s => (n >>> s) & 255).join(".");
const bin = n => toIp(n).split(".").map(o => (+o).toString(2).padStart(8, "0")).join(".");
const maskOf = p => (p === 0 ? 0 : (0xffffffff << (32 - p)) >>> 0);
const SPECIAL = [["0.0.0.0/8", "this network"], ["10.0.0.0/8", "private (RFC 1918)"],
  ["100.64.0.0/10", "shared CGNAT (RFC 6598)"], ["127.0.0.0/8", "loopback"],
  ["169.254.0.0/16", "link-local"], ["172.16.0.0/12", "private (RFC 1918)"],
  ["192.0.2.0/24", "documentation TEST-NET-1"], ["192.168.0.0/16", "private (RFC 1918)"],
  ["198.51.100.0/24", "documentation TEST-NET-2"], ["203.0.113.0/24", "documentation TEST-NET-3"],
  ["224.0.0.0/4", "multicast"], ["240.0.0.0/4", "reserved"]];
const inside = (ip, c) => { const [a, p] = c.split("/"); return ((ip & maskOf(+p)) >>> 0) === toInt(a); };
function classOf(ip) {
  const f = ip >>> 24;
  return f < 128 ? "A (default /8)" : f < 192 ? "B (default /16)" : f < 224 ? "C (default /24)"
       : f < 240 ? "D (multicast, no mask)" : "E (reserved)";
}
function calc(cidr) {
  const [a, p] = cidr.split("/"), ip = toInt(a), pre = +p, m = maskOf(pre);
  const net = (ip & m) >>> 0, bc = (net | ~m) >>> 0;
  const hosts = pre >= 31 ? 2 ** (32 - pre) : 2 ** (32 - pre) - 2;   // /31, /32: no net/bcast
  const first = pre >= 31 ? net : net + 1, last = pre >= 31 ? bc : bc - 1;
  const label = (SPECIAL.find(([c]) => inside(ip, c)) || [0, "public (global)"])[1];
  console.log(`=== ${cidr}  class ${classOf(ip)}  ->  ${label}`);
  console.log(`  address  ${bin(ip)}`);
  console.log(`  mask     ${bin(m)}  = ${toIp(m)}`);
  console.log(`  network  ${toIp(net)}   broadcast ${pre >= 31 ? "(none)" : toIp(bc)}`);
  console.log(`  usable   ${toIp(first)} - ${toIp(last)}   hosts = ${hosts}`);
}
["192.168.10.77/26", "203.0.113.200/28", "172.20.5.9/12", "198.51.100.9/31",
 "100.72.1.5/10", "192.0.2.1/32"].forEach(calc);

=== 192.168.10.77/26  class C (default /24)  ->  private (RFC 1918)
  address  11000000.10101000.00001010.01001101
  mask     11111111.11111111.11111111.11000000  = 255.255.255.192
  network  192.168.10.64   broadcast 192.168.10.127
  usable   192.168.10.65 - 192.168.10.126   hosts = 62
=== 203.0.113.200/28  class C (default /24)  ->  documentation TEST-NET-3
  address  11001011.00000000.01110001.11001000
  mask     11111111.11111111.11111111.11110000  = 255.255.255.240
  network  203.0.113.192   broadcast 203.0.113.207
  usable   203.0.113.193 - 203.0.113.206   hosts = 14
=== 172.20.5.9/12  class B (default /16)  ->  private (RFC 1918)
  address  10101100.00010100.00000101.00001001
  mask     11111111.11110000.00000000.00000000  = 255.240.0.0
  network  172.16.0.0   broadcast 172.31.255.255
  usable   172.16.0.1 - 172.31.255.254   hosts = 1048574
=== 198.51.100.9/31  class C (default /24)  ->  documentation TEST-NET-2
  address  11000110.00110011.01100100.00001001
  mask     11111111.11111111.11111111.11111110  = 255.255.255.254
  network  198.51.100.8   broadcast (none)
  usable   198.51.100.8 - 198.51.100.9   hosts = 2
=== 100.72.1.5/10  class A (default /8)  ->  shared CGNAT (RFC 6598)
  address  01100100.01001000.00000001.00000101
  mask     11111111.11000000.00000000.00000000  = 255.192.0.0
  network  100.64.0.0   broadcast 100.127.255.255
  usable   100.64.0.1 - 100.127.255.254   hosts = 4194302
=== 192.0.2.1/32  class C (default /24)  ->  documentation TEST-NET-1
  address  11000000.00000000.00000010.00000001
  mask     11111111.11111111.11111111.11111111  = 255.255.255.255
  network  192.0.2.1   broadcast (none)
  usable   192.0.2.1 - 192.0.2.1   hosts = 1

একটি নেটওয়ার্ককে ছোট ছোট ভাগে ভাগ করা (subnetting), প্রতিটি বিভাগকে মাপমতো আলাদা prefix দেওয়া (VLSM) আর সেসব হিসাবের ধাপে ধাপে অনুশীলন পাবেন পরের পর্ব — পর্ব ১৭-এ।

৫ · বিশেষ ঠিকানা — সবার জন্য নয় এমন ব্লক

৪২৯ কোটি ঠিকানার সবগুলো সাধারণ host-এর জন্য নয়। কিছু ব্লক নির্দিষ্ট কাজে সংরক্ষিত; এদের পূর্ণ তালিকা রাখে IANA-র “IPv4 Special-Purpose Address Registry” (RFC 6890 এর কাঠামো দেয়)। যেগুলো সবচেয়ে বেশি দেখবেন:

একটি নেটওয়ার্কের নিজস্ব broadcast ঠিকানাকে (যেমন 192.168.10.127) বলে directed broadcast — দূরের কেউ এই ঠিকানায় পাঠালে সেই নেটওয়ার্কের সবার কাছে যাওয়ার কথা। ১৯৯০-এর দশকে আক্রমণকারীরা এর অপব্যবহার করে একটি ছোট অনুরোধকে শত শত উত্তরে বড় করত (“smurf” ধরনের amplification). প্রতিরক্ষা হিসেবে ১৯৯৯ সালের RFC 2644 নিয়ম করে যে router ডিফল্টভাবে directed broadcast পার করবে না — আজকের প্রায় সব router এটাই মানে।

৬ · কে ঠিকানা দেয় — IANA থেকে আপনার ফোন পর্যন্ত

দুই প্রতিষ্ঠান একই public ঠিকানা ব্যবহার করলে ইন্টারনেট বুঝবে না packet কার কাছে যাবে। তাই public ঠিকানা বণ্টন হয় একটি স্তরভিত্তিক শিকলে — ওপর থেকে নিচে বড় ব্লক ভেঙে ছোট ব্লকে:

IANA  (পুরো IPv4 ভান্ডার; বড় ব্লক /8 আকারে দিত)
  │
  ├── AFRINIC   আফ্রিকা
  ├── APNIC     এশিয়া-প্রশান্ত মহাসাগরীয় অঞ্চল (বাংলাদেশসহ)
  ├── ARIN      উত্তর আমেরিকা
  ├── LACNIC    লাতিন আমেরিকা ও ক্যারিবীয় অঞ্চল
  └── RIPE NCC  ইউরোপ, মধ্যপ্রাচ্য ও মধ্য এশিয়ার অংশ
        │
        ├── ISP, মোবাইল অপারেটর, ডেটা সেন্টার (সদস্য বা LIR) — যেমন একটি /22
        │     │
        │     └── গ্রাহক: একটি অফিস /29, বাসার router-এর WAN-এ একটি ঠিকানা
        └── কিছু দেশে মাঝখানে জাতীয় সংস্থা (NIR), যেমন জাপানের JPNIC

সবার ওপরে IANA (Internet Assigned Numbers Authority), যার কাজ এখন ICANN-এর একটি অঙ্গ-প্রতিষ্ঠান পরিচালনা করে। IANA ঠিকানা দেয় পাঁচটি RIR (Regional Internet Registry)-কে। বাংলাদেশ পড়ে APNIC-এর অঞ্চলে; দেশের ISP আর মোবাইল অপারেটররা সাধারণত APNIC-এর সদস্য হয়ে সরাসরি ঠিকানার ব্লক নেয় বলে জানা যায়।

ঠিকানা ফুরিয়ে যাওয়া

২০১১ সালের ফেব্রুয়ারিতে IANA তার শেষ পাঁচটি /8 ব্লক পাঁচ RIR-কে একটি করে দিয়ে দেয় — কেন্দ্রীয় ভান্ডার শূন্য। এরপর প্রতিটি RIR একে একে নিজের “শেষ ব্লক”-এর কঠোর নীতিতে চলে যায়: APNIC প্রায় সাথে সাথেই, ২০১১ সালের এপ্রিলে; RIPE NCC ২০১২ সালে (আর ২০১৯ সালের শেষে জানায় যে সাধারণ বরাদ্দের মতো ঠিকানা আর নেই); ARIN ২০১৫ সালে — তারিখগুলো RIR-গুলোর ঘোষণা অনুযায়ী, বিস্তারিত তাদের ওয়েবসাইটে মিলিয়ে নিন। আজ নতুন প্রতিষ্ঠান সাধারণত অপেক্ষা-তালিকা থেকে খুব ছোট ব্লক পায়, বা অন্যের কাছ থেকে কেনে।

ঘাটতি সামলানোর তিনটি পথ বাস্তবে চলছে:

• NAT আর CGNAT: একটি public ঠিকানার পেছনে অনেক private যন্ত্র — বাসায় router, আর ISP পর্যায়ে carrier-grade NAT (পর্ব ১৯)। বাংলাদেশসহ অনেক দেশে মোবাইল ডেটা ব্যবহারকারীরা সাধারণত CGNAT-এর পেছনে থাকেন বলে ধারণা করা হয়।
• ঠিকানার বাজার: RIR-গুলোর নীতি মেনে ব্লক হস্তান্তর (transfer) আর ভাড়া দেওয়া এখন বৈধ ব্যবসা (ভাবনার প্রশ্ন ৪ দেখুন)।
• IPv6: ১২৮ বিটের ঠিকানা — স্থায়ী সমাধান, পর্ব ২১-এ।

Route aggregation — একটি লাইনে চারটি নেটওয়ার্ক

CIDR-এর দ্বিতীয় বড় উপহার হলো route aggregation (supernetting নামেও পরিচিত): পাশাপাশি কয়েকটি ব্লককে একটি ছোট prefix দিয়ে একসাথে ঘোষণা করা। ধরুন একটি ISP পেয়েছে 198.18.0.0/22 (উদাহরণের জন্য benchmarking-এর সংরক্ষিত ব্লক 198.18.0.0/15 থেকে নেওয়া), আর চারটি গ্রাহককে দিয়েছে একটি করে /24:

198.18.0.0/24   তৃতীয় octet  0 = 000000 00
198.18.1.0/24   তৃতীয় octet  1 = 000000 01
198.18.2.0/24   তৃতীয় octet  2 = 000000 10
198.18.3.0/24   তৃতীয় octet  3 = 000000 11
                                 ──────
প্রথম 16 + 6 = 22 বিট চারটিতেই এক   →   একটি route: 198.18.0.0/22

ইন্টারনেটের বাকি সবাইকে ISP চারটি নয়, একটি route জানায়: “198.18.0.0/22 আমার দিকে”। ভেতরে কোন /24 কোন গ্রাহকের, তা শুধু ISP জানে — ঠিক যেমন বিদেশের ডাকঘর শুধু “বাংলাদেশ” দেখে বস্তা পাঠায়, জেলা-থানা দেখে দেশের ভেতরের ডাকঘর। শর্ত দুটি: ব্লকগুলো পাশাপাশি হতে হবে, আর শুরুটা block size-এর গুণিতকে (aligned). যেমন 198.18.1.0/24 আর 198.18.2.0/24 পাশাপাশি হলেও একটি /23 হয় না — তৃতীয় octet ১ (00000001) আর ২ (00000010) সপ্তম বিটেই আলাদা; /23 হতে পারে 0–1 বা 2–3 জোড়া।

কোনো গ্রাহক (ধরুন 198.18.2.0/24) অন্য ISP-তে চলে গেলে নতুন ISP শুধু সেই /24 ঘোষণা করে। তখন router-দের কাছে দুটি মিলে যাওয়া route থাকে — /22 আর /24 — আর তারা বেছে নেয় যেটি বেশি নির্দিষ্ট (লম্বা prefix). এই নিয়মের নাম longest prefix match; এর পুরো কৌশল পর্ব ২২-এ, আর ISP-দের মধ্যে route ঘোষণার protocol BGP পর্ব ২৫-এ। Aggregation না থাকলে বিশ্বের routing table অনেক আগেই অচল হয়ে যেত; তবু আজ পুরো ইন্টারনেটের IPv4 routing table-এ প্রায় দশ লাখের কাছাকাছি prefix আছে বলে বিভিন্ন পরিমাপে দেখা যায়।

৭ · IPv4 header — ঘর ধরে ধরে

ঠিকানা হলো খামের ওপর লেখা তথ্যের একটি অংশ মাত্র। পুরো খামটি — IPv4 header — দেখতে এমন (RFC 791-এর ছবির মতো, প্রতি সারি ৩২ বিট = ৪ বাইট):

 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
┌───────┬───────┬───────────┬───┬───────────────────────────────┐
│Version│  IHL  │    DSCP   │ECN│          Total Length         │
├───────┴───────┴───────────┴───┼─────┬─────────────────────────┤
│         Identification        │Flags│     Fragment Offset     │
├───────────────┬───────────────┼─────┴─────────────────────────┤
│      TTL      │    Protocol   │        Header Checksum        │
├───────────────┴───────────────┴───────────────────────────────┤
│                         Source Address                        │
├───────────────────────────────────────────────────────────────┤
│                      Destination Address                      │
├───────────────────────────────────────────────────────────────┤
│                 Options (if IHL > 5) + padding                │
└───────────────────────────────────────────────────────────────┘

Option ছাড়া header পাঁচ সারি = ২০ বাইট। প্রতিটি ঘরের কাজ:

এবার একটি capture করা packet-এর প্রথম ২০ বাইট বাইট ধরে পড়া যাক। এটি একটি container (10.0.2.100) থেকে একটি ওয়েব সার্ভারে (192.0.2.80) পাঠানো TCP সংযোগের প্রথম packet (SYN, পর্ব ২৯)। “পরে” চাপুন:

45 00 00 3c 3a 7c 40 00 40 06 31 8c 0a 00 02 64 c0 00 02 50

এখন উল্টো কাজ: ঘরগুলোর মান দিয়ে header বানানো, checksum হিসাব, আর একটি ভিন্ন capture করা header পড়ে ঘরে ঘরে ভাগ করা। বহু-বাইটের ঘর নেটওয়ার্কে যায় big-endian ক্রমে (বড় বাইট আগে) — একে বলে network byte order; কোডে তাই len >> 8 আগে, len & 255 পরে। (x86-এর মতো little-endian CPU-তে C প্রোগ্রাম এজন্য htons/htonl ডাকে — পর্ব ৪১-এ socket কোডে দেখবেন।)

// IPv4 header: build 20 bytes from fields, then parse hex back into fields.
const sum16 = b => { let s = 0;                           // one's-complement sum
  for (let i = 0; i < b.length; i += 2) s += (b[i] << 8) | b[i + 1];
  while (s > 0xffff) s = (s & 0xffff) + (s >>> 16); return s; };
const hex = b => b.map(x => x.toString(16).padStart(2, "0")).join("");
function build(f) {
  const ip = s => s.split(".").map(Number), frag = (f.df << 14) | (f.mf << 13) | f.off;
  const b = [(4 << 4) | 5, (f.dscp << 2) | f.ecn, f.len >> 8, f.len & 255,
    f.id >> 8, f.id & 255, frag >> 8, frag & 255, f.ttl, f.proto, 0, 0,  // checksum = 0
    ...ip(f.src), ...ip(f.dst)];
  const c = ~sum16(b) & 0xffff; b[10] = c >> 8; b[11] = c & 255; return b;
}
function parse(h) {
  const b = h.match(/../g).map(x => parseInt(x, 16)), u16 = i => (b[i] << 8) | b[i + 1];
  const ihl = b[0] & 15, off = u16(6) & 0x1fff, name = { 1: "ICMP", 6: "TCP", 17: "UDP" };
  console.log(`  version=${b[0] >> 4} IHL=${ihl} (${ihl * 4} B) DSCP=${b[1] >> 2} ECN=${b[1] & 3}` +
              ` total=${u16(2)} B id=0x${u16(4).toString(16)}`);
  console.log(`  DF=${(b[6] >> 6) & 1} MF=${(b[6] >> 5) & 1} offset=${off} (= ${off * 8} B)` +
              ` TTL=${b[8]} protocol=${b[9]} (${name[b[9]] || "?"})`);
  console.log(`  checksum=0x${hex(b.slice(10, 12))} -> ` +
              (sum16(b.slice(0, ihl * 4)) === 0xffff ? "OK" : "BAD"));
  console.log(`  src=${b.slice(12, 16).join(".")} dst=${b.slice(16, 20).join(".")}` +
              ` payload=${u16(2) - ihl * 4} B`);
}
const syn = build({ dscp: 0, ecn: 0, len: 60, id: 0x3a7c, df: 1, mf: 0, off: 0,
                    ttl: 64, proto: 6, src: "10.0.2.100", dst: "192.0.2.80" });
console.log("built:  " + hex(syn).replace(/(....)(?!$)/g, "$1 "));
parse(hex(syn));
const cap = "458805dc8e2120b93911665fc6336407cb007114";       // a captured fragment
console.log("captured: " + cap.replace(/(....)(?!$)/g, "$1 "));
parse(cap);

built:  4500 003c 3a7c 4000 4006 318c 0a00 0264 c000 0250
  version=4 IHL=5 (20 B) DSCP=0 ECN=0 total=60 B id=0x3a7c
  DF=1 MF=0 offset=0 (= 0 B) TTL=64 protocol=6 (TCP)
  checksum=0x318c -> OK
  src=10.0.2.100 dst=192.0.2.80 payload=40 B
captured: 4588 05dc 8e21 20b9 3911 665f c633 6407 cb00 7114
  version=4 IHL=5 (20 B) DSCP=34 ECN=0 total=1500 B id=0x8e21
  DF=0 MF=1 offset=185 (= 1480 B) TTL=57 protocol=17 (UDP)
  checksum=0x665f -> OK
  src=198.51.100.7 dst=203.0.113.20 payload=1480 B

৮ · Fragmentation আর reassembly — বড় datagram ছোট রাস্তায়

প্রতিটি link একটি সর্বোচ্চ আকারের packet বহন করতে পারে — তার MTU. সাধারণ Ethernet-এ ১৫০০ বাইট, PPPoE-র broadband-এ ১৪৯২, অনেক VPN tunnel-এ আরও কম, আর data center-এর jumbo frame-এ প্রায় ৯০০০. RFC 791 সব host-কে অন্তত ৫৭৬ বাইটের datagram গ্রহণ করতে বলে, আর IPv4-এর জন্য সর্বনিম্ন MTU ৬৮ বাইট। এখন ধরুন একটি ৪০০০ বাইটের datagram (বড় MTU-র একটি link থেকে আসা) এমন একটি router-এ পৌঁছাল, যার পরের link-এর MTU ১৫০০. DF = ০ হলে router সেটিকে টুকরো করে — একে বলে fragmentation. আর গন্তব্যে টুকরো জোড়া লাগানো — reassembly.

নিয়মগুলো

• প্রতিটি টুকরো একটি পূর্ণ IP datagram — নিজস্ব header-সহ; Identification, উৎস, গন্তব্য আর protocol মূলটির মতোই।
• শেষটি ছাড়া প্রতিটি টুকরোর ডেটা ৮-এর গুণিতক বাইট; offset লেখা হয় ৮ বাইটের এককে।
• শেষটি ছাড়া সব টুকরোয় MF = ১; শেষটিতে MF = ০.
• প্রতিটি টুকরোর Total Length আর checksum নিজের মতো। জোড়া লাগায় শুধু চূড়ান্ত গন্তব্য — কারণ টুকরোগুলো ভিন্ন পথে যেতে পারে, আর মাঝের router-কে সরল রাখাই নকশার নীতি।

কেন ৮ বাইটের একক? — ছোট্ট একটি প্রমাণ

Flags আর offset মিলে একটি ১৬-বিটের ঘর: ৩ বিট flag, বাকি ১৩ বিট offset. ১৩ বিটে 2¹³ = ৮১৯২টি মান (০–৮১৯১)। কিন্তু datagram-এর ডেটা হতে পারে প্রায় ৬৫,৫৩৫ বাইট পর্যন্ত। বাইটের এককে offset লিখলে ৮১৯১-এর পরের বাইট চেনানো যেত না। একক u বাইট হলে সর্বোচ্চ ৮১৯১u বাইট চেনানো যায়; ৬৫,৫৩৫ ÷ ৮১৯২ ≈ ৭.৯৯৯৯, তাই দরকার u ≥ ৮, আর ৮ হলো সবচেয়ে ছোট দুইয়ের ঘাত যা চলে। সর্বোচ্চ offset তাই ৮১৯১ × ৮ = ৬৫,৫২৮ বাইট — সর্বোচ্চ ডেটার (৬৫,৫৩৫ − ২০ = ৬৫,৫১৫) চেয়ে বেশি, তাই যথেষ্ট। এর দাম: শেষটি ছাড়া প্রতিটি টুকরোর ডেটা ৮-এর গুণিতক হতেই হবে।

পূর্ণ সমাধান করা উদাহরণ

প্রশ্ন: ৪০০০ বাইটের একটি IPv4 datagram (header ২০ বাইট, option নেই, Identification ধরা যাক 0x1f2e) MTU ১৫০০-এর link-এ পাঠাতে হবে। প্রতিটি টুকরোর Total Length, offset আর MF লিখুন।

সমাধান: ডেটা D = ৪০০০ − ২০ = ৩৯৮০ বাইট। প্রতি টুকরোয় সর্বোচ্চ ডেটা ১৫০০ − ২০ = ১৪৮০; ১৪৮০ ÷ ৮ = ১৮৫, পূর্ণসংখ্যা, তাই P = ১৪৮০. টুকরো = ⌈৩৯৮০ ÷ ১৪৮০⌉ = ⌈২.৬৯⌉ = ৩. ধাপে ধাপে দেখুন:

এবার একই হিসাব কয়েকটি MTU-র জন্য, সাথে প্রাপকের জোড়া লাগানোর যাচাই — এলোমেলো ক্রমে আসা আর একটি টুকরো হারানো, দুই ক্ষেত্রেই:

// IPv4 fragmentation: split one datagram for an MTU, then check reassembly.
const HDR = 20;                                    // IPv4 header without options
function fragment(total, mtu) {
  const data = total - HDR;
  const chunk = Math.floor((mtu - HDR) / 8) * 8;   // non-last pieces: multiple of 8
  const out = [];
  for (let off = 0; off < data; off += chunk) {
    const n = Math.min(chunk, data - off);
    out.push({ total: n + HDR, data: n, off, mf: off + n < data ? 1 : 0 });
  }
  return out;
}
function reassemble(frags, data) {                 // receiver: any arrival order
  const got = [...frags].sort((a, b) => a.off - b.off);
  let next = 0;
  for (const f of got) { if (f.off !== next) return `hole at byte ${next}`; next += f.data; }
  const last = got[got.length - 1];
  return last.mf === 0 && next === data ? `OK, ${next} data bytes` : "last fragment missing";
}
for (const mtu of [1500, 1492, 576]) {
  const fr = fragment(4000, mtu);
  console.log(`--- 4000-byte datagram, MTU ${mtu}: ${fr.length} fragments ---`);
  console.log(" #  total  data  offset(x8)  offset(bytes)  MF");
  fr.forEach((f, i) => console.log(`${String(i + 1).padStart(2)}  ${String(f.total).padStart(5)}` +
    `  ${String(f.data).padStart(4)}  ${String(f.off / 8).padStart(10)}` +
    `  ${String(f.off).padStart(13)}  ${f.mf}`));
  const sent = fr.reduce((s, f) => s + f.total, 0);
  console.log(`bytes on the wire: ${sent} (extra headers: ${sent - 4000})`);
}
const fr = fragment(4000, 1500);
console.log("reassembly, arrival order 3,1,2: " + reassemble([fr[2], fr[0], fr[1]], 3980));
console.log("reassembly, fragment 2 lost:     " + reassemble([fr[0], fr[2]], 3980));

--- 4000-byte datagram, MTU 1500: 3 fragments ---
 #  total  data  offset(x8)  offset(bytes)  MF
 1   1500  1480           0              0  1
 2   1500  1480         185           1480  1
 3   1040  1020         370           2960  0
bytes on the wire: 4040 (extra headers: 40)
--- 4000-byte datagram, MTU 1492: 3 fragments ---
 #  total  data  offset(x8)  offset(bytes)  MF
 1   1492  1472           0              0  1
 2   1492  1472         184           1472  1
 3   1056  1036         368           2944  0
bytes on the wire: 4040 (extra headers: 40)
--- 4000-byte datagram, MTU 576: 8 fragments ---
 #  total  data  offset(x8)  offset(bytes)  MF
 1    572   552           0              0  1
 2    572   552          69            552  1
 3    572   552         138           1104  1
 4    572   552         207           1656  1
 5    572   552         276           2208  1
 6    572   552         345           2760  1
 7    572   552         414           3312  1
 8    136   116         483           3864  0
bytes on the wire: 4140 (extra headers: 140)
reassembly, arrival order 3,1,2: OK, 3980 data bytes
reassembly, fragment 2 lost:     hole at byte 1480

আজ কেন fragmentation এড়ানো হয়

১৯৮৭ সালে Christopher Kent আর Jeffrey Mogul-এর বিখ্যাত প্রবন্ধ “Fragmentation Considered Harmful” যে যুক্তিগুলো দেয়, সেগুলো আজও সত্য:

• ক্ষতি গুণ হয়: প্রতিটি টুকরো স্বাধীনভাবে p সম্ভাবনায় হারালে n টুকরোর datagram টেকে (১ − p)ⁿ সম্ভাবনায়। p = ১% হলে ৩ টুকরোয় datagram হারানোর সম্ভাবনা ≈ ২.৯৭%, ৮ টুকরোয় ≈ ৭.৭৩% — একটি হারালেই সব বৃথা।
• Port থাকে শুধু প্রথম টুকরোয়: firewall, NAT আর load balancer পরের টুকরোগুলো চিনতে পারে না; অনেকে সেগুলো ফেলে দেয়।
• প্রাপকের বোঝা আর আক্রমণের সুযোগ: জোড়া লাগাতে মেমরি আর টাইমার লাগে। ১৯৯০-এর দশকে একে অপরের ওপর চেপে বসা (overlapping) টুকরো পাঠিয়ে কিছু OS-কে অচল করার ঘটনা ঘটেছিল (“teardrop” নামে পরিচিত), আর অসমাপ্ত টুকরোর বন্যা দিয়ে reassembly-র মেমরি ভরিয়ে ফেলা যায়। প্রতিরক্ষা: আধুনিক stack overlapping টুকরো বাতিল করে, reassembly-র মেমরিতে সীমা রাখে, আর firewall অস্বাভাবিক টুকরো আটকায়।
• Identification ফুরিয়ে যাওয়া: ১৬ বিটে মাত্র ৬৫,৫৩৬টি নম্বর; উচ্চ গতিতে একই নম্বর দ্রুত ফিরে আসে, আর ভিন্ন datagram-এর টুকরো ভুল করে জোড়া লাগতে পারে (RFC 4963 এই সমস্যার বর্ণনা দেয়)।

Path MTU Discovery

সমাধান হলো প্রেরক নিজেই শুরু থেকে এমন মাপে পাঠাবে, যা পুরো পথে ভাঙতে হবে না। ১৯৯০ সালের RFC 1191-এর Path MTU Discovery: প্রেরক DF = ১ দিয়ে পাঠায় (stepper-এর SYN-এর মতো)। পথের কোনো router-এর পরের link ছোট হলে সে packet ফেলে দেয় আর প্রেরককে ICMP “Destination Unreachable — Fragmentation Needed” (type 3, code 4) পাঠায়, সাথে পরের link-এর MTU. প্রেরক মাপ কমিয়ে আবার পাঠায়। ICMP-র বার্তাগুলোর বিস্তারিত পর্ব ২০-এ।

৯ · নিজের মেশিনে IPv4 — Linux, Windows আর container

তত্ত্ব শেষে নিজের চোখে দেখা যাক। নিচের স্ক্রিপ্ট এই পাতার কোড চালানোর container-এ তিনটি কাজ করে: iproute2-এর ip -4 -br addr দিয়ে ঠিকানা দেখায়, kernel-এর নিজের হিসাব /proc/net/fib_trie থেকে (পর্ব ০৬-এর procfs) local আর broadcast ঠিকানা পড়ে, আর bash-এর পূর্ণসংখ্যার হিসাব দিয়ে প্রতিটি ঠিকানার mask, network আর broadcast বের করে। টুল না থাকলে স্ক্রিপ্ট সে কথা জানায়:

to_int() { local IFS=.; set -- $1; echo $(( ($1 << 24) | ($2 << 16) | ($3 << 8) | $4 )); }
to_ip() { echo "$(( $1 >> 24 & 255 )).$(( $1 >> 16 & 255 )).$(( $1 >> 8 & 255 )).$(( $1 & 255 ))"; }
echo "== 1. ip -4 -br addr =="
if command -v ip >/dev/null; then ip -4 -br addr; else echo "  ip নেই"; fi
echo "== 2. /proc/net/fib_trie: local and broadcast entries =="
if [ -r /proc/net/fib_trie ]; then
  awk '/\/32 host LOCAL/ {print "  LOCAL     " p} /\/32 link BROADCAST/ {print "  BROADCAST " p}
       {p = $2}' /proc/net/fib_trie | sort -u
else echo "  /proc/net/fib_trie পড়া যাচ্ছে না"; fi
echo "== 3. network and broadcast, computed in bash =="
if command -v ip >/dev/null; then
  list=$(ip -4 -o addr show | awk '{print $2, $4}')
else list="lo 127.0.0.1/8"; echo "  (ip নেই, উদাহরণ হিসেবে loopback)"; fi
while read -r dev cidr; do
  [ -n "$cidr" ] || continue
  a=$(to_int "${cidr%/*}"); p=${cidr#*/}
  m=$(( p == 0 ? 0 : (0xFFFFFFFF << (32 - p)) & 0xFFFFFFFF ))
  net=$(( a & m )); bc=$(( net | (~m & 0xFFFFFFFF) ))
  echo "  $dev $cidr  mask=$(to_ip $m)  network=$(to_ip $net)  broadcast=$(to_ip $bc)  hosts=$(( p >= 31 ? 1 << (32 - p) : (1 << (32 - p)) - 2 ))"
done <<< "$list"

== 1. ip -4 -br addr ==
lo               UNKNOWN        127.0.0.1/8
tap0             UNKNOWN        10.0.2.100/24
== 2. /proc/net/fib_trie: local and broadcast entries ==
  BROADCAST 10.0.2.255
  BROADCAST 127.255.255.255
  LOCAL     10.0.2.100
  LOCAL     127.0.0.1
== 3. network and broadcast, computed in bash ==
  lo 127.0.0.1/8  mask=255.0.0.0  network=127.0.0.0  broadcast=127.255.255.255  hosts=16777214
  tap0 10.0.2.100/24  mask=255.255.255.0  network=10.0.2.0  broadcast=10.0.2.255  hosts=254

Windows-এ একই তথ্য দেয় ipconfig — prefix নয়, dotted mask দেখায়। নিচে একটি সাধারণ ল্যাপটপের উদাহরণ (চালানো যাবে না, শুধু পড়ার জন্য):

PS> ipconfig
Wireless LAN adapter Wi-Fi:
   IPv4 Address. . . . . . . . . . . : 192.168.0.105
   Subnet Mask . . . . . . . . . . . : 255.255.255.0
   Default Gateway . . . . . . . . . : 192.168.0.1

Ethernet adapter Ethernet:
   Autoconfiguration IPv4 Address. . : 169.254.83.12
   Subnet Mask . . . . . . . . . . . : 255.255.0.0
   Default Gateway . . . . . . . . . :

Wi-Fi adapter স্বাভাবিক: 192.168.0.105/24, default gateway বাসার router. কিন্তু Ethernet adapter-এ “Autoconfiguration” আর 169.254.83.12 — অর্থাৎ তার লাগানো আছে, কিন্তু DHCP সার্ভার উত্তর দেয়নি, তাই Windows link-local ঠিকানা (APIPA) বসিয়েছে আর gateway ফাঁকা। “তার লাগানো, তবু ইন্টারনেট নেই” অভিযোগে প্রথমেই এটি দেখুন। macOS-এ ifconfig en0 একই তথ্য দেয়, mask লেখে hex-এ (netmask 0xffffff00).

১০ · AI-এর যুগে IPv4-এর হিসাব

“192.168.10.77/26-এর broadcast কত?” — AI এক সেকেন্ডে উত্তর দেবে, আর বেশিরভাগ সময় ঠিকও হবে। সমস্যা হলো বাকি সময়টুকু: ভুল উত্তরও একই আত্মবিশ্বাসে আসে। Subnet-এর হিসাব ভাষার মডেলের কাছে আসলে বিটের হিসাব নয়, শব্দের অনুমান — তাই এক-বিট এদিক-ওদিক হওয়া খুব স্বাভাবিক। এই বিষয়ে AI-এর পরিচিত ভুল:

AI-এর দেওয়া IPv4-উত্তর গ্রহণের আগে — চেকলিস্ট

• Network ঠিকানা block size-এর গুণিতক আর broadcast পরের network-এর ঠিক আগের ঠিকানা কি না নিজে মিলিয়েছি
• Host-সংখ্যায় −২ ধরা হয়েছে, আর /31, /32 হলে ব্যতিক্রম মানা হয়েছে
• বিশেষ ব্লকের সীমা (172.16.0.0/12, 100.64.0.0/10…) নির্ভরযোগ্য উৎসে মিলিয়েছি
• Fragment-এর হিসাবে offset ৮ বাইটের এককে আর ডেটা ৮-এর গুণিতক কি না দেখেছি
• কমান্ডগুলো আধুনিক আর আমার OS-এর (ip/ss বনাম ipconfig), man page দেখে নিশ্চিত হয়েছি
• Firewall-এর পরামর্শে ঢালাও “ICMP বন্ধ” বা “সব খুলে দিন” নেই; সম্ভব হলে নিজের ল্যাব বা VM-এ packet capture করে মিলিয়েছি