Exercises — Safe alternatives — strncpy, snprintf, strlcpy

• strcpy → (c). Yeh sirf source ke apne '\0' par rukta hai; yeh kabhi destination size nahi dekhta. Yeh woh unsafe function hai strcpy and sprintf (unsafe) se.
• strncpy → (a). n par cap hai, lekin ek full/overflowing source par yeh exactly n bytes likhta hai aur koi terminator nahi add karta — woh trap.
• snprintf → (b). Total bytes written ≤ size, aur yeh '\0' ke liye last box reserve karta hai, isliye result hamesha ek valid string hota hai jab size > 0 ho.

• strncpy dest return karta hai (woh pointer jo tumne pass kiya) — truncation detect karne ke liye useless.
• snprintf un characters ki count return karta hai jo yeh likhta, '\0' exclude karke. Truncation tab hua jab return >= size.
• strlcpy strlen(src) return karta hai — woh full length jise yeh copy karne ki koshish kar raha tha. Truncation tab hua jab return >= size.

Pattern: snprintf aur strlcpy dono tumhe ek number dete hain jise tum size se compare kar sako. strncpy kuch bhi useful nahi deta.

sizeof(buf) 6 hai (chhe boxes — dekho sizeof vs strlen yeh samajhne ke liye ki sizeof array ki box count kyun deta hai, text length nahi). Source "abc" 3 visible chars plus apna '\0' = 4 bytes hai, jo n = 6 se choti hai. strncpy a b c \0 copy karta hai, phir baaki boxes ko '\0' se pad karta hai: $\text{’a’ ’b’ ’c’ ’0’ ’0’ ’0’}$ Valid string? Haan — box 3 mein '\0' hai, isliye strlen(buf) == 3. Yahan safe hai purely isliye kyunki source choti thi.

"abcdef" 6 visible chars hai. n = 6. strncpy exactly 6 bytes content copy karta hai: $\text{’a’ ’b’ ’c’ ’d’ ’e’ ’f’}$ Kahi bhi '\0' nahi — source ne poora byte budget fill kar diya, isliye fence ke liye koi box nahi bachi. Valid? Nahi. strlen(buf) box 5 se adjacent memory mein run off kar deta (undefined behaviour — dekho Memory safety and undefined behavior). Fix:

strncpy(buf, "abcdef", sizeof(buf) - 1); // cap at 5
buf[sizeof(buf) - 1] = '\0';             // box 5 = fence

Ab buf = a b c d e '\0', jo truncated string "abcde" deta hai (strlen == 5).

"val=42" 6 visible chars hai, jise 7 bytes chahiye (6 + '\0'). Sirf 6 boxes hain, aur snprintf hamesha last box reserve karta hai '\0' ke liye. Isliye yeh 5 content chars + terminator likhta hai: $\text{’v’ ’a’ ’l’ ’=’ ’4’ ’0’}$ giving buf = "val=4". r woh length hai jo yeh produce karta = strlen("val=42") = 6. Truncation check: $r\ge \text{size}⟺6\ge 6$ → true, truncation hua. (Dekho Format strings and printf family yeh samajhne ke liye ki %d kaise expand hota hai.)

strlcpy content ko size - 1 = 7 par cap karta hai aur hamesha terminate karta hai: $\text{’0’ ’1’ ’2’ ’3’ ’4’ ’5’ ’6’ ’0’}$ isliye buf = "0123456". Yeh strlen(src) = 10 return karta hai (woh full length jise yeh try kiya). $10\ge 8$ → truncation detected, ek line mein, free. Contrast karo strncpy se same call ke saath: yeh exactly 8 content bytes 0 1 2 3 4 5 6 7 copy karta hai bina terminator ke — ek invalid string. Woh single difference (fence vs no fence) hi puri wajah hai ki strlcpy ko "woh strncpy jo hona chahiye tha" kaha jaata hai.

5 content chars + 1 terminator = 6 bytes, jo exactly sizeof(buf) = 6 hai. Perfect fit: $\text{’h’ ’e’ ’l’ ’l’ ’o’ ’0’}$ buf = "hello". Return r = 5. Truncation check: $r\ge \text{size}⟺5\ge 6$ → false. Koi truncation nahi — sahi, kyunki sab kuch (fence samajhkar) fit hua. Yeh important boundary hai: r == size - 1 sabse bada value hai jiska matlab "sab kuch fit hua."

Jab size == 0 ho, snprintf ko koi bhi byte likhna forbidden hai — ek '\0' bhi nahi. Isliye buf[0] 'X' rehta hai; buffer untouched hai. Lekin yeh phir bhi compute karta hai ki yeh kya likhta aur woh return karta hai: strlen("hi") = 2. Yeh ek common idiom hai — pehle snprintf(NULL, 0, fmt, ...) call karo needed length measure karne ke liye, phir exactly r + 1 bytes allocate karo aur dobara call karo. Measure-then-write pattern is rule par rely karta hai.

void copy_safe(char *dst, size_t dstsize, const char *src) {
    if (dstsize == 0) return;          // fence ke liye bhi jagah nahi
    strncpy(dst, src, dstsize - 1);    // content ko C-1 par cap karo
    dst[dstsize - 1] = '\0';           // fence ko last box mein force karo
}

Har line kyun hai:

• dstsize == 0 guard: zero boxes ke saath hum ek terminator bhi nahi likh sakte; dst[-1] likhna ek out-of-bounds write hoga (Buffer overflow and stack smashing).
• strncpy(..., dstsize - 1): last box reserve karta hai, isliye strncpy kabhi box dstsize - 1 touch nahi kar sakta.
• dst[dstsize - 1] = '\0': unconditionally fence place karta hai. Agar source lambi thi, toh yeh truncate karta hai; agar choti thi, toh yeh box already padding se '\0' tha — dono cases mein sahi hai.

char out[16];
const char *name = "alexandra";       // 9 chars
int r = snprintf(out, sizeof(out), "user=%s", name);
int truncated = (r >= (int)sizeof(out));

"user=alexandra" 5 + 9 = 14 chars hai, jise 15 bytes chahiye. sizeof(out) = 16, isliye spare room ke saath fit hota hai: $\text{out = "user=alexandra"},r=14$ truncated = (14 >= 16) = false (0). Sahi — koi data nahi gaya. Note karo (int) cast: sizeof ek unsigned size_t yield karta hai; unsigned r ke against signed comparison ke bina cast ke misbehave kar sakta hai agar r kabhi negative ho (encoding error). Cast comparison ko honest banata hai.

char out[9];
int r = snprintf(out, sizeof(out), "%s-%s", "hello", "world");

Full result "hello-world" 5 + 1 + 5 = 11 chars hai, jise 12 bytes chahiye. Sirf 9 boxes hain, aur snprintf last ek '\0' ke liye reserve karta hai, isliye yeh 8 content chars + fence likhta hai: $\text{’h’ ’e’ ’l’ ’l’ ’o’ ’-’ ’w’ ’o’ ’0’}$ out = "hello-wo". Return r = 11 (woh wanted length). Truncation: $11\ge 9$ → true. Ek sahi buffer ko r + 1 = 12 bytes chahiye. Yahi measure trick hai: r tumhe exactly batata hai agali baar kitna bada banana hai.

size_t need = strlen(src) + 1;   // +1 '\0' fence ke liye
char *dst = malloc(need);
memcpy(dst, src, need);          // content AUR terminator copy karo

Yeh bulletproof kyun hai:

• strlen(src) visible chars count karta hai (src ke apne '\0' par rukta hai), isliye need exactly content + fence hai.
• malloc(need) precisely utne hi boxes allocate karta hai — koi overflow possible nahi kyunki buffer data se size kiya gaya tha.
• memcpy(dst, src, need) need bytes copy karta hai, aur kyunki src ka box need - 1 uska '\0' hai, fence bhi copy ho jaata hai. Koi manual termination needed nahi.
• Sirf standard functions use karta hai → har jagah portable, koi strlcpy dependency nahi. Yeh "cup ko paani ke hisaab se size karo" strategy hai — "fixed cup mein daalo" ka inverse, aur yeh kabhi truncate nahi karta.

Source "1234567" 7 content chars hai, jise total 8 bytes chahiye (7 + fence). b mein exactly 8 boxes hain — ek exact fit.

Subtle point: yahan even strncpy ek valid string produce karta hai! Source "1234567" 7 chars hai; strncpy 7 content bytes copy karta hai aur uske paas 1 byte bachi hai, jise woh source ke apne '\0' se fill karta hai, phir pad karta hai (pad karne ke liye kuch nahi baca). Yeh sirf isliye succeed karta hai kyunki content n - 1 bytes thi, n nahi. Source ko 8 chars tak push karo aur strncpy break kar jaata hai jabki dono aur safe rehte hain. snprintf/strlcpy 7 return karte hain; kyunki $7<8$, koi truncation flag nahi hua — sahi, sab kuch fit hua.

"n fence bhool jaata hai; printf aur l hamesha baandhte hain." Ek extra argument — destination size — poori safety ki kahaani hai. Size jawaab deta hai "cup kitna bada hai?" Ise kabhi skip mat karo. Aur fence rule: content ≤ capacity − 1, hamesha.