When you use snprintf() instead of sprintf(), are you:
A. Writing code that proactively detects bugs.
B. Writing code that proactively prevents bugs.
Did you answer "B"? TRICK QUESTION! The correct answer is:
C. Writing code that proactively hides bugs.
Here's a short program that takes a directory name as an argument and prints the first line of the file "tst.c" in that directory:
#include <stdio.h> #include <string.h> int main(int argc, char **argv) { char path[20]; char iline[4]; snprintf(path, sizeof(path), "%s/tst.c", argv[1]); FILE *fp = fopen(path, "r"); fgets(iline, sizeof(iline), fp); fclose(fp); printf("iline='%s'\n", iline); return 0; }Nice and safe, right? Both snprintf() and fgets() do a great job of not overflowing their buffers. Let's run it:
$ ./tst . iline='#inc'
Hmm ... didn't get the full input line. I guess my iline array was too small. But hey, at least it didn't seg fault, like it might have if I had just used scanf() or something dangerous like that! No seg faults for me.
$ ./tst ././././././././. Segmentation fault: 11
Um ... oh, silly me. My path array was too small. fopen() failed, and I didn't check its return status.
So I could, and should, check fopen()'s return status. But that just gives me a more user-friendly error message. It doesn't tell my *why* the file name is wrong. Imagine the snprintf() being in a completely different area of the code. Yes, you discover there's a bug by checking fopen(), but it's nowhere near where the bug actually is. Same thing, by the way, with the fgets() not reading the entire line. Who knows how much more code is going to be executed before the program misbehaves because it didn't get the entire line?
And that is my point. Most of these "safe" functions work the same way: you pass in the size of your buffer, and the functions guarantee that they won't overrun your buffer, but give you *NO* indication that they truncated. I.e. they don't tell you when your buffer is too small. It's not until later that something visibly misbehaves, and that wastes time and effort working your way back to the root cause.
Now I'm not suggesting that we throw away snprintf() in favor of sprintf(). I'm suggesting that using snprintf() is only half the job. How about this:
#include <stdio.h> #include <string.h> #include <assert.h> #define BUF2SMALL(_s) do {\ assert(strnlen(_s, sizeof(_s)) < sizeof(_s)-1);\ } while (0) int main(int argc, char **argv) { char path[21]; char iline[5]; snprintf(path, sizeof(path), "%s/tst.c", argv[1]); BUF2SMALL(path); FILE *fp = fopen(path, "r"); assert(fp != NULL); fgets(iline, sizeof(iline), fp); BUF2SMALL(iline); fclose(fp); printf("iline='%s'\n", iline); return 0; }
Now let's run it:
$ ./tst ./. Assertion failed: (strnlen(iline, sizeof(iline)) < sizeof(iline)-1), function main, file tst.c, line 15. Abort trap: 6 $ ./tst ././././././././. Assertion failed: (strnlen(path, sizeof(path)) < sizeof(path)-1), function main, file tst.c, line 13. Abort trap: 6
There. My bugs are reported *much* closer to where they really are.
The essence of the BUF2SMALL() macro is that you should use a buffer which is at least one character larger than the maximum size you think you need. So if you want an answer string to be able to hold either "yes" or "no", don't make it "char ans[4]", make it at least "char ans[5]". BUF2SMALL() asserts an error if the string consumes the whole array.
One final warning. Note that in BUF2SMALL() I use "strnlen()" instead of "strlen()". I wrote BUF2SMALL() to be a general-purpose error checker after a variety of "safe" functions. For example, maybe I want to use it after a "strncpy()". Look at what the man page for "strncpy()" says:
Warning: If there is no null byte among the first n bytes of src, the string placed in dest will not be null-terminated.
If you use "strncpy()" to copy a string, the string might not be null-terminated, and strlen() has a good chance of segfaulting. So I used strnlen(), which is only "safe" in that it won't segfault. But it doesn't tell me that the string isn't null-terminated! So I still need my macro to tell me that the buffer is too small. The "safe" functions only make the fuse a little longer on the stick of dynamite in your program.