Subnetting, CIDR আর VLSM — ধাপে ধাপে হিসাব

১ · কেন ভাগ করবেন — এক মহল্লা থেকে অনেক সেক্টর

পর্ব ১৬-এ (IPv4 ঠিকানা আর header) দেখেছেন, একটি IPv4 ঠিকানা ৩২ bit-এর, চারটি ৮ bit-এর ভাগে (octet) লেখা হয় — যেমন 192.168.10.77. ঠিকানার শুরুর কিছু bit হলো নেটওয়ার্কের নাম (prefix), বাকিটা host-এর নম্বর। কতটি bit prefix, তা বলে CIDR-এর /n লেখা বা সমতুল্য subnet mask: /24 = 255.255.255.0. Host-অংশের সব bit ০ হলে সেটি network address, সব bit ১ হলে broadcast address, আর দুটোর মাঝের ঠিকানাগুলো যন্ত্রকে দেওয়া যায়। এই পর্বের পুরো হিসাব এই একটি অনুচ্ছেদের ওপর দাঁড়িয়ে।

এখন প্রশ্ন: একটি প্রতিষ্ঠান একটি বড় ঠিকানা-ব্লক পেলে সব যন্ত্রকে একটিই বড় নেটওয়ার্কে রাখবে, নাকি ভাগ করবে? ভাগ করার কাজটির নাম subnetting.

চারটি কারণ

২ · Host bit ধার করা — ২^s আর ২^h − ২-এর হিসাব

একটি /24 ব্লক নিন: 192.168.10.0/24. প্রথম ২৪ bit নেটওয়ার্ক, শেষ ৮ bit host. এখন host-অংশের বাঁ দিক থেকে কয়েকটি bit “ধার” নিয়ে সেগুলোকে নেটওয়ার্ক-অংশে যোগ করা হলো। ধার নেওয়া bit-গুলো হলো subnet bit (সংখ্যা s), বাকিগুলো host bit (সংখ্যা h). নতুন prefix = ২৪ + s, আর s + h = ৮।

 192.168.10.0/24 থেকে ৩ bit ধার → /27

 ┌──────────── network (24 bit) ───────────┬─ subnet ─┬── host ──┐
 │ 11000000 . 10101000 . 00001010 .        │   s s s  │ h h h h h│
 │   192        168        10              │  3 bit   │  5 bit   │
 └─────────────────────────────────────────┴──────────┴──────────┘
 mask: 11111111.11111111.11111111.111 00000 = 255.255.255.224

দুটি সূত্র, আর কেন সেগুলো সত্য

প্রমাণ: প্রতিটি subnet bit ০ বা ১ হতে পারে, আর s-টি bit স্বাধীনভাবে বদলায়, তাই আলাদা subnet-নম্বর ২ × ২ × … (s বার) = ২^s. একই যুক্তিতে একটি subnet-এর ভেতরে host-অংশের আলাদা মান ২^h. এর মধ্যে দুটি মান সংরক্ষিত: সব bit ০ (network address — subnet-টির নিজের নাম, routing table-এ এটিই লেখা হয়) আর সব bit ১ (broadcast address — “এই subnet-এর সবাই”). তাই যন্ত্রকে দেওয়া যায় ২^h − ২টি। উদাহরণ: /27-এ h = ৫, ২^৫ − ২ = ৩০টি host; s = ৩, তাই একটি /24 থেকে ৮টি /27.

উল্টো দিকের প্রশ্নই পরীক্ষায় বেশি আসে: “প্রতিটি subnet-এ অন্তত ৫০টি host লাগবে, mask কত?” — সবচেয়ে ছোট h খুঁজুন যাতে ২^h − ২ ≥ ৫০। h = ৫ দিলে ৩০ (কম), h = ৬ দিলে ৬২ (যথেষ্ট)। তাই h = ৬, prefix = ৩২ − ৬ = /26. আর “অন্তত ৬টি subnet লাগবে” — সবচেয়ে ছোট s যাতে ২^s ≥ ৬: s = ৩ (৮টি)।

৩ · দুই পদ্ধতি পাশাপাশি — block size বনাম binary AND

Subnetting-এর সবচেয়ে সাধারণ প্রশ্ন: “192.168.10.77/27 — network, broadcast, প্রথম আর শেষ ব্যবহারযোগ্য ঠিকানা কত?” উত্তর বের করার দুটি পদ্ধতি আছে। Router নিজে দ্বিতীয়টি করে; মানুষ মাথায় দ্রুত করে প্রথমটি। দুটোই জানা দরকার — একটি দিয়ে উত্তর, অন্যটি দিয়ে যাচাই।

পদ্ধতি ক — Block size (“magic number”)

