কমান্ড-লাইন আর্গুমেন্ট ও variadic ফাংশন — প্রোগ্রামকে টুল বানানো

১ · প্রোগ্রাম একটি যন্ত্র — আর্গুমেন্ট তার অর্ডার ফর্ম

পর্ব ২৩-এ আমরা রহিম চাচার দোকানের খাতার জন্য একটি CLI টুল বানিয়েছিলাম। সেটি চালানোর পর মেনু দেখাত, প্রশ্ন করত, উত্তরের জন্য অপেক্ষা করত। পর্ব ২৪-এ সেই খাতা ফাইলে জমা হলো — কিন্তু ফাইলের নাম ledger.csv লেখা ছিল কোডের ভেতরেই। অন্য নামের ফাইল খুলতে চাইলে কোড বদলে আবার compile করতে হতো।

এবার একটু অন্যভাবে ভাবুন। আপনি যখন terminal-এ gcc hello.c -o hello লেখেন, gcc আপনাকে কোনো প্রশ্ন করে না। কোন ফাইল, কী নামে বানাবে — সব তথ্য আপনি চালানোর মুহূর্তেই এক লাইনে দিয়ে দেন। gcc সেই নির্দেশ পড়ে কাজ সারে, তারপর একটি সংখ্যা ফেরত দিয়ে চলে যায় — সফল হলো কি না। এই এক লাইনের নির্দেশগুলোকেই বলে command-line argument.

মেনু-ভিত্তিক প্রোগ্রাম মানুষের সাথে কথা বলার জন্য ভালো। কিন্তু আর্গুমেন্ট-ভিত্তিক টুলের একটি বড় সুবিধা আছে: অন্য প্রোগ্রামও একে চালাতে পারে। একটি script রাত ২টায় হাজারটি ফাইলের ওপর আপনার টুল চালাতে পারে, কেউ বসে থেকে মেনুতে “১” চাপার দরকার নেই। এজন্যই git, gcc, docker, ffmpeg — পেশাদার জগতের প্রায় সব শক্তিশালী টুল আর্গুমেন্ট নিয়ে চলে।

২ · argc আর argv — মেমরিতে কেমন দেখায়

পর্ব ০৪-এ আমরা int main(void) লিখেছিলাম — অর্থাৎ main কিছুই নেয় না। আর্গুমেন্ট পেতে হলে main-কে লিখতে হয় এভাবে:

int main(int argc, char *argv[])   /* অথবা: char **argv — একই জিনিস */

• argc (argument count) — মোট কয়টি শব্দ এসেছে, প্রোগ্রামের নিজের নামসহ।
• argv (argument vector) — char pointer-এর একটি অ্যারে। প্রতিটি ঘর একটি string-এর প্রথম অক্ষরের দিকে তাক করে থাকে। পর্ব ১৮-তে দেখেছেন, ফাংশনের parameter-এ char *argv[] আর char **argv একই অর্থ — অ্যারে আসলে pointer হয়ে আসে। তাই argv একটি pointer-to-pointer.

এবার দেখি ./marks report.txt --top 3 চালালে মেমরিতে আসলে কী তৈরি হয়। “পরে” চেপে এগোন:

ফাঁকা জায়গা, quote আর wildcard

শব্দ কোথায় ভাঙবে, সেটা ঠিক করে shell — আপনার প্রোগ্রাম নয়। নামের মধ্যে ফাঁকা জায়গা থাকলে quote দিতে হয়। নিচের টেবিলে দেখুন একই রকম দেখতে কমান্ডে argv কত আলাদা হয়:

শেষ সারিটির নাম wildcard expansion. Linux ও Mac-এর shell *.txt-কে প্রোগ্রাম চালানোর আগেই সব মিলে যাওয়া নামে বদলে দেয়, তাই আপনার প্রোগ্রাম কখনো * চিহ্নটি দেখে না। Windows-এ ব্যাপারটি আলাদা — সেখানে প্রোগ্রাম পুরো কমান্ড-লাইন একটি লম্বা লেখা হিসেবে পায়, আর C runtime library সেটিকে ভেঙে argv বানায়। ফলাফল প্রায় একই হলেও খুঁটিনাটি নিয়মে পার্থক্য আছে।

