Linux-এ নেটওয়ার্ক দেখা — ip, ping, ss, curl আর /proc/net

১ · কেন এই পর্ব — নেটওয়ার্ককে চোখে দেখা

আগের পাঁচটি পর্বে আমরা নেটওয়ার্কের ধারণা গড়েছি — স্তর, packet, delay. কিন্তু ধারণা যতই পরিষ্কার হোক, নিজের ল্যাপটপে সেগুলো দেখতে না পেলে মনে হয় সবই বইয়ের কথা। এই পর্বটি একটি ল্যাব পর্ব। এখানে শেখা কমান্ডগুলো পুরো কোর্সে বারবার ফিরে আসবে: ARP দেখতে ip neigh, TCP state দেখতে ss, DNS বুঝতে dig, HTTP বুঝতে curl -v.

এই পর্বের কমান্ডগুলো চালাতে হলে একটি Linux shell লাগবে — নিজের Linux, Windows-এর WSL, বা কোনো ক্লাউড VM. Terminal খোলা, cd, ls, pipe (|), grep আর man যদি নতুন হয়, আগে অপারেটিং সিস্টেম কোর্সের Linux terminal পর্বটি দেখে নিন; এখানে সেগুলো আবার শেখানো হবে না।

পুরোনো টুল বনাম আধুনিক টুল

অনলাইনে পুরোনো টিউটোরিয়ালে (আর অনেক সময় AI-এর উত্তরেও) দেখবেন ifconfig, netstat, route, arp. এগুলো net-tools নামের একটি পুরোনো প্যাকেজের অংশ। বহু বছর ধরে এর উন্নয়ন প্রায় থেমে ছিল, আর আধুনিক Linux-এর অনেক সুবিধা (একটি interface-এ অনেক ঠিকানা, একাধিক routing table, network namespace) এটি ঠিকমতো দেখাতে পারে না। এর জায়গা নিয়েছে iproute2 — যার প্রধান কমান্ড ip আর ss. Ubuntu, Debian, Fedora-র মতো বেশিরভাগ আধুনিক distribution-এ iproute2 আগে থেকেই থাকে, আর ছোট (minimal) ইনস্টলেশনে net-tools প্রায়ই থাকে না — তাই ifconfig: command not found দেখে অবাক হবেন না।

২ · আমার ঠিকানা কী — ip addr আর interface

নেটওয়ার্কের সাথে কম্পিউটারের প্রতিটি সংযোগ-বিন্দুকে বলে network interface. ল্যাপটপে সাধারণত তিনটি থাকে: Wi-Fi কার্ড, Ethernet পোর্ট আর একটি কাল্পনিক interface — loopback (lo), যেটি দিয়ে কম্পিউটার নিজের সাথেই কথা বলে। প্রতিটি interface-এর থাকতে পারে একটি হার্ডওয়্যার ঠিকানা (MAC address), এক বা একাধিক IP address, আর একটি MTU — একবারে সবচেয়ে বড় কত বাইটের packet পাঠানো যায়।

নিচে ঢাকার একটি বাসার Wi-Fi-তে যুক্ত সাধারণ Ubuntu ল্যাপটপের ip addr আউটপুট। এটি একটি উদাহরণ — আপনার যন্ত্রের নাম, MAC আর ঠিকানা আলাদা হবে। “পরে” চেপে লাইন ধরে ধরে পড়ুন:

11: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN2    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:003    inet 127.0.0.1/8 scope host lo4    inet6 ::1/128 scope host52: enp3s0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 state DOWN6    link/ether 8c:16:45:3a:7e:21 brd ff:ff:ff:ff:ff:ff73: wlp2s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 state UP8    link/ether 4c:d5:77:1b:9e:42 brd ff:ff:ff:ff:ff:ff9    inet 192.168.0.105/24 brd 192.168.0.255 scope global dynamic wlp2s010       valid_lft 85980sec preferred_lft 85980sec11    inet6 fe80::9a3c:2f1e:7b44:c1d0/64 scope link

প্রতিদিনের কাজে পুরো আউটপুট লাগে না। -br (brief) দিলে প্রতি interface এক লাইনে আসে — সবচেয়ে বেশি ব্যবহৃত রূপ:

$ ip -br addr
lo               UNKNOWN        127.0.0.1/8 ::1/128
enp3s0           DOWN
wlp2s0           UP             192.168.0.105/24 fe80::9a3c:2f1e:7b44:c1d0/64

$ ip -br link                  # শুধু link স্তর: নাম, state, MAC
lo               UNKNOWN        00:00:00:00:00:00 <LOOPBACK,UP,LOWER_UP>
enp3s0           DOWN           8c:16:45:3a:7e:21 <NO-CARRIER,BROADCAST,MULTICAST,UP>
wlp2s0           UP             4c:d5:77:1b:9e:42 <BROADCAST,MULTICAST,UP,LOWER_UP>

$ ip -4 addr show dev wlp2s0   # শুধু একটি interface-এর IPv4

ip-এর ব্যাকরণ সহজ: ip [বিকল্প] বস্তু কাজ. বস্তু হতে পারে addr, link, route, neigh; কাজ না দিলে ধরে নেয় show. সংক্ষেপও চলে — ip a, ip r, ip n. দেখার কমান্ডে root লাগে না; কিন্তু বদলানোর কমান্ডে (যেমন ip addr add, ip link set … down) sudo লাগে, আর এগুলো ভুল করে চালালে দূরের সার্ভারের সাথে আপনার সংযোগই কেটে যেতে পারে — তাই সেগুলো এই পর্বে চালাবেন না।