1. আগ্রহের octet খুঁজুন: mask-এর যে octet ২৫৫ নয় আর ০-ও নয় (বা prefix যে octet-এ শেষ হয়)। /27 = ৮ + ৮ + ৮ + ৩, তাই চতুর্থ octet, mask-এর মান ২২৪।
2. Block size = ২৫৬ − ২২৪ = ৩২। Subnet-গুলো শুরু হয় ৩২-এর গুণিতকে: 0, 32, 64, 96, 128, 160, 192, 224.
3. Host-এর মান কোন দুই গুণিতকের মাঝে? ৭৭ আছে ৬৪ আর ৯৬-এর মাঝে। তাই network = 192.168.10.64.
4. Broadcast = পরের network − ১ = ৯৬ − ১ = 192.168.10.95.
5. ব্যবহারযোগ্য: network + ১ থেকে broadcast − ১ = .65 থেকে .94, মোট ৩০টি।

পদ্ধতি খ — Binary AND

Router-এর কাছে mask একটি bit-এর ছাঁকনি: ঠিকানা আর mask-এর প্রতিটি bit জোড়ায় AND করলে (দুটোই ১ হলে ১, নইলে ০) host-অংশ মুছে গিয়ে network address থাকে। Broadcast পেতে network-এর host-অংশের সব bit ১ করে দিন (mask উল্টে OR).

              ঠিকানা      192.168.10. 0100 1101   (77)
          AND mask        255.255.255. 1110 0000   (224)
          ─────────────────────────────────────────
              network     192.168.10. 0100 0000   (64)   ← host bit মুছে গেল
           OR ~mask       000.000.000. 0001 1111   (31)
          ─────────────────────────────────────────
              broadcast   192.168.10. 0101 1111   (95)   ← host bit সব ১

দুটি পদ্ধতি কেন একই উত্তর দেয়: ব্লক B = ২^h হলে mask-এর আগ্রহের octet = ২৫৬ − B, যার নিচের h-টি bit ০ আর ওপরের bit-গুলো ১. কোনো মান x-কে এর সাথে AND করলে x-এর নিচের h-টি bit মুছে যায় — অর্থাৎ ফল x − (x mod B), যা B-এর সবচেয়ে কাছের নিচের গুণিতক, ⌊x ÷ B⌋ × B. Block size পদ্ধতি ঠিক এই ভাগফলটাই মাথায় করে: ৭৭ − (৭৭ mod ৩২) = ৭৭ − ১৩ = ৬৪। এ জন্যই block size সবসময় ২-এর ঘাত, আর এ জন্যই subnet সবসময় তার নিজের block size-এর গুণিতকে শুরু হয় — পরে VLSM-এ এই সত্যটিই কাজে লাগবে।

চতুর্থ octet-এ আরেকটি — হাতে করে দেখুন

10.0.5.130/26: /26-এ mask-এর চতুর্থ octet ১৯২, block = ২৫৬ − ১৯২ = ৬৪। সিঁড়ি 0, 64, 128, 192 — ১৩০ আছে ১২৮ আর ১৯২-এর মাঝে। Network 10.0.5.128, broadcast 10.0.5.191, ব্যবহারযোগ্য .129–.190, ৬২টি host.

৪ · তৃতীয় আর দ্বিতীয় octet-এ mask — একই কৌশল, বড় সিঁড়ি

Prefix ২৪-এর ছোট হলে আগ্রহের octet সরে যায় বাঁয়ে। পদ্ধতি হুবহু একই, শুধু দুটি জিনিস মনে রাখতে হয়: আগ্রহের octet-এর ডানের সব octet network-এ ০ আর broadcast-এ ২৫৫, আর host-এর সংখ্যায় ডানের সব bit-ও গুনতে হয়।

উদাহরণ ১ — তৃতীয় octet: 172.16.45.200/20

• /20 = ৮ + ৮ + ৪, তাই আগ্রহের octet তৃতীয়টি; সেখানে mask 11110000 = ২৪০। Mask 255.255.240.0.
• Block = ২৫৬ − ২৪০ = ১৬ (তৃতীয় octet-এ)। সিঁড়ি 0, 16, 32, 48… — ৪৫ আছে ৩২ আর ৪৮-এর মাঝে।
• Network = 172.16.32.0 (তৃতীয় octet ৩২, চতুর্থ ০)।
• Broadcast = পরের network 172.16.48.0 − ১ = 172.16.47.255.
• ব্যবহারযোগ্য 172.16.32.1 থেকে 172.16.47.254; host bit h = ৩২ − ২০ = ১২, তাই ২^১২ − ২ = ৪,০৯৪টি।

লক্ষ করুন, এই subnet-এর ভেতরে 172.16.40.0 বা 172.16.47.0-এর মতো “শূন্যে শেষ” ঠিকানাও সাধারণ host ঠিকানা — সেগুলো network address নয়। /20-এ network একটিই, 172.16.32.0. শেষ octet ০ দেখেই “এটি network” ধরে নেওয়া একটি সাধারণ ভুল।

উদাহরণ ২ — দ্বিতীয় octet: 10.77.130.5/11

• /11 = ৮ + ৩, আগ্রহের octet দ্বিতীয়টি; mask সেখানে 11100000 = ২২৪, পুরো mask 255.224.0.0.
• Block = ২৫৬ − ২২৪ = ৩২ (দ্বিতীয় octet-এ)। ৭৭ আছে ৬৪ আর ৯৬-এর মাঝে।
• Network 10.64.0.0, broadcast 10.95.255.255 (পরের network 10.96.0.0-এর ঠিক আগে)।
• ব্যবহারযোগ্য 10.64.0.1 থেকে 10.95.255.254; h = ২১, host = ২^২১ − ২ = ২০,৯৭,১৫০টি।

দুটি host কি একই subnet-এ?

দুটি ঠিকানার network address আলাদা করে বের করুন — একই mask দিয়ে। মিললে তারা একই subnet-এ, router ছাড়াই সরাসরি (ARP দিয়ে MAC জেনে) কথা বলবে; না মিললে প্রেরক packet পাঠাবে gateway-তে। প্রতিটি কম্পিউটার প্রতিটি packet পাঠানোর আগে ঠিক এই প্রশ্নটিই করে।

• 192.168.10.70 আর 192.168.10.100, /27: block ৩২; ৭০ → ৬৪, ১০০ → ৯৬। আলাদা subnet.
• একই দুটি ঠিকানা, /26: block ৬৪; ৭০ → ৬৪, ১০০ → ৬৪। একই subnet. উত্তর ঠিকানার ওপর নয়, mask-এর ওপর নির্ভর করে।
• 172.16.33.1 আর 172.16.46.9, /20: তৃতীয় octet-এ block ১৬; ৩৩ → ৩২, ৪৬ → ৩২। একই subnet, যদিও তৃতীয় octet আলাদা দেখায়।

নিচের calculator ঠিক এই হিসাবগুলো করে, আর প্রতিটির সাথে block size-এর যুক্তিও ছাপে, যাতে খাতার হিসাব মেলাতে পারেন। ঠিকানাকে ৩২ bit-এর একটি সংখ্যা বানিয়ে mask দিয়ে AND (&), আর broadcast-এর জন্য উল্টানো mask দিয়ে OR (|) — router-এর hardware-ও মূলত এটাই করে। শেষের /31 উদাহরণটি অংশ ৬-এ ব্যাখ্যা করা হয়েছে।

// IPv4 subnet calculator: network, broadcast, usable range + block-size reasoning.
const toInt = ip => ip.split(".").reduce((a, o) => a * 256 + Number(o), 0);
const toIp = n => [24, 16, 8, 0].map(s => (n >>> s) & 255).join(".");
const maskOf = p => (p === 0 ? 0 : (0xffffffff << (32 - p)) >>> 0);
const netOf = (x, p) => (x & maskOf(p)) >>> 0;
function calc(cidr) {
  const [ip, ps] = cidr.split("/"), p = Number(ps), x = toInt(ip);
  const m = maskOf(p), net = netOf(x, p), bc = (net | ~m) >>> 0;
  const k = Math.max(0, Math.ceil(p / 8) - 1);           // interesting octet (0-based)
  const mo = toIp(m).split(".")[k], block = 256 - mo, v = ip.split(".")[k];
  const lo = Math.floor(v / block) * block;
  console.log(`${cidr}  mask ${toIp(m)}`);
  console.log(`  octet ${k + 1}: block = 256 - ${mo} = ${block}; ${v} lies in ${lo}..${lo + block - 1}`);
  if (p === 31) { console.log(`  /31 link: ${toIp(net)} and ${toIp(bc)} are both hosts (RFC 3021)`); return; }
  console.log(`  network ${toIp(net)}  broadcast ${toIp(bc)}`);
  console.log(`  usable ${toIp(net + 1)} - ${toIp(bc - 1)}  (${2 ** (32 - p) - 2} hosts)`);
}
function same(a, b, p) {
  const na = netOf(toInt(a), p), nb = netOf(toInt(b), p);
  console.log(`${a} vs ${b} /${p}: ${toIp(na)} vs ${toIp(nb)} -> ` +
    (na === nb ? "SAME subnet (talk directly)" : "DIFFERENT subnets (need a router)"));
}
["192.168.10.77/27", "10.0.5.130/26", "172.16.45.200/20", "10.77.130.5/11", "192.168.50.6/31"]
  .forEach(calc);
console.log("--- same subnet? ---");
same("192.168.10.70", "192.168.10.100", 27);
same("192.168.10.70", "192.168.10.100", 26);
same("172.16.33.1", "172.16.46.9", 20);

192.168.10.77/27  mask 255.255.255.224
  octet 4: block = 256 - 224 = 32; 77 lies in 64..95
  network 192.168.10.64  broadcast 192.168.10.95
  usable 192.168.10.65 - 192.168.10.94  (30 hosts)
10.0.5.130/26  mask 255.255.255.192
  octet 4: block = 256 - 192 = 64; 130 lies in 128..191
  network 10.0.5.128  broadcast 10.0.5.191
  usable 10.0.5.129 - 10.0.5.190  (62 hosts)
172.16.45.200/20  mask 255.255.240.0
  octet 3: block = 256 - 240 = 16; 45 lies in 32..47
  network 172.16.32.0  broadcast 172.16.47.255
  usable 172.16.32.1 - 172.16.47.254  (4094 hosts)
10.77.130.5/11  mask 255.224.0.0
  octet 2: block = 256 - 224 = 32; 77 lies in 64..95
  network 10.64.0.0  broadcast 10.95.255.255
  usable 10.64.0.1 - 10.95.255.254  (2097150 hosts)
192.168.50.6/31  mask 255.255.255.254
  octet 4: block = 256 - 254 = 2; 6 lies in 6..7
  /31 link: 192.168.50.6 and 192.168.50.7 are both hosts (RFC 3021)
--- same subnet? ---
192.168.10.70 vs 192.168.10.100 /27: 192.168.10.64 vs 192.168.10.96 -> DIFFERENT subnets (need a router)
192.168.10.70 vs 192.168.10.100 /26: 192.168.10.64 vs 192.168.10.64 -> SAME subnet (talk directly)
172.16.33.1 vs 172.16.46.9 /20: 172.16.32.0 vs 172.16.32.0 -> SAME subnet (talk directly)

৫ · সমান মাপের subnetting — 192.168.10.0/24 থেকে ৬টি subnet

প্রশ্ন: একটি অফিস 192.168.10.0/24 পেয়েছে, ৬টি বিভাগ, প্রতিটির জন্য আলাদা subnet চাই, সব subnet সমান মাপের। Mask কত? প্রতিটিতে কতটি host? সব subnet-এর তালিকা দিন। একে বলে fixed-length subnetting (FLSM).

সমাধান: ২^s ≥ ৬ হতে সবচেয়ে ছোট s = ৩ (২^৩ = ৮)। নতুন prefix = ২৪ + ৩ = /27, mask 255.255.255.224. h = ৫, প্রতিটিতে ২^৫ − ২ = ৩০টি host. Block size ৩২:

৬টি বিভাগ পেল ৬টি subnet, আর ভবিষ্যতের জন্য ২টি বাকি রইল। কিন্তু এই নকশার দুর্বলতা স্পষ্ট: যে বিভাগে ১০০ জন, সে-ও পায় ৩০টি ঠিকানা, আর যে router-to-router link-এ মাত্র ২টি ঠিকানা লাগে, সে-ও ৩০টি নিয়ে বসে থাকে। সব সমান মাপে কাটলে কোথাও অভাব, কোথাও অপচয়। এর সমাধানই পরের অংশের VLSM.

৬ · VLSM — প্রতিটি দলকে তার মাপের জামা

VLSM (Variable Length Subnet Mask) মানে একই মূল ব্লকের ভেতরে বিভিন্ন দৈর্ঘ্যের prefix — বড় বিভাগের জন্য বড় block, ছোট link-এর জন্য ছোট block. দর্জির দোকানের কথা ভাবুন: সবাইকে এক মাপের জামা দিলে কারও ঢিলে, কারও আঁটসাঁট; প্রত্যেকের মাপ নিয়ে কাটলে একই থান কাপড়ে বেশি জামা হয়। তবে কাটার একটি নিয়ম আছে — বড় টুকরো আগে কাটতে হয়।

VLSM-এর চার ধাপ

1. প্রতিটি চাহিদার জন্য সবচেয়ে ছোট block বের করুন: ২^h − ২ ≥ host-সংখ্যা। Router-to-router link-এ ২টি host → /30 (৪টি ঠিকানা)।
2. বড় থেকে ছোট সাজান (host নয়, block-এর মাপ ধরে)।
3. মূল ব্লকের শুরু থেকে একটির পর একটি বসান — প্রতিটি block শুরু হবে তার নিজের মাপের গুণিতকে (aligned).
4. যাচাই: শেষ block-এর broadcast মূল ব্লকের ভেতরে কি না, কোনো দুটি block ওভারল্যাপ করে কি না, আর বাকি খালি অংশ কোথায়।

উদাহরণ: একটি অফিসের জন্য 192.168.20.0/24. চাহিদা: Sales ১২০ জন, Accounts ৬০, HR ২৮, Mgmt (switch, প্রিন্টার, ক্যামেরা) ১২, আর অন্য তিন শাখার সাথে তিনটি point-to-point WAN link. মোট দরকার ১২৮ + ৬৪ + ৩২ + ১৬ + ৪ × ৩ = ২৫২, যা ২৫৬-এর মধ্যে — কাগজে আঁটে। এবার বসিয়ে দেখি:

বড়টি আগে কেন — একটি ছোট প্রমাণ

সব block-এর মাপ ২-এর ঘাত। বড় থেকে ছোট সাজালে, কোনো block (মাপ b) বসানোর সময় তার আগে বসানো সব block-এর মাপ ≥ b, আর ২-এর ঘাত বলে প্রত্যেকটি b-এর গুণিতক। তাদের যোগফলও তাই b-এর গুণিতক — অর্থাৎ “পরের খালি ঠিকানা” আপনা থেকেই b-এর সীমানায় পড়ে, কোনো ফাঁক রাখতে হয় না। এলোমেলো ক্রমে ভাবুন: আগে একটি /30 (.0–.3) বসালে Sales-এর /25 আর .0-তে বসতে পারে না, শুরু করতে হয় .128-এ। তখন “পরের খালি ঠিকানা” সোজা সামনে এগোলে বাকিদের জায়গাই থাকে না; মাঝের .4–.127-এর ১২৪টি ঠিকানা আলাদা করে খুঁজে ভরাতে হয়, আর সীমানা মেলাতে গিয়ে ফাঁক পড়ে — ভুল আর ওভারল্যাপের ঝুঁকিও বাড়ে। বড়টি আগে বসালে কোনো ফাঁক থাকে না, আর বাকি খালি জায়গা শেষে একটানা একটি block হয়ে থাকে। অপারেটিং সিস্টেমের buddy allocator-ও (contiguous allocation) একই কারণে ২-এর ঘাতে, সীমানা মেনে memory দেয়।

Point-to-point link: /30 নাকি /31?

দুই router-এর মাঝের একটি তারে মাত্র দুটি প্রান্ত। /30-এ ৪টি ঠিকানার মধ্যে ২টি (network আর broadcast) অপচয় — ৫০%. একটি দুই-প্রান্তের link-এ “সবাইকে broadcast”-এর আসলে কোনো দরকার নেই, তাই RFC 3021 (২০০০ সাল) প্রস্তাব করে, point-to-point link-এ /31 ব্যবহার করা যাবে: দুটি ঠিকানাই দুই প্রান্তের, network বা broadcast বলে আলাদা কিছু নেই। আধুনিক অনেক router আর Linux /31 সমর্থন করে, তবে সব যন্ত্র, পুরোনো firmware বা নিরীক্ষণ-সফটওয়্যার করে কি না, ব্যবহারের আগে যাচাই করা উচিত। পরীক্ষায় সাধারণত /30-ই প্রত্যাশিত, যদি না প্রশ্নে /31 বলা থাকে। আর একটিমাত্র যন্ত্রের ঠিকানা বোঝাতে /32 (host route) — যেমন router-এর loopback ঠিকানা।

নিচের planner একই চার ধাপ চালায়: চাহিদাগুলো যেকোনো ক্রমে দিলেও নিজে বড় থেকে ছোট সাজায়, প্রতিটি block-কে তার মাপের গুণিতকে বসায়, আর জায়গা না থাকলে স্পষ্ট জানায়। দ্বিতীয় উদাহরণে ইচ্ছে করে এমন চাহিদা দেওয়া হয়েছে যা একটি /24-এ আঁটে না।

// VLSM planner: biggest requirement first, every block aligned to its own size.
const toInt = ip => ip.split(".").reduce((a, o) => a * 256 + Number(o), 0);
const toIp = n => [24, 16, 8, 0].map(s => (n >>> s) & 255).join(".");
function prefixFor(hosts) {                 // smallest block with (size - 2) >= hosts
  let p = 30;
  while (2 ** (32 - p) - 2 < hosts) p--;
  return p;
}
function plan(base, reqs) {
  const [ip, bp] = base.split("/"), start = toInt(ip), end = start + 2 ** (32 - bp);
  let next = start;
  console.log(`\nBase ${base} = ${end - start} addresses`);
  for (const [name, hosts] of [...reqs].sort((a, b) => b[1] - a[1])) {
    const p = prefixFor(hosts), size = 2 ** (32 - p);
    next = start + Math.ceil((next - start) / size) * size;   // align to block size
    if (next + size > end) {
      console.log(`  ${name}: needs /${p} (${size}) but only ${end - next} left -> DOES NOT FIT`);
      continue;
    }
    console.log(`  ${name.padEnd(9)} ${String(hosts).padStart(3)} hosts -> ${toIp(next)}/${p}` +
      `  usable ${toIp(next + 1)}-${toIp(next + size - 2)}  bc ${toIp(next + size - 1)}` +
      `  spare ${size - 2 - hosts}`);
    next += size;
  }
  console.log(`  used ${next - start} of ${end - start}; ` +
    (next < end ? `free from ${toIp(next)}` : "nothing left"));
}
plan("192.168.20.0/24", [["Mgmt", 12], ["Sales", 120], ["WAN-1", 2], ["HR", 28],
  ["Accounts", 60], ["WAN-2", 2], ["WAN-3", 2]]);
plan("192.168.30.0/24", [["Floor-1", 100], ["Floor-2", 100], ["Floor-3", 50]]);

Base 192.168.20.0/24 = 256 addresses
  Sales     120 hosts -> 192.168.20.0/25  usable 192.168.20.1-192.168.20.126  bc 192.168.20.127  spare 6
  Accounts   60 hosts -> 192.168.20.128/26  usable 192.168.20.129-192.168.20.190  bc 192.168.20.191  spare 2
  HR         28 hosts -> 192.168.20.192/27  usable 192.168.20.193-192.168.20.222  bc 192.168.20.223  spare 2
  Mgmt       12 hosts -> 192.168.20.224/28  usable 192.168.20.225-192.168.20.238  bc 192.168.20.239  spare 2
  WAN-1       2 hosts -> 192.168.20.240/30  usable 192.168.20.241-192.168.20.242  bc 192.168.20.243  spare 0
  WAN-2       2 hosts -> 192.168.20.244/30  usable 192.168.20.245-192.168.20.246  bc 192.168.20.247  spare 0
  WAN-3       2 hosts -> 192.168.20.248/30  usable 192.168.20.249-192.168.20.250  bc 192.168.20.251  spare 0
  used 252 of 256; free from 192.168.20.252

Base 192.168.30.0/24 = 256 addresses
  Floor-1   100 hosts -> 192.168.30.0/25  usable 192.168.30.1-192.168.30.126  bc 192.168.30.127  spare 26
  Floor-2   100 hosts -> 192.168.30.128/25  usable 192.168.30.129-192.168.30.254  bc 192.168.30.255  spare 26
  Floor-3: needs /26 (64) but only 0 left -> DOES NOT FIT
  used 256 of 256; nothing left

৭ · Route summarisation — অনেক মহল্লা, এক ঠিকানা

এবার উল্টো কাজ: ভাগ করা নয়, জোড়া লাগানো। ধরুন চট্টগ্রাম শাখার router-এর পেছনে চারটি LAN: 172.16.4.0/24, 172.16.5.0/24, 172.16.6.0/24 আর 172.16.7.0/24. ঢাকার প্রধান অফিসের router-কে চারটি আলাদা লাইন না জানিয়ে এক লাইনে বলা যায়: “172.16.4.0/22 — সব আমার কাছে পাঠান”. একে বলে route summarisation বা route aggregation; যখন সারাংশটি একটি class-এর স্বাভাবিক সীমার চেয়েও বড় হয়, তখন পুরোনো নাম supernetting.

পদ্ধতি — সাধারণ prefix খোঁজা

1. নেটওয়ার্কগুলোকে binary-তে লিখুন (যে octet-এ পার্থক্য, শুধু সেটি লিখলেই চলে)।
2. বাঁ দিক থেকে কতটি bit সবার এক — সেটিই নতুন prefix.
3. বাকি bit ০ করে দিলে summary-র network address.
4. যাচাই: summary-র মাপ (২^{৩২ − p}) আর তালিকার নেটওয়ার্কগুলোর মোট মাপ সমান কি না। বেশি হলে summary বাড়তি ঠিকানাও ঢেকে ফেলছে।

চারটি /24 সবসময় /22 হয় না

এবার 192.168.1.0/24 থেকে 192.168.4.0/24. তৃতীয় octet: ১ = 00000001, ৪ = 00000100. মিল মাত্র প্রথম ৫ bit (00000), তাই prefix ৮ + ৮ + ৫ = /21, summary 192.168.0.0/21 — যা ঢাকে 0 থেকে 7, আটটি /24. কারণ? ১ থেকে ৪ একটি ৪-এর block নয় — /22-এর block শুরু হয় ৪-এর গুণিতকে (0, 4, 8…), আর ১–৪ দুটি block-এ ছড়ানো (0–3 আর 4–7). এখানে নিখুঁত summary এক লাইনে হয় না; ভালো বিকল্প হলো 192.168.1.0/24, 192.168.2.0/23 আর 192.168.4.0/24 — তিন লাইন, কিন্তু একটিও বাড়তি ঠিকানা নয়।

নিচের summariser প্রতিটি নেটওয়ার্কের পুরো ৩২ bit ছাপে, সাধারণ prefix গোনে, আর summary-র ভেতরের যে অংশ তালিকায় নেই তা সতর্কবার্তায় দেখায়।

// Route summarisation: longest common prefix of several networks + what else it covers.
const toInt = ip => ip.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 => n.toString(2).padStart(32, "0").match(/.{8}/g).join(".");
function summarize(list) {
  const nets = list.map(c => { const [ip, p] = c.split("/"); return [toInt(ip), Number(p)]; })
    .sort((a, b) => a[0] - b[0]);
  const first = nets[0][0];
  let p = Math.min(...nets.map(n => n[1]));
  while (p > 0 && nets.some(([n]) => (n ^ first) >>> (32 - p) !== 0)) p--;
  const size = 2 ** (32 - p), sum = p === 0 ? 0 : first - (first % size);
  console.log(`\n${list.join(", ")}`);
  nets.forEach(([n]) => console.log(`  ${bin(n)}  ${toIp(n)}`));
  console.log(`  common prefix = ${p} bits -> summary ${toIp(sum)}/${p}` +
    ` (${toIp(sum)} - ${toIp(sum + size - 1)}, ${size} addresses)`);
  let at = sum, extra = 0;                      // walk the block, report the gaps
  for (const [n, q] of nets) {
    if (n > at) { console.log(`  WARNING also covers ${toIp(at)} - ${toIp(n - 1)}`); extra += n - at; }
    at = Math.max(at, n + 2 ** (32 - q));
  }
  if (at < sum + size) { console.log(`  WARNING also covers ${toIp(at)} - ${toIp(sum + size - 1)}`); extra += sum + size - at; }
  console.log(extra ? `  ${extra} extra addresses not in the list` : "  exact summary: nothing extra");
}
summarize(["172.16.4.0/24", "172.16.5.0/24", "172.16.6.0/24", "172.16.7.0/24"]);
summarize(["192.168.1.0/24", "192.168.2.0/24", "192.168.3.0/24", "192.168.4.0/24"]);
summarize(["10.1.1.0/24", "10.1.6.0/24"]);

172.16.4.0/24, 172.16.5.0/24, 172.16.6.0/24, 172.16.7.0/24
  10101100.00010000.00000100.00000000  172.16.4.0
  10101100.00010000.00000101.00000000  172.16.5.0
  10101100.00010000.00000110.00000000  172.16.6.0
  10101100.00010000.00000111.00000000  172.16.7.0
  common prefix = 22 bits -> summary 172.16.4.0/22 (172.16.4.0 - 172.16.7.255, 1024 addresses)
  exact summary: nothing extra

192.168.1.0/24, 192.168.2.0/24, 192.168.3.0/24, 192.168.4.0/24
  11000000.10101000.00000001.00000000  192.168.1.0
  11000000.10101000.00000010.00000000  192.168.2.0
  11000000.10101000.00000011.00000000  192.168.3.0
  11000000.10101000.00000100.00000000  192.168.4.0
  common prefix = 21 bits -> summary 192.168.0.0/21 (192.168.0.0 - 192.168.7.255, 2048 addresses)
  WARNING also covers 192.168.0.0 - 192.168.0.255
  WARNING also covers 192.168.5.0 - 192.168.7.255
  1024 extra addresses not in the list

10.1.1.0/24, 10.1.6.0/24
  00001010.00000001.00000001.00000000  10.1.1.0
  00001010.00000001.00000110.00000000  10.1.6.0
  common prefix = 21 bits -> summary 10.1.0.0/21 (10.1.0.0 - 10.1.7.255, 2048 addresses)
  WARNING also covers 10.1.0.0 - 10.1.0.255
  WARNING also covers 10.1.2.0 - 10.1.5.255
  WARNING also covers 10.1.7.0 - 10.1.7.255
  1536 extra addresses not in the list

! চট্টগ্রামের router: চারটি LAN-এর বদলে একটি summary ঘোষণা, আর নিজের কাছে
! যে অংশ নেই তার packet ফেলে দেওয়ার জন্য একটি discard (Null0) route
ip route 172.16.4.0 255.255.252.0 Null0
!
router ospf 1
 area 1 range 172.16.4.0 255.255.252.0     ! OSPF area সীমানায় summary (পর্ব ২৪)

এখানে Null0 route-টি একটি নিরাপত্তা-জাল: summary-র ভেতরের কোনো ঠিকানার জন্য আরও নির্দিষ্ট route না থাকলে packet সেখানেই ফেলে দেওয়া হয়, default route ধরে উল্টো ফেরত পাঠানো হয় না — নইলে দুই router-এর মাঝে packet ঘুরপাক খেতে পারে (routing loop). অনেক routing protocol summary বানালে নিজেই এমন discard route যোগ করে। এই নির্দিষ্ট route আর summary-র মাঝে কে জেতে, সেই longest prefix match-এর পুরো নিয়ম পর্ব ২২-এ।

৮ · Wildcard mask, মুখে মুখে হিসাবের টেবিল আর সাধারণ ভুল

Wildcard mask — উল্টো mask

Cisco IOS-এর ACL (access control list, পর্ব ৪৯) আর OSPF-এর network কমান্ডে mask-এর বদলে লেখা হয় wildcard mask: ২৫৫.২৫৫.২৫৫.২৫৫ থেকে subnet mask বিয়োগ। Wildcard-এ ০ মানে “এই bit মিলতে হবে”, ১ মানে “যা খুশি”. /27-এর mask 255.255.255.224 → wildcard 0.0.0.31; /20 → 0.0.15.255; /22 → 0.0.3.255.

access-list 10 permit 192.168.20.192 0.0.0.31     ! HR subnet (.192/27) অনুমোদিত
access-list 10 deny   any
!
router ospf 1
 network 192.168.20.0 0.0.0.255 area 0             ! এই /24-এর interface-গুলোতে OSPF

এটি vendor-নির্ভর প্রথা, সার্বজনীন standard নয়: Juniper, MikroTik বা Linux-এর nftables সাধারণত সরাসরি 192.168.20.192/27 লেখে। আর Cisco-র ACL-এ wildcard-এর ১ আর ০ একটানা না-ও হতে পারে (যেমন শুধু জোড় ঠিকানা মেলানো) — এটি subnet mask-এর সাথে মেলে না, তাই সাধারণ নকশায় এড়ানোই ভালো।

মুখে মুখে হিসাবের টেবিল

নিচের টেবিল মুখস্থ না করে বুঝে রাখুন — প্রতিটি সারি আগের সারির অর্ধেক। চতুর্থ octet-এর এই block size-গুলোই তৃতীয় octet-এ /16–/23 আর দ্বিতীয় octet-এ /8–/15-এর জন্য হুবহু একই (/17 → ১২৮, /20 → ১৬, /23 → ২…); শুধু host-সংখ্যায় ডানের octet-গুলোর bit যোগ হয়।

Mask-এর octet-এর মানগুলোও একটি সিঁড়ি: ১২৮, ১৯২, ২২৪, ২৪০, ২৪৮, ২৫২, ২৫৪, ২৫৫ — প্রতিবার বাঁ থেকে আরেকটি ১ যোগ (১২৮ + ৬৪ + ৩২ + …)। এই আটটি সংখ্যা আর “block = ২৫৬ − mask” — পরীক্ষার হলে এটুকুই যথেষ্ট।

Calculator ছাড়াও হিসাবটি একদম সাধারণ shell-এ করা যায়। নিচের script শুধু bash-এর নিজের পূর্ণসংখ্যার অঙ্ক $(( )) ব্যবহার করে — shift (<<), AND (&), OR (|), NOT (~) — কোনো বাইরের টুল লাগে না; শুধু শেষে দেখে নেয় ipcalc আছে কি না।

# Subnet math with bash arithmetic $(( )) only - no external tool needed.
ip2int() { local IFS=.; set -- $1; echo $(( ($1 << 24) | ($2 << 16) | ($3 << 8) | $4 )); }
int2ip() { local n=$1; echo "$(( (n >> 24) & 255 )).$(( (n >> 16) & 255 )).$(( (n >> 8) & 255 )).$(( n & 255 ))"; }
for cidr in 192.168.10.77/27 172.16.45.200/20; do
  ip=${cidr%/*}; p=${cidr#*/}
  x=$(ip2int "$ip")
  mask=$(( (0xFFFFFFFF << (32 - p)) & 0xFFFFFFFF ))
  net=$(( x & mask ))
  bc=$(( net | (~mask & 0xFFFFFFFF) ))
  echo "$cidr"
  echo "  mask      $(int2ip $mask)   wildcard $(int2ip $(( ~mask & 0xFFFFFFFF )))"
  echo "  network   $(int2ip $net)"
  echo "  broadcast $(int2ip $bc)"
  echo "  usable    $(int2ip $(( net + 1 ))) - $(int2ip $(( bc - 1 )))   hosts=$(( (1 << (32 - p)) - 2 ))"
done
if command -v ipcalc >/dev/null; then
  echo "ipcalc found - cross-check: ipcalc 192.168.10.77/27"
else
  echo "ipcalc not installed - bash arithmetic was enough"
fi

192.168.10.77/27
  mask      255.255.255.224   wildcard 0.0.0.31
  network   192.168.10.64
  broadcast 192.168.10.95
  usable    192.168.10.65 - 192.168.10.94   hosts=30
172.16.45.200/20
  mask      255.255.240.0   wildcard 0.0.15.255
  network   172.16.32.0
  broadcast 172.16.47.255
  usable    172.16.32.1 - 172.16.47.254   hosts=4094
ipcalc not installed - bash arithmetic was enough

সাধারণ ভুল আর নিজে যাচাইয়ের উপায়

তিনটি দ্রুত আত্মযাচাই: (১) network-এর আগ্রহের octet ÷ block = পূর্ণ সংখ্যা; (২) broadcast + ১ = পরের subnet-এর network; (৩) block = ২-এর ঘাত, আর host = block − ২. তারপর যন্ত্র দিয়ে মিলিয়ে নিন — যেমন Python-এর standard library:

$ python3 -c "import ipaddress as i; n=i.ip_interface('192.168.10.77/27').network; print(n, n.broadcast_address, n.num_addresses-2)"
192.168.10.64/27 192.168.10.95 30

৯ · AI-এর যুগে subnetting — হিসাব আপনার, যাচাইও আপনার

AI-কে “192.168.20.0/24-এ ১২০, ৬০, ২৮, ১২ host-এর VLSM করে দিন” বললে কয়েক সেকেন্ডে একটি সুন্দর টেবিল পাবেন। ভাষার মডেল কিন্তু অঙ্ক কষে না — সম্ভাব্য লেখা তৈরি করে। তাই subnet-এর টেবিল দেখতে নিখুঁত হলেও তাতে একটি broadcast এক ঘর সরে যেতে পারে, বা দুটি subnet নিঃশব্দে ওভারল্যাপ করতে পারে। আর সেই টেবিল দিয়ে DHCP আর router কনফিগার করলে সমস্যা ধরা পড়ে সপ্তাহ পরে, যখন দুটি যন্ত্র একই ঠিকানা পায়।

AI-এর টেবিল ব্যবহারের আগে — চেকলিস্ট

• প্রতিটি সারির network, broadcast আর host-সংখ্যা নিজে বা calculator/ipcalc/Python দিয়ে আবার হিসাব করেছি
• প্রতিটি network তার block size-এর গুণিতক, আর কোনো দুটি subnet ওভারল্যাপ করে না — যাচাই করেছি
• Summary route ঠিক কোন কোন ঠিকানা ঢাকে, আর তার মধ্যে কোনটি আমার নয় — দেখে নিয়েছি
• কমান্ডগুলো আমার যন্ত্রের vendor আর OS-এর ডকুমেন্টেশনে মিলিয়েছি (Linux-এ ip, পুরোনো ifconfig নয়)
• প্রথমে ল্যাবে বা virtual machine-এ চালিয়ে দুই subnet-এর মাঝে ping আর packet capture করে আচরণ দেখেছি — শুধু নিজের বা অনুমতিপ্রাপ্ত নেটওয়ার্কে