৩ · লেখা থেকে সংখ্যা — atoi নয়, strtol

--top 3-এর "3"-কে সংখ্যা বানানোর সবচেয়ে পরিচিত উপায় atoi(argv[3]). ছোট, সহজ — আর বিপজ্জনক। atoi("abc") দেয় 0, atoi("0")-ও দেয় 0. দুটোর পার্থক্য বোঝার কোনো উপায় নেই! atoi("3x") চুপচাপ 3 দেয়, আর মান খুব বড় হলে standard অনুযায়ী ফল undefined behavior. অর্থাৎ ভুল ইনপুট এলে atoi কখনো আপনাকে জানায় না।

পেশাদার বিকল্প হলো strtol (string to long), <stdlib.h>-এ। এটি তিনটি জিনিস জানায়:

1. ফল — রূপান্তরিত সংখ্যা, টাইপ long.
2. কোথায় থামল — আপনি একটি char *end-এর ঠিকানা দেন, strtol সেখানে লিখে রাখে কোন অক্ষরে এসে পড়া থেমেছে। একে বলে end pointer. পুরো লেখা সংখ্যা হলে *end হবে '\0'.
3. সীমা ছাড়াল কি না — সংখ্যা long-এ না ধরলে strtol LONG_MAX বা LONG_MIN ফেরত দেয় আর errno-তে বসায় ERANGE.

একটি সূক্ষ্ম কিন্তু জরুরি নিয়ম: সফল হলে strtol errno-কে 0 করে না। আগের কোনো ভুলের পুরোনো মান থেকে যেতে পারে। তাই ডাকার ঠিক আগে নিজে errno = 0 লিখতে হয়। নিচের ডায়াগ্রামে পাঁচটি ভিন্ন ইনপুটে strtol কী করে দেখুন:

লেখা :  4  2  \0
                ^
               end      (*end == '\0' — পুরোটা সংখ্যা)
ফল   :  42
errno:  0

লেখা :  4  2  a  b  c  \0
              ^
             end        (*end == 'a' — পেছনে আবর্জনা)
ফল   :  42              atoi এটিকেই 42 বলে মেনে নিত
errno:  0

লেখা :  a  b  c  \0
        ^
       end == লেখার শুরু  (একটি অঙ্কও পড়া যায়নি)
ফল   :  0               — কিন্তু এই 0 আসল 0 নয়
errno:  0

লেখা :  20টি 9         (64-bit long-এর সীমা প্রায় 9.22 x 10^18)
end  :  '\0'-এ         (সব অঙ্কই পড়া হয়েছে)
ফল   :  LONG_MAX       (9223372036854775807)
errno:  ERANGE         — সীমা ছাড়িয়েছে

লেখা :  -  7  \0
              ^
             end        (পুরোটা সংখ্যা)
ফল   :  -7
errno:  0
আপনার নিয়ম: --top হতে হবে 1..100  →  বাতিল

এই চারটি পাহারা প্রতিবার আলাদা করে লেখার বদলে একটি ছোট helper ফাংশনে রাখাই ভালো। নিচের কোডটি শুধু পড়ার জন্য — চালানোর উদাহরণ আসছে অংশ ৫-এ:

#include <errno.h>
#include <stdlib.h>

/* সফল হলে 1 ফেরত দেয় আর *out-এ মান রাখে; ব্যর্থ হলে 0 */
int parse_long(const char *s, long lo, long hi, long *out) {
    char *end;
    errno = 0;                         /* পুরোনো মান মুছে দিন */
    long v = strtol(s, &end, 10);
    if (end == s || *end != '\0') return 0;      /* সংখ্যাই নয়, বা পেছনে আবর্জনা */
    if (errno == ERANGE || v < lo || v > hi) return 0;  /* সীমার বাইরে */
    *out = v;
    return 1;
}

ভুল হলে কোথায় বলবেন, আর কী ফেরত দেবেন