PS> ipconfig /all
PS> Get-NetIPAddress -AddressFamily IPv4 | Format-Table InterfaceAlias, IPAddress, PrefixLength
PS> Get-NetAdapter | Format-Table Name, Status, MacAddress, LinkSpeed
PS> netsh interface ipv4 show config

$ ifconfig en0
$ ipconfig getifaddr en0        # শুধু IPv4 ঠিকানা
$ networksetup -getinfo Wi-Fi

৩ · বাইরে যাওয়ার দরজা আর পাশের বাড়ি — ip route আর ip neigh

ঠিকানা জানা হলো। এবার প্রশ্ন: একটি packet কোথায় পাঠাবেন? Kernel এই সিদ্ধান্ত নেয় routing table দেখে — একটি তালিকা, যেখানে লেখা থাকে “এই গন্তব্যের জন্য এই দরজা”। দেখার কমান্ড ip route:

$ ip route
default via 192.168.0.1 dev wlp2s0 proto dhcp src 192.168.0.105 metric 600
192.168.0.0/24 dev wlp2s0 proto kernel scope link src 192.168.0.105 metric 600

$ ip route get 192.0.2.10        # এই ঠিকানায় যেতে kernel কোন পথ নেবে?
192.0.2.10 via 192.168.0.1 dev wlp2s0 src 192.168.0.105 uid 1000
    cache

দ্বিতীয় লাইনটি আগে পড়ুন: 192.168.0.0/24-এর যেকোনো ঠিকানা সরাসরি wlp2s0 দিয়ে পাওয়া যায় (scope link) — এরা একই LAN-এর প্রতিবেশী, মাঝে কোনো router লাগে না। প্রথম লাইনটি হলো default route: বাকি সব গন্তব্যের packet যাবে 192.168.0.1-এর কাছে। এই 192.168.0.1-ই আপনার default gateway — বাসার Wi-Fi router. proto dhcp বলছে এই নিয়মটি DHCP থেকে এসেছে; metric 600 হলো অগ্রাধিকার (একই গন্তব্যের একাধিক পথ থাকলে কম metric জেতে — Wi-Fi আর তার দুটোই থাকলে সাধারণত তারের পথের metric কম রাখা হয়)।

পাশের বাড়ির দরজার নম্বর — ip neigh

Gateway-এর IP জানা গেল, কিন্তু Wi-Fi-তে frame পাঠাতে লাগে তার MAC ঠিকানা। IP থেকে MAC বের করার কাজ করে ARP (IPv6-এ এর বদলে Neighbor Discovery). একবার জানা MAC kernel কিছুক্ষণ মনে রাখে — এই স্মৃতির নাম ARP cache বা neighbour table:

$ ip neigh
192.168.0.1 dev wlp2s0 lladdr 60:a4:b7:5e:21:0c REACHABLE
192.168.0.110 dev wlp2s0 lladdr 3a:f1:0c:88:42:9d STALE
fe80::62a4:b7ff:fe5e:210c dev wlp2s0 lladdr 60:a4:b7:5e:21:0c router STALE

প্রথম লাইন: router-এর MAC জানা আছে, আর সম্প্রতি নিশ্চিত হওয়া গেছে যে সে সাড়া দেয় (REACHABLE). দ্বিতীয়টি বাসার অন্য একটি যন্ত্র — হয়তো কারও ফোন; STALE মানে তথ্যটি একটু পুরোনো, পরের বার ব্যবহারের আগে kernel আবার যাচাই করবে। খেয়াল করুন, ফোনের MAC-এর প্রথম বাইট 3a — এর দ্বিতীয় সর্বনিম্ন বিটটি ১, যার মানে এটি “locally administered”, অর্থাৎ কারখানার আসল MAC নয়। আধুনিক Android আর iPhone গোপনীয়তার জন্য প্রতিটি Wi-Fi নেটওয়ার্কে আলাদা এলোমেলো MAC ব্যবহার করে। তৃতীয় লাইনে একই router-কে IPv6-এর চোখে দেখা যাচ্ছে (router শব্দটি লক্ষ করুন)। ARP-এর request-reply কীভাবে চলে, তা ধাপে ধাপে পর্ব ১৮-তে দেখবেন।

PS> route print -4
PS> Get-NetRoute -DestinationPrefix 0.0.0.0/0      # শুধু default route
PS> arp -a
PS> Get-NetNeighbor -AddressFamily IPv4

mac$ netstat -rn -f inet
mac$ route -n get default
mac$ arp -a

৪ · কে কোন port-এ শুনছে — ss -tulpn

একটি যন্ত্রে একসাথে অনেক নেটওয়ার্ক প্রোগ্রাম চলে: ওয়েব সার্ভার, ডেটাবেস, SSH, স্থানীয় DNS. প্রত্যেকে একটি বা একাধিক socket খোলে, আর socket চেনা যায় একটি IP ঠিকানা আর একটি port নম্বর দিয়ে। Port হলো অফিসের কাউন্টার নম্বরের মতো — একই ভবন (IP), কিন্তু ৮০ নম্বর কাউন্টারে ওয়েব, ২২ নম্বরে SSH. Port আর socket-এর তত্ত্ব পর্ব ২৭-এ; এখানে শুধু দেখতে শিখি।

ss মানে socket statistics. সবচেয়ে প্রচলিত রূপ ss -tulpn, যার প্রতিটি অক্ষর একটি বিকল্প: -t TCP, -u UDP, -l শুধু যারা শুনছে (listening), -p কোন process, -n নাম না বানিয়ে সংখ্যা দেখানো (:80, :http নয়)। অন্যের process দেখতে sudo লাগে; না দিলে শুধু নিজের process-এর নাম আসে, বাকিদের ঘর ফাঁকা থাকে।

নিচে একটি ছোট Ubuntu সার্ভারের উদাহরণ — এতে nginx ওয়েব সার্ভার, একটি Node.js অ্যাপ, PostgreSQL আর SSH চলছে। ধাপে ধাপে দেখুন আউটপুটটি সার্ভার সম্পর্কে কী কী বলে দেয়:

1Netid State  Recv-Q Send-Q Local Address:Port  Peer Address:Port Process2udp   UNCONN 0      0      127.0.0.53%lo:53        0.0.0.0:*     users:(("systemd-resolve",pid=612,fd=13))3tcp   LISTEN 0      4096   127.0.0.53%lo:53        0.0.0.0:*     users:(("systemd-resolve",pid=612,fd=14))4tcp   LISTEN 0      128          0.0.0.0:22         0.0.0.0:*     users:(("sshd",pid=901,fd=3))5tcp   LISTEN 0      511          0.0.0.0:80         0.0.0.0:*     users:(("nginx",pid=1204,fd=6),("nginx",pid=1203,fd=6))6tcp   LISTEN 0      511             [::]:80            [::]:*     users:(("nginx",pid=1204,fd=7),("nginx",pid=1203,fd=7))7tcp   LISTEN 0      200        127.0.0.1:5432       0.0.0.0:*     users:(("postgres",pid=1088,fd=7))8tcp   LISTEN 0      511        127.0.0.1:3000       0.0.0.0:*     users:(("node",pid=2210,fd=19))

শুধু শোনা socket নয়, চলমান সংযোগও দেখা যায়। কয়েকটি কাজের রূপ:

$ ss -tn                          # সব চলমান TCP সংযোগ (ESTAB ইত্যাদি)
$ ss -tn state established '( dport = :443 )'   # শুধু HTTPS সংযোগগুলো
$ sudo ss -ltnp 'sport = :8080'   # 8080 port-এ কে শুনছে?
$ ss -s                           # মোট হিসাব: কতগুলো TCP, কতগুলো TIME_WAIT
$ ss -ti                          # প্রতিটি সংযোগের ভেতরের তথ্য: rtt, cwnd, retrans

শেষ কমান্ডটি পর্ব ৩০–৩২-এ খুব কাজে লাগবে — সেখানে TCP-র RTT অনুমান আর congestion window (cwnd) আসল সংযোগে দেখবেন। পুরোনো সমতুল্য netstat -tulpn-এর আউটপুট দেখতে প্রায় একই, কিন্তু অনেক socket থাকলে ধীর (কারণ অংশ ৭-এ)।

PS> netstat -ano | findstr LISTENING
PS> Get-NetTCPConnection -State Listen | Sort-Object LocalPort | Format-Table LocalAddress, LocalPort, OwningProcess
PS> Get-Process -Id 1204          # PID থেকে প্রোগ্রামের নাম

mac$ sudo lsof -nP -iTCP -sTCP:LISTEN
mac$ netstat -an -p tcp | grep LISTEN

৫ · পৌঁছানো যায় তো? — ping, traceroute, tracepath আর mtr

ping সবচেয়ে পুরোনো আর সবচেয়ে পরিচিত নেটওয়ার্ক টুল। এটি ICMP protocol-এর “Echo Request” বার্তা পাঠায়, আর গন্তব্য বেঁচে থাকলে ফেরত দেয় “Echo Reply”. ICMP-এর কোনো port নেই — তাই “ping কোন port ব্যবহার করে?” প্রশ্নটিই ভুল। একটি উদাহরণ:

$ ping -c 4 example.com
PING example.com (192.0.2.10) 56(84) bytes of data.
64 bytes from 192.0.2.10: icmp_seq=1 ttl=56 time=38.2 ms
64 bytes from 192.0.2.10: icmp_seq=2 ttl=56 time=37.9 ms
64 bytes from 192.0.2.10: icmp_seq=3 ttl=56 time=39.8 ms
64 bytes from 192.0.2.10: icmp_seq=4 ttl=56 time=38.5 ms

--- example.com ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3004ms
rtt min/avg/max/mdev = 37.900/38.600/39.800/0.725 ms

লাইন ধরে পড়ি। 56(84) bytes: ৫৬ বাইট ডেটা, তার সাথে ৮ বাইট ICMP header = ৬৪, তার সাথে ২০ বাইট IP header = ৮৪. প্রতিটি উত্তরে তিনটি জিনিস:

• icmp_seq — ক্রমিক নম্বর। কোনো নম্বর বাদ গেলে সেই packet হারিয়েছে; ক্রম উল্টে এলে পথে reorder হয়েছে।
• time — RTT (round-trip time): পাঠানো থেকে উত্তর আসা পর্যন্ত সময়। পর্ব ৫-এর propagation, transmission, queueing আর processing delay — সব যাওয়া-আসায় মিলে এই সংখ্যা।
• ttl — উত্তর-packet-এর TTL (time to live)-এর বাকি মান। প্রতিটি router TTL ১ করে কমায়; ০ হলে packet ফেলে দেয়। এটি ঘুরপাক খাওয়া packet-কে চিরকাল বাঁচতে দেয় না।

শেষ লাইনের mdev হলো RTT কতটা ওঠানামা করছে তার মাপ (প্রায় standard deviation). হিসাবটা মিলিয়ে দেখুন: চারটি RTT-র যোগফল ১৫৪.৪, গড় ৩৮.৬; গড় থেকে বিচ্যুতি −০.৪, −০.৭, +১.২, −০.১; বর্গের গড় (০.১৬ + ০.৪৯ + ১.৪৪ + ০.০১) ÷ ৪ = ০.৫২৫; বর্গমূল ≈ ০.৭২৫. ওঠানামা (jitter) বেশি হলে ভিডিও কল আর অনলাইন গেম কষ্ট পায়। আর 0% packet loss — packet loss শূন্য। বাসার Wi-Fi-তে কয়েক শতাংশ loss মানে প্রায়ই দুর্বল সংকেত বা ব্যস্ত চ্যানেল।

traceroute — TTL-এর চতুর ব্যবহার

TTL ০ হলে router packet ফেলে দেয়, কিন্তু চুপচাপ নয় — প্রেরককে একটি ICMP “Time Exceeded” বার্তা পাঠায়, আর সেই বার্তার উৎস-ঠিকানা হলো router-এর নিজের ঠিকানা। traceroute এই নিয়মটিকেই কাজে লাগায়। নিচের ডায়াগ্রামে ধাপে ধাপে দেখুন:

বাস্তবের একটি দীর্ঘ পথ দেখতে এরকম হতে পারে (উদাহরণ; ঠিকানাগুলো documentation range-এর, তাই আসল কোনো প্রতিষ্ঠানের নয়)। খেয়াল করুন — ping-এ ttl=56 বলেছিল ৮টি router, আর এখানে ৮টি hop-এর পরে ৯ নম্বরে গন্তব্য:

$ traceroute example.com
traceroute to example.com (192.0.2.10), 30 hops max, 60 byte packets
 1  _gateway (192.168.0.1)  1.912 ms  1.874 ms  2.035 ms
 2  100.64.12.1 (100.64.12.1)  4.210 ms  4.388 ms  4.157 ms
 3  10.20.0.5 (10.20.0.5)  5.902 ms  6.114 ms  5.877 ms
 4  203.0.113.17 (203.0.113.17)  7.341 ms  7.120 ms  7.509 ms
 5  * * *
 6  198.51.100.66 (198.51.100.66)  34.880 ms  35.102 ms  34.917 ms
 7  198.51.100.129 (198.51.100.129)  36.554 ms  36.019 ms  36.871 ms
 8  203.0.113.201 (203.0.113.201)  37.640 ms  37.488 ms  37.912 ms
 9  192.0.2.10 (192.0.2.10)  38.105 ms  37.996 ms  38.240 ms

৪ থেকে ৬ নম্বর hop-এ সময় ~৭ ms থেকে ~৩৫ ms-এ লাফ দিয়েছে। এ ধরনের বড় লাফ সাধারণত বোঝায় পথটি এখানে একটি দীর্ঘ সংযোগ পার হয়েছে — বাংলাদেশ থেকে বিদেশের সার্ভারে যেতে traffic সাধারণত সাবমেরিন কেবল বা প্রতিবেশী দেশের মধ্য দিয়ে যাওয়া স্থল-সংযোগ ব্যবহার করে। তবে এটি অনুমান: মাঝের router-এর নিজের উত্তর দেওয়ার গতিও সংখ্যাটিকে প্রভাবিত করে।

৬ · নাম, ওয়েব আর একটি কাঁচা TCP সংযোগ — dig, curl -v আর nc

dig — নাম থেকে ঠিকানা

মানুষ মনে রাখে নাম (example.com), যন্ত্রের লাগে ঠিকানা। নাম থেকে ঠিকানা বের করার ব্যবস্থাই DNS. এর সবচেয়ে বিস্তারিত টুল dig:

$ dig example.com A

; <<>> DiG 9.18.28 <<>> example.com A
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 41873
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 65494
;; QUESTION SECTION:
;example.com.                   IN      A

;; ANSWER SECTION:
example.com.            3125    IN      A       192.0.2.10

;; Query time: 24 msec
;; SERVER: 127.0.0.53#53(127.0.0.53) (UDP)
;; WHEN: Mon Oct 26 21:14:03 +06 2026
;; MSG SIZE  rcvd: 56

গুরুত্বপূর্ণ অংশ চারটি। status: NOERROR — প্রশ্নের উত্তর পাওয়া গেছে (নাম না থাকলে আসত NXDOMAIN). ANSWER SECTION-এ আসল উত্তর: example.com-এর A (IPv4) রেকর্ড 192.0.2.10, আর 3125 হলো সেকেন্ডে TTL — এতক্ষণ উত্তরটি cache-এ রাখা যাবে (এই TTL DNS-এর, IP header-এর TTL নয় — নাম এক, জিনিস আলাদা)। SERVER: 127.0.0.53 — প্রশ্নটি গেছে অংশ ৪-এ দেখা স্থানীয় DNS stub-এর কাছে। Query time: 24 msec — উত্তর পেতে কত সময় লাগল; আবার চালালে cache থেকে প্রায় ০ ms আসতে পারে।

$ dig +short example.com
192.0.2.10
$ host example.com
example.com has address 192.0.2.10
$ nslookup example.com
Server:         127.0.0.53
Address:        127.0.0.53#53

Non-authoritative answer:
Name:   example.com
Address: 192.0.2.10

nslookup Windows-এও আছে; PowerShell-এ আধুনিক বিকল্প Resolve-DnsName example.com. DNS-এর ভেতরের যাত্রা — root, TLD, authoritative server, recursive resolver আর caching — পর্ব ৩৫-এর বিষয়।

curl -v — একটি HTTP কথোপকথন

curl URL দিয়ে কিছু আনার টুল। -v (verbose) দিলে এটি পুরো কথোপকথন দেখায়: * চিহ্নের লাইন curl-এর নিজের মন্তব্য, > চিহ্নের লাইন যা পাঠানো হলো, < চিহ্নের লাইন যা ফিরে এলো।

$ curl -v http://example.com/
*   Trying 192.0.2.10:80...
* Connected to example.com (192.0.2.10) port 80
> GET / HTTP/1.1
> Host: example.com
> User-Agent: curl/8.5.0
> Accept: */*
>
< HTTP/1.1 200 OK
< Content-Type: text/html; charset=UTF-8
< Content-Length: 1256
< Cache-Control: max-age=3600
<
<!doctype html>
… (পাতার HTML) …
* Connection #0 to host example.com left intact

এক নজরে পুরো স্তরের গল্প: আগে DNS (192.0.2.10 পাওয়া), তারপর TCP সংযোগ port ৮০-তে (Connected), তারপর HTTP অনুরোধ — একটি GET লাইন আর কয়েকটি header, শেষে একটি ফাঁকা লাইন। সার্ভার জবাব দিল 200 OK, কিছু header আর পাতার বিষয়বস্তু। HTTPS URL দিলে Connected-এর পরে TLS handshake-এর লাইনও দেখবেন (পর্ব ৪৮)। HTTP-র প্রতিটি অংশ পর্ব ৩৬-এ বিস্তারিত।

nc — নিজের যন্ত্রে একটি কাঁচা TCP সংযোগ

netcat (nc) হলো নেটওয়ার্কের “সুইস ছুরি”: এটি যেকোনো TCP বা UDP সংযোগ খুলে আপনার কীবোর্ড থেকে বাইট পাঠায় আর যা আসে তা দেখায়। নিজের ল্যাপটপে দুটি terminal খুলে চেষ্টা করুন — সবকিছু 127.0.0.1-এ, তাই বাইরের কেউ জড়িত নয়:

# terminal ১: 9000 port-এ শোনা শুরু (OpenBSD-ধাঁচের nc; Ubuntu-র ডিফল্ট)
$ nc -l 127.0.0.1 9000

# terminal ২: সংযোগ, তারপর একটি লাইন লিখে Enter
$ nc -v 127.0.0.1 9000
Connection to 127.0.0.1 9000 port [tcp/*] succeeded!
hello
# → terminal ১-এ "hello" ভেসে উঠবে; Ctrl+C দিয়ে বন্ধ

# শুধু port খোলা কি না যাচাই (নিজের যন্ত্রে):
$ nc -zv 127.0.0.1 22
Connection to 127.0.0.1 22 port [tcp/ssh] succeeded!

সংযোগ চলার সময় তৃতীয় একটি terminal-এ ss -tn '( sport = :9000 or dport = :9000 )' দিলে দুটি ESTAB লাইন দেখবেন — সংযোগের দুই প্রান্ত। nc-এর কয়েকটি “জাত” আছে (OpenBSD nc, পুরোনো traditional nc, Nmap প্রকল্পের ncat), আর এদের বিকল্প একটু আলাদা: traditional nc-তে শোনার কমান্ড nc -l -p 9000. তাই man nc দেখে নিন। Windows-এ এর কাজ অনেকটা করে Test-NetConnection 127.0.0.1 -Port 9000.

৭ · Kernel-এর কাঁচা হিসাব — /proc/net আর /sys/class/net

এতক্ষণের সব টুল তথ্য পায় kernel থেকে। Linux সেই তথ্যের একটি অংশ ফাইলের আকারে খুলে রাখে — /proc আর /sys ফাইল সিস্টেমে। এগুলো ডিস্কের আসল ফাইল নয়: পড়ার মুহূর্তে kernel লেখাটি বানিয়ে দেয়। কয়েকটি কাজের ফাইল:

একটি গুরুত্বপূর্ণ সূক্ষ্মতা: /proc/net আসলে /proc/self/net-এর একটি link — অর্থাৎ আপনি যে network namespace-এ আছেন, শুধু সেটিরই তথ্য। Docker বা অন্য container-এর ভেতরে /proc/net/tcp পড়লে host-এর socket দেখবেন না (অপারেটিং সিস্টেম কোর্সের container পর্বে namespace বিস্তারিত)।

এই পাতার কোড চলে একটি rootless container-এ — বাইরের সার্ভারের সাথে কাজ করার জন্য এটি বানানো নয়, আর ip বা ss থাকবে কি না নিশ্চিত নয়। তাই নিচের স্ক্রিপ্ট প্রতিটি টুল আগে command -v দিয়ে খুঁজে নেয়, আর না পেলে সরাসরি kernel-এর ফাইল পড়ে। “চালান” চাপুন — এটি সেই container-এর নেটওয়ার্কের এক নজরের ছবি:

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}"; }
echo "== 1. interfaces (/sys/class/net) =="
for d in /sys/class/net/*; do
  echo "  ${d##*/}  state=$(cat "$d/operstate")  mac=$(cat "$d/address")  mtu=$(cat "$d/mtu")"
done
echo "== 2. IPv4 addresses =="
if command -v ip >/dev/null; then ip -br -4 addr
else echo "  (ip নেই; /proc/net/fib_trie থেকে)"
  awk '/32 host/ {print "  " p} {p = $2}' /proc/net/fib_trie 2>/dev/null | sort -u
fi
echo "== 3. default route (/proc/net/route) =="
found=no
while read -r ifc dst gw flags _; do
  if [ "$dst" = 00000000 ]; then echo "  default via $(hex2ip "$gw") dev $ifc flags=$flags"; found=yes; fi
done < <(tail -n +2 /proc/net/route)
if [ "$found" = no ]; then echo "  (default route নেই)"; fi
echo "== 4. counters (/proc/net/dev) =="
tail -n +3 /proc/net/dev | while read -r line; do
  set -- ${line/:/ }
  echo "  $1  rx_bytes=$2 rx_packets=$3  tx_bytes=${10} tx_packets=${11}"
done
echo "== 5. TCP LISTEN sockets (/proc/net/tcp, st=0A) =="
n=0
while read -r sl loc rem st _; do
  if [ "$st" = 0A ]; then echo "  $(hex2ip "${loc%:*}"):$((16#${loc#*:}))"; n=$((n + 1)); fi
done < <(tail -n +2 /proc/net/tcp)
echo "  total LISTEN: $n"
echo "== 6. which tools exist here? =="
for t in ip ss ping traceroute dig curl nc tcpdump; do
  command -v "$t" >/dev/null && echo "  $t: আছে" || echo "  $t: নেই"
done

== 1. interfaces (/sys/class/net) ==
  lo  state=unknown  mac=00:00:00:00:00:00  mtu=65536
  tap0  state=unknown  mac=8a:6e:8f:9e:5c:c6  mtu=65520
== 2. IPv4 addresses ==
lo               UNKNOWN        127.0.0.1/8
tap0             UNKNOWN        10.0.2.100/24
== 3. default route (/proc/net/route) ==
  default via 10.0.2.2 dev tap0 flags=0003
== 4. counters (/proc/net/dev) ==
  lo  rx_bytes=0 rx_packets=0  tx_bytes=0 tx_packets=0
  tap0  rx_bytes=110 rx_packets=1  tx_bytes=250 tx_packets=3
== 5. TCP LISTEN sockets (/proc/net/tcp, st=0A) ==
  total LISTEN: 0
== 6. which tools exist here? ==
  ip: আছে
  ss: আছে
  ping: নেই
  traceroute: নেই
  dig: নেই
  curl: নেই
  nc: নেই
  tcpdump: নেই

/proc/net/tcp-এর একটি লাইন নিজের হাতে পড়া

স্ক্রিপ্টের অংশ ৩ আর ৫-এ আমরা hex থেকে ঠিকানা বানালাম। নিয়মটি একবার হাতে করে দেখা দরকার, কারণ কোনো টুল না থাকলে (ছোট container, ভাঙা সার্ভার, পরীক্ষার খাতা) এটুকুই আপনার ভরসা। নিচে একটি ল্যাপটপের /proc/net/tcp থেকে নেওয়া একটি লাইন — প্রতিটি টুকরো আলাদা করে পড়ুন:

একই নিয়ম /proc/net/route-এ খাটে। সেখানে Destination 00000000 মানে 0.0.0.0 — default route; Gateway 0100A8C0 উল্টে C0 A8 00 01 = ১৯২.১৬৮.০.১; Mask 00FFFFFF উল্টে FF FF FF 00 = ২৫৫.২৫৫.২৫৫.০; আর Flags 0003 = U (চালু) + G (gateway দিয়ে)। এবার একটি ছোট JavaScript decoder দিয়ে পুরো একটি নমুনা ফাইল পড়ি (নমুনাটি একটি ল্যাপটপের মতো করে বানানো; বাইরের ঠিকানাগুলো documentation range-এর):

// Decode /proc/net/tcp lines by hand: hex IP:port and the state code
const STATES = { "01": "ESTABLISHED", "02": "SYN_SENT", "03": "SYN_RECV", "04": "FIN_WAIT1",
  "05": "FIN_WAIT2", "06": "TIME_WAIT", "07": "CLOSE", "08": "CLOSE_WAIT", "09": "LAST_ACK",
  "0A": "LISTEN", "0B": "CLOSING", "0C": "NEW_SYN_RECV" };
const sample = `  sl  local_address rem_address   st tx_queue rx_queue tr tm->when retrnsmt   uid  timeout inode
   0: 3500007F:0035 00000000:0000 0A 00000000:00000000 00:00000000 00000000   991        0 18342 1
   1: 00000000:0016 00000000:0000 0A 00000000:00000000 00:00000000 00000000     0        0 21057 1
   2: 0100007F:0CEA 00000000:0000 0A 00000000:00000000 00:00000000 00000000   113        0 23911 1
   3: 6900A8C0:D5C2 227100CB:01BB 01 00000000:00000000 02:000A3F2C 00000000  1000        0 98213 2
   4: 6900A8C0:B0F4 0F6433C6:01BB 06 00000000:00000000 03:00001523 00000000     0        0 0 3
   5: 6900A8C0:9C40 4A0200C0:0050 02 00000000:00000000 01:00000064 00000002  1000        0 99120 1`;

function ip(hex) {          // "6900A8C0" -> bytes 69 00 A8 C0 -> reverse -> 192.168.0.105
  return hex.match(/../g).map(x => parseInt(x, 16)).reverse().join(".");
}
function endpoint(s) {      // "6900A8C0:D5C2" -> "192.168.0.105:54722"
  const [h, p] = s.split(":");
  return ip(h) + ":" + parseInt(p, 16);
}

console.log("local".padEnd(21) + "remote".padEnd(21) + "st  state        uid");
for (const line of sample.split("\n").slice(1)) {
  const f = line.trim().split(/\s+/);   // f[1]=local f[2]=remote f[3]=st f[7]=uid
  console.log(endpoint(f[1]).padEnd(21) + endpoint(f[2]).padEnd(21) +
              f[3] + "  " + STATES[f[3]].padEnd(13) + f[7]);
}
console.log("check: 0x01BB = " + 0x01BB + ", 0x0CEA = " + 0x0CEA + ", 0x0016 = " + 0x16);

local                remote               st  state        uid
127.0.0.53:53        0.0.0.0:0            0A  LISTEN       991
0.0.0.0:22           0.0.0.0:0            0A  LISTEN       0
127.0.0.1:3306       0.0.0.0:0            0A  LISTEN       113
192.168.0.105:54722  203.0.113.34:443     01  ESTABLISHED  1000
192.168.0.105:45300  198.51.100.15:443    06  TIME_WAIT    0
192.168.0.105:40000  192.0.2.74:80        02  SYN_SENT     1000
check: 0x01BB = 443, 0x0CEA = 3306, 0x0016 = 22

৮ · নিজের socket নিজে খুঁজে দেখা — একটি C পরীক্ষা

এবার তত্ত্বটি নিজের চোখে যাচাই করি। নিচের C প্রোগ্রাম 127.0.0.1-এ একটি TCP listener খোলে। Port নম্বর হিসেবে দেয় 0 — এর মানে “kernel নিজেই একটি খালি port বেছে দিক”। কোন port পাওয়া গেল, তা জানা যায় getsockname() দিয়ে। তারপর একটি child process সেই port-এ সংযোগ করে, আর parent সংযোগ চলাকালীন /proc/net/tcp পড়ে তিনটি socket খুঁজে বের করে: listener, সার্ভারের প্রান্ত আর client-এর প্রান্ত। Port নম্বর প্রতিবার আলাদা হবে, তাই প্রোগ্রাম আসল নম্বর না ছেপে শুধু সম্পর্ক ছাপে — P = সার্ভারের port, C = client-এর port. Socket কোডের প্রতিটি লাইন পর্ব ৪১-এ বিস্তারিত শিখবেন; এখানে শুধু দেখুন kernel-এর খাতায় কী লেখা হয়।

#include <stdio.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/wait.h>
static const char *NAME[] = {"(gone)", "ESTABLISHED", "SYN_SENT", "SYN_RECV", "FIN_WAIT1",
    "FIN_WAIT2", "TIME_WAIT", "CLOSE", "CLOSE_WAIT", "LAST_ACK", "LISTEN", "CLOSING"};
static void show(const char *when, unsigned P, unsigned C) {   /* P = server port, C = client port */
    unsigned la, lp, ra, rp, st, lis = 0, srv = 0, cli = 0, hex = 0; char line[256];
    FILE *f = fopen("/proc/net/tcp", "r");
    while (fgets(line, sizeof line, f))
        if (sscanf(line, " %*u: %X:%X %X:%X %X", &la, &lp, &ra, &rp, &st) == 5 && st < 12) {
            if (lp == P && rp == 0) { lis = st; hex = la; }
            if (lp == P && rp == C) srv = st; else if (lp == C && rp == P) cli = st;
        }
    fclose(f);
    printf("%s\n  listener    local=P           st=%02X %s (local addr hex %08X)\n"
           "  server end  local=P remote=C  st=%02X %s\n  client end  local=C remote=P  st=%02X %s\n",
           when, lis, NAME[lis], hex, srv, NAME[srv], cli, NAME[cli]);
}
int main(void) {
    struct sockaddr_in a = {0}, peer; socklen_t len = sizeof a; char b;
    a.sin_family = AF_INET; a.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    int ls = socket(AF_INET, SOCK_STREAM, 0);   /* port 0 in a: the kernel picks one */
    bind(ls, (struct sockaddr *)&a, sizeof a); listen(ls, 1); getsockname(ls, (struct sockaddr *)&a, &len);
    fflush(stdout); if (fork() == 0) {          /* child = the client; it waits for EOF */
        int c = socket(AF_INET, SOCK_STREAM, 0); connect(c, (struct sockaddr *)&a, sizeof a);
        while (read(c, &b, 1) > 0) {} close(c); _exit(0); }
    len = sizeof peer; int conn = accept(ls, (struct sockaddr *)&peer, &len);
    unsigned P = ntohs(a.sin_port), C = ntohs(peer.sin_port);
    printf("P = port from getsockname, C = client's port; P != C: %s\n", P != C ? "yes" : "no");
    show("while connected:", P, C);
    close(conn); wait(NULL); usleep(200000);                     /* the server closes first */
    show("after the server closed first:", P, C); return 0;
}

P = port from getsockname, C = client's port; P != C: yes
while connected:
  listener    local=P           st=0A LISTEN (local addr hex 0100007F)
  server end  local=P remote=C  st=01 ESTABLISHED
  client end  local=C remote=P  st=01 ESTABLISHED
after the server closed first:
  listener    local=P           st=0A LISTEN (local addr hex 0100007F)
  server end  local=P remote=C  st=06 TIME_WAIT
  client end  local=C remote=P  st=00 (gone)

৯ · Packet নিজের চোখে — tcpdump, Wireshark আর নৈতিকতা

এতক্ষণ আমরা দেখেছি kernel-এর হিসাব। কিন্তু তারে আসলে কোন বাইট যাচ্ছে? সেটি দেখার কাজের নাম packet capture. Command line-এ এর প্রধান টুল tcpdump, আর গ্রাফিক্যাল টুল Wireshark — যেটি প্রতিটি packet-কে স্তর ধরে ধরে খুলে দেখায় (Ethernet → IP → TCP → HTTP), ঠিক পর্ব ৩-এর encapsulation-এর ছবির মতো।

অংশ ৬-এর nc পরীক্ষাটি চলার সময় নিজের ল্যাপটপে loopback interface-এ capture করলে এরকম দেখাবে (উদাহরণ; capture করতে root বা বিশেষ অনুমতি লাগে):

$ sudo tcpdump -i lo -n 'tcp port 9000'
listening on lo, link-type EN10MB (Ethernet), snapshot length 262144 bytes
21:20:01.112233 IP 127.0.0.1.48212 > 127.0.0.1.9000: Flags [S], seq 3049185517, win 65495, options [mss 65495,sackOK,TS val 1912345 ecr 0,nop,wscale 7], length 0
21:20:01.112250 IP 127.0.0.1.9000 > 127.0.0.1.48212: Flags [S.], seq 1772004321, ack 3049185518, win 65483, options [mss 65495,sackOK,TS val 1912345 ecr 1912345,nop,wscale 7], length 0
21:20:01.112262 IP 127.0.0.1.48212 > 127.0.0.1.9000: Flags [.], ack 1, win 512, options [nop,nop,TS val 1912345 ecr 1912345], length 0
21:20:04.530101 IP 127.0.0.1.48212 > 127.0.0.1.9000: Flags [P.], seq 1:7, ack 1, win 512, options [nop,nop,TS val 1915763 ecr 1912345], length 6
21:20:04.530118 IP 127.0.0.1.9000 > 127.0.0.1.48212: Flags [.], ack 7, win 512, options [nop,nop,TS val 1915763 ecr 1915763], length 0

প্রথম তিনটি লাইন TCP-র বিখ্যাত three-way handshake: [S] (SYN), [S.] (SYN + ACK), [.] (ACK). দ্বিতীয় লাইনের ack 3049185518 = প্রথম লাইনের seq + ১. তারপর tcpdump সুবিধার জন্য seq নম্বর আপেক্ষিক করে দেখায় (ack 1). চতুর্থ লাইনে hello আর newline — মোট ৬ বাইট (seq 1:7, length 6), [P.] মানে PUSH + ACK; পঞ্চম লাইনে প্রাপক জানাল “৭ পর্যন্ত পেয়েছি”। mss 65495 = একটি IPv4 packet-এর সর্বোচ্চ আকার ৬৫,৫৩৫ বাইট (header-এর ১৬-বিট দৈর্ঘ্যের ঘর) থেকে IP আর TCP header-এর ৪০ বাইট বাদ — loopback-এর MTU ৬৫,৫৩৬ এর চেয়েও বড়, তাই সীমাটা আসে IPv4 থেকে। এই সংখ্যাগুলোর প্রতিটির মানে পর্ব ২৯–৩১-এ খুলে দেখবেন; এখন শুধু মনে রাখুন — packet capture হলো নেটওয়ার্কের “সত্যের উৎস”, টুলের ব্যাখ্যা নয়, তারে যা গেছে তাই।

Wireshark-এ দুই রকম filter আছে, যা নতুনরা প্রায়ই গুলিয়ে ফেলেন: capture filter (tcpdump-এর মতো BPF ভাষা, যেমন tcp port 9000) ঠিক করে কোন packet আদৌ ধরা হবে; display filter (Wireshark-এর নিজের ভাষা, যেমন tcp.port == 9000) শুধু ধরা packet-এর মধ্যে কোনটি দেখাবে। Windows-এ Wireshark চলে Npcap driver দিয়ে; Windows-এর নিজস্ব pktmon-ও আছে। বিস্তারিত তদন্তের কৌশল পর্ব ৫৫-এ।

ভালো খবর হলো, আজকের ওয়েবের বেশিরভাগ traffic HTTPS-এ এনক্রিপ্ট করা, তাই কেউ capture করলেও বিষয়বস্তু পড়তে পারে না। তবু কিছু তথ্য খোলা থাকে — কোন ঠিকানায় কখন কত বাইট গেল, আর অনেক সময় কোন ডোমেইনে সংযোগ হচ্ছে (DNS প্রশ্ন আর TLS-এর SNI থেকে)। এজন্যই নিজের অ্যাপে HTTPS বাধ্যতামূলক রাখা আর সংবেদনশীল কাজে public Wi-Fi এড়িয়ে চলা ভালো অভ্যাস। এই প্রতিরক্ষার কাঠামো মডিউল ৮-এ।

১০ · AI-এর যুগে নেটওয়ার্ক কমান্ড — কপি করার আগে

“আমার ইন্টারনেট ধীর, কী কমান্ড দেব?” — এ প্রশ্নে AI মুহূর্তে এক গাদা কমান্ড দেবে। কিছু হবে চমৎকার, কিছু পুরোনো, আর কিছু বিপজ্জনক। নেটওয়ার্ক কমান্ডের ক্ষেত্রে ভুলের দাম বেশি: একটি ভুল ip route বা firewall কমান্ড দূরের সার্ভার থেকে আপনাকে চিরতরে বের করে দিতে পারে, আর “সব খুলে দিন” ধাঁচের পরামর্শ সার্ভারকে আক্রমণের জন্য উন্মুক্ত করে।

AI-এর দেওয়া নেটওয়ার্ক কমান্ড চালানোর আগে — চেকলিস্ট

• কমান্ডটি আমার OS-এর, আর command -v দিয়ে নিশ্চিত হয়েছি যে টুলটি আছে
• এটি শুধু “দেখার” কমান্ড, না কিছু বদলায় — বদলালে আগে বর্তমান অবস্থা (ip route, firewall নিয়ম) লিখে রেখেছি
• দূরের সার্ভারে route বা firewall বদলানোর আগে ফেরার পথ (console access বা স্বয়ংক্রিয় rollback) রেখেছি
• hex, subnet বা TTL-এর হিসাব নিজে আবার করে মিলিয়েছি
• কোনো কমান্ড অন্যের যন্ত্র বা নেটওয়ার্ককে লক্ষ্য করছে না; capture বা scan শুধু নিজের, বা লিখিত অনুমতির নেটওয়ার্কে
• AI-এর উল্লেখ করা RFC বা ডকুমেন্টেশন নিজে খুলে দেখেছি