পর্ব ১০-এ দেখেছেন, প্রতিটি প্রোগ্রামের দুটি আলাদা আউটপুট-পাইপ আছে: stdout আর stderr. নিয়মটি সহজ — আসল ফল stdout-এ, সমস্যার কথা stderr-এ। কেন এত কড়াকড়ি? ধরুন কেউ লিখলেন ./marks report.txt > top.txt. Error যদি stdout-এ যায়, সেটা চুপচাপ top.txt ফাইলের ভেতরে ঢুকে যাবে, স্ক্রিনে কিছুই দেখা যাবে না। stderr আলাদা থাকায় redirection করলেও error স্ক্রিনে আসে।

আর পর্ব ০৪-এর return 0 মনে আছে? সেটিই exit status. প্রথা অনুযায়ী:

শুধু ০ আর “০ ছাড়া অন্য কিছু” — এটুকুই সব সিস্টেমে নিশ্চিত। ১ আর ২-এর পার্থক্য একটি প্রচলিত প্রথা, যা অনেক Unix টুল মানে। যেমন grep: মিল পেলে ০, কিছু না মিললে ১, আর কোনো ত্রুটি হলে ২. Error সামলানোর পুরো কৌশল আসবে পর্ব ৩০-এ।

৪ · অপশন আর ফ্ল্যাগ — নিজের হাতে পার্সিং

বেশিরভাগ টুলের আর্গুমেন্ট দুই রকম। কিছু হলো option — - বা -- দিয়ে শুরু, আচরণ বদলায়। বাকিগুলো হলো সাধারণ আর্গুমেন্ট, যেমন ফাইলের নাম। অপশনেরও দুই জাত:

পার্সিংয়ের মূল কৌশল একটি লুপ: i = 1 থেকে শুরু করে প্রতিটি argv[i] দেখা। অপশন মানসহ হলে পরের শব্দটিও “খেয়ে ফেলা” — অর্থাৎ i এক ঘর বাড়তি এগোনো। নিচে ./marks -n 3 report.txt-এর জন্য লুপটি ধাপে ধাপে চলছে:

1for (int i = 1; i < argc; i++) {2    if (strcmp(argv[i], "-n") == 0 && i + 1 < argc) {3        top = parse(argv[++i]);4    } else if (argv[i][0] == '-') {5        return usage("unknown option");6    } else {7        file = argv[i];8    }9}10printf("file=%s top=%ld\n", file, top);

প্রচলিত নিয়মগুলো — ব্যবহারকারী যা আশা করেন

টুল যেই বানাক, ব্যবহারকারীরা কিছু আচরণ ধরে নেন। এগুলো মানলে আপনার টুল প্রথম দিনেই “চেনা” লাগবে:

• -h ও --help: একটি usage message stdout-এ ছেপে exit 0 — কারণ সাহায্য চাওয়া কোনো ভুল নয়। কিন্তু ভুল ব্যবহারের পর usage যায় stderr-এ, exit 2.
• Usage-এর চেহারা: usage: marks [-v] [-n N] FILE — বর্গবন্ধনী মানে ঐচ্ছিক, বড় হাতের শব্দ মানে “এখানে আপনার মান বসান”।
• -- মানে অপশন শেষ: ./marks -- -report.txt লিখলে -report.txt-কে অপশন নয়, ফাইলের নাম ধরা হয়। একে বলে end of options চিহ্ন। - দিয়ে শুরু হওয়া নামের ফাইল মুছতে rm -- -file লিখতে হয় ঠিক এই কারণেই।
• শুধু - মানে stdin: অনেক টুলে ফাইলের নামের জায়গায় একটি - দিলে টুলটি stdin থেকে পড়ে।
• ছোট অপশন জোড়া দেওয়া: ls -l -a আর ls -la একই। এটি হাতে লেখা লুপে সামলানো ঝামেলার — এজন্যই আছে getopt.

getopt — চাকা নতুন করে না বানানো

Linux, Mac ও অন্যান্য POSIX সিস্টেমে অপশন পার্সিংয়ের তৈরি ফাংশন আছে: getopt. আপনি একটি ছোট লেখায় বলে দেন কোন কোন অপশন চলবে — "vn:h" মানে -v, -h সুইচ, আর -n-এর পরে : আছে বলে সেটি একটি মান নেয়। বাকি সব হিসাব getopt নিজেই করে:

#include <unistd.h>      /* POSIX — standard C নয়, Windows-এ সাধারণত নেই */

int opt;
while ((opt = getopt(argc, argv, "vn:h")) != -1) {
    switch (opt) {
    case 'v': verbose = 1; break;
    case 'n': if (!parse_long(optarg, 1, 100, &top)) return usage_error(); break;
    case 'h': print_usage(stdout); return 0;
    default:  return usage_error();      /* getopt নিজেই '?' ফেরত দেয় ও বার্তা ছাপে */
    }
}
/* অপশনের পরে বাকি নামগুলো: argv[optind] থেকে argv[argc - 1] পর্যন্ত */

optarg-এ থাকে অপশনের মান, আর optind বলে দেয় অপশন শেষে বাকি আর্গুমেন্ট কোথা থেকে শুরু। -vn 3, -n3, -- — সবই getopt ঠিকঠাক বোঝে। --help বা --top=3-এর মতো লম্বা অপশনের জন্য GNU ও BSD (Mac-সহ) সিস্টেমে আছে getopt_long, থাকে <getopt.h>-এ। বড় প্রজেক্টে নিজে লুপ না লিখে এগুলোই ব্যবহার করুন — তবে ভেতরে কী হয়, সেটা আপনি এখন জানেন।

৫ · CLI টেস্ট করা — argv-কে নকল করে বানানো

এখানে একটি বাস্তব সমস্যা আছে। এই পাতার কোড-রানার প্রোগ্রামকে কোনো আর্গুমেন্ট পাঠাতে পারে না — সে শুধু ./prog চালায়। তাহলে argv নিয়ে লেখা কোড পরীক্ষা করব কীভাবে?

সমাধানটি শুধু এখানে কাজ চালানোর কৌশল নয় — এটি পেশাদারদের unit test লেখার আসল পদ্ধতি। সব কাজ main-এ না রেখে একটি run(int argc, char **argv) ফাংশনে রাখুন, যা একটি exit status ফেরত দেয়। আসল প্রোগ্রামে main শুধু একটি লাইন: return run(argc, argv);. আর পরীক্ষার সময় main নিজেই নকল argv বানিয়ে run-কে বারবার ডাকে — একবার সঠিক ইনপুটে, একবার ভুলে — আর exit status মিলিয়ে দেখে।

নিচের প্রোগ্রামে run একটি ছোট marks টুল: -n-এর মান যাচাই করে, অজানা অপশন ধরে, ফাইলের নাম না পেলে usage দেখায়। main দুটি নকল কমান্ড-লাইন দিয়ে একে পরীক্ষা করছে — দ্বিতীয়টিতে "3x" ইচ্ছা করে ভুল:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
int usage(const char *why) { fprintf(stderr, "marks: %s\nusage: marks [-n 1..100] FILE\n", why); return 2; }
int run(int argc, char **argv) {
    long top = 5; const char *file = NULL;
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-n") == 0 && i + 1 < argc) {
            char *end; errno = 0; top = strtol(argv[++i], &end, 10);
            if (errno != 0 || end == argv[i] || *end != '\0' || top < 1 || top > 100) return usage("bad -n value");
        } else if (argv[i][0] == '-') return usage("unknown option");
        else file = argv[i];
    }
    if (file == NULL) return usage("no file given");
    printf("file=%s top=%ld\n", file, top); return 0;
}
int main(void) {
    char *t[2][5] = { {"marks", "-n", "3", "report.txt", NULL}, {"marks", "-n", "3x", "report.txt", NULL} };
    for (int k = 0; k < 2; k++) printf("exit=%d\n", run(4, t[k]));
    return 0;
}

এই পদ্ধতির আসল শক্তি হলো test case-এর তালিকা। একটি ভালো CLI-র জন্য অন্তত এগুলো পরীক্ষা করা উচিত:

পর্ব ৩২-এ টেস্টিং নিয়ে বিস্তারিত দেখবেন — সেখানে এই তালিকাই একটি স্বয়ংক্রিয় test harness হয়ে উঠবে।

৬ · Environment variable আর exit status — টুল দিয়ে টুল জোড়া

Environment — প্রতিটি প্রোগ্রামের সাথে আসা পরিবেশ

আর্গুমেন্ট ছাড়াও প্রতিটি প্রোগ্রাম জন্মের সময় একটি তালিকা পায়: নাম=মান জোড়া, যেমন HOME=/home/rafi বা LANG=bn_BD.UTF-8. এদের বলে environment variable. আর্গুমেন্ট হলো “এই একবারের অর্ডার”, আর environment হলো “এই দোকানের স্থায়ী নিয়ম” — প্রতিবার বলে দিতে হয় না।

#include <stdlib.h>

const char *home = getenv("HOME");     /* না থাকলে NULL */
if (home == NULL) home = ".";          /* তাই সবসময় NULL যাচাই, তারপর ডিফল্ট */

getenv standard C-এর অংশ, তাই সব জায়গায় চলে। সবচেয়ে পরিচিত environment variable হলো PATH — কয়েকটি ফোল্ডারের তালিকা। আপনি শুধু gcc লিখলে shell এই ফোল্ডারগুলোতে একে একে gcc নামের প্রোগ্রাম খোঁজে। পর্ব ০৩-এর “gcc is not recognized” error-এর মানে আসলে এটিই: gcc-র ফোল্ডারটি PATH-এ নেই।

কিছু পুরোনো বই ও AI-এর কোডে int main(int argc, char *argv[], char *envp[]) দেখবেন। এই তৃতীয় parameter envp অনেক সিস্টেমে কাজ করে, কিন্তু C standard-এ নেই — standard শুধু একে একটি “প্রচলিত extension” হিসেবে উল্লেখ করে। বহনযোগ্য কোডে getenv-ই ব্যবহার করুন। আর একটি নিরাপত্তা-সতর্কতা: environment-এর মান ব্যবহারকারী বদলাতে পারেন, তাই আর্গুমেন্টের মতোই একেও যাচাই না করে বিশ্বাস করবেন না।

Exit status — ছোট টুল জুড়ে বড় কাজ

এখন বোঝা যাবে exit status এত জরুরি কেন। Shell প্রতিটি প্রোগ্রামের exit status মনে রাখে ($?-এ), আর সেই অনুযায়ী পরের সিদ্ধান্ত নেয়:

$ ./marks -n 3 report.txt && echo "ok"        # marks 0 দিলে তবেই echo চলবে
$ ./marks -n 3x report.txt || echo "failed"   # marks ব্যর্থ হলে তবেই echo চলবে
$ ./marks -n 3x report.txt; echo $?           # শেষ প্রোগ্রামের exit status দেখুন: 2
$ ./marks -n 10 report.txt | sort | head -3   # pipe: এক টুলের stdout পরের টুলের stdin

শেষ লাইনটি pipe. marks-এর stdout সরাসরি sort-এর stdin-এ যায়, তারপর head-এ। কোনোটিই অন্যটির কথা জানে না — প্রত্যেকে শুধু লেখা পড়ে আর লেখা দেয়। এখানেই stdout/stderr আলাদা রাখার আসল মূল্য: আপনার error যদি stdout-এ যেত, সেটা sort-এর ভেতরে ঢুকে সাজানো ডেটার মাঝে মিশে যেত। Pipe ভেতরে কীভাবে তৈরি হয় — fork, exec, pipe() — সেটা পর্ব ৪৮-এ দেখবেন।

৭ · Variadic ফাংশন — printf যেভাবে যতখুশি মান নেয়

এতক্ষণ দেখলাম একটি প্রোগ্রাম কীভাবে যতখুশি শব্দ নেয়। এবার একটি ফাংশন-এর একই প্রশ্ন। printf("%d", x)-এ দুটি argument, printf("%s %d %f", a, b, c)-এ চারটি। পর্ব ১৩-এর নিয়মে তো প্রতিটি ফাংশনের parameter-সংখ্যা নির্দিষ্ট! তাহলে printf এটা করে কীভাবে?

উত্তর printf-এর ঘোষণাতেই: int printf(const char *format, ...);. ওই তিনটি বিন্দু (..., ellipsis) মানে “এরপর যতগুলো খুশি, যেকোনো টাইপের argument আসতে পারে।” এমন ফাংশনকে বলে variadic function. নিজে লিখতে লাগে <stdarg.h>-এর চারটি জিনিস:

একটি গুরুত্বপূর্ণ কথা: variadic ফাংশন নিজে থেকে জানে না কয়টি argument এসেছে, বা কোনটির টাইপ কী। এই তথ্য তাকে কোনোভাবে জানাতে হয়। printf জানে format string পড়ে — যতগুলো %, ততগুলো মান। আমাদের sum জানবে প্রথম argument count থেকে। নিচে sum(4, 10, 20, 30, 40) ডাকা হলে ভেতরে কী ঘটে দেখুন:

1int sum(int count, ...) {2    va_list ap;3    va_start(ap, count);4    int total = 0;5    for (int i = 0; i < count; i++)6        total += va_arg(ap, int);7    va_end(ap);8    return total;9}

Default argument promotions — ...-এর লুকানো রূপান্তর

পর্ব ০৮-এ লুকানো টাইপ রূপান্তর দেখেছেন। ...-এর জায়গায় মান পাঠালেও একটি বিশেষ রূপান্তর ঘটে, যার নাম default argument promotions: char ও short হয়ে যায় int (integer promotion), আর float হয়ে যায় double. ফলাফল দুটি:

• va_arg(ap, char) বা va_arg(ap, float) কখনো লিখবেন না। ওই টাইপ ... দিয়ে কখনো পৌঁছায়ই না। পড়তে হবে int বা double হিসেবে। GCC এমন কোড দেখলে warning দেয়।
• এজন্যই printf-এ float ও double দুটোর জন্যই %f! printf কখনো float পায় না — সব double হয়ে আসে। কিন্তু scanf-এ মান নয়, ঠিকানা যায় (pointer-এর promotion হয় না), তাই সেখানে double-এর জন্য %lf লাগে। পর্ব ১০-এর সেই ধাঁধার উত্তর এটাই।

নিজের printf-এর মতো ফাংশন — vfprintf

বাস্তবে variadic ফাংশনের সবচেয়ে প্রচলিত ব্যবহার হলো printf-এর ওপর একটি মোড়ক, যেমন log লেখার ফাংশন যা প্রতিটি লাইনের আগে একটি চিহ্ন বসায়। কিন্তু সমস্যা: আপনার পাওয়া ... সরাসরি printf-কে দেওয়া যায় না। এজন্য printf-পরিবারের প্রতিটি সদস্যের একটি “v” সংস্করণ আছে, যা একটি va_list নেয়: vprintf, vfprintf, vsnprintf. নিচের প্রোগ্রামে sum আর log_msg দুটোই আছে:

#include <stdio.h>
#include <stdarg.h>
int sum(int count, ...) {
    va_list ap; int total = 0;
    va_start(ap, count);
    for (int i = 0; i < count; i++) total += va_arg(ap, int);
    va_end(ap);
    return total;
}
__attribute__((format(printf, 1, 2)))
void log_msg(const char *fmt, ...) {
    va_list ap; va_start(ap, fmt);
    printf("[log] ");
    vfprintf(stdout, fmt, ap);
    va_end(ap);
}
int main(void) {
    char grade = 'A';
    log_msg("sum = %d\n", sum(4, 10, 20, 30, 40));
    log_msg("grade %c, avg %.1f\n", grade, 76.5f);
    return 0;
}

৮ · Varargs-এর অন্ধকার দিক — টাইপ-যাচাই নেই

সাধারণ ফাংশনে ভুল টাইপ দিলে compiler সাথে সাথে ধরে, কারণ prototype-এ প্রতিটি parameter-এর টাইপ লেখা থাকে। কিন্তু ...-এর পরে কোনো টাইপ লেখা নেই। Compiler-এর কাছে সেখানে যা খুশি পাঠানো বৈধ। কে কী টাইপ পড়বে, সেই চুক্তি থাকে শুধু format string-এ বা আপনার মাথায়।

সুখবর হলো, printf-এর জন্য GCC ও Clang বিশেষ ব্যবস্থা রেখেছে। -Wall চালু থাকলে -Wformat-ও চালু হয়, আর compiler format string পড়ে প্রতিটি মানের টাইপ মিলিয়ে দেখে। উপরের প্রথম তিনটি ভুলই warning হয়ে ধরা পড়ে। কিন্তু চতুর্থটি ধরা পড়ে না — আপনার নিজের sum-এর নিয়ম compiler জানে না। নিজের printf-মতো ফাংশনে format attribute লাগালে সেটিও printf-এর মতো যাচাই পায় — উপরের log_msg-এ ঠিক এটাই করেছি।

printf(user_input) — এক লাইনের নিরাপত্তা-ছিদ্র

এবার সবচেয়ে বিপজ্জনক ভুলটি। ব্যবহারকারীর নাম ছাপতে অনেকে লেখেন printf(argv[1]);. দেখতে নিরীহ, আর সাধারণ নামে ঠিকঠাক চলে। কিন্তু কেউ যদি নাম হিসেবে দেন "%x %x %x %x"? printf ভাববে এটি format string, আর চারটি মান খুঁজতে যাবে যা কেউ পাঠায়নি — ফলে stack-এর গোপন মেমরি স্ক্রিনে ছেপে দেবে। আরও খারাপ, %n চিহ্নটি printf-কে দিয়ে মেমরিতে লেখায়। এই আক্রমণের নাম format string vulnerability, আর ১৯৯৯–২০০০ সালের দিকে এটি ব্যাপকভাবে পরিচিত হয় — তখন wu-ftpd-এর মতো জনপ্রিয় সার্ভার সফটওয়্যারে এমন ত্রুটি দিয়ে দূর থেকে সার্ভার দখল করা গিয়েছিল।

নিয়মটি একটাই: format string সবসময় আপনার নিজের লেখা, কোডের ভেতরের একটি স্থির লেখা হবে — কখনো বাইরে থেকে আসা কিছু নয়। GCC-র -Wformat-security (কিছু Linux distribution এটি ডিফল্টে চালু রাখে) ঠিক এই ভুলটি ধরে। নিরাপত্তা-ত্রুটি কীভাবে খুঁজে বের করা ও ঠেকানো হয়, তা নিয়ে আরও গভীরে যেতে পারেন Cybersecurity কোর্সে, আর C-র দিক থেকে পর্ব ৪৬-এ।

৯ · AI-এর যুগে — CLI কোডে AI যেসব ভুল করে

“একটা C প্রোগ্রাম লেখো যা ফাইলের নাম আর একটি সংখ্যা আর্গুমেন্ট হিসেবে নেবে” — এমন অনুরোধে AI কয়েক সেকেন্ডে কোড দেয়, আর সাধারণ ইনপুটে সেটা চলেও। সমস্যা লুকিয়ে থাকে কিনারায়। AI শিখেছে লাখো টিউটোরিয়াল থেকে, আর সেগুলোর বেশিরভাগই ছোট রাখতে যাচাই বাদ দেয়। নিচের ভুলগুলো বারবার দেখা যায়:

AI-এর CLI কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• আর্গুমেন্ট ছাড়া চালিয়েছি — crash নয়, usage আর exit 2 এসেছে
• সংখ্যার জায়গায় abc, 3x, -5 আর ২০ অঙ্কের সংখ্যা দিয়েছি — সবগুলো বাতিল হয়েছে
• ./tool … > out.txt চালিয়ে দেখেছি error স্ক্রিনেই আসে, ফাইলে ঢোকে না
• প্রতিটি ব্যর্থতার পরে echo $? দিয়ে exit status ০ নয় তা নিশ্চিত করেছি
• কোডে printf(-এর পরে সরাসরি কোনো ভ্যারিয়েবল আছে কি না খুঁজেছি
• প্রতিটি va_arg-এর টাইপ promotion-এর পরের টাইপ (int/double/pointer) কি না দেখেছি, আর প্রতিটি va_start-এর একটি va_end আছে