Sure, it can be important to know what these problems are and how to identify them if you should have to read through some terrible code written by someone else. Still, I think the author goes a bit far; it should be more important that you hire a programmer who doesn't produce this sort of code in the first place.
In the end I think there is no "best way" to technically test programmers; you're better off covering as many bases as possible with a bit of programming, a bit of documentation/explanation, some debugging, etc.
strncpy(argv[0], "NewName", 7);
WTF does 7 come from, the source or the destination?As the comments said, argv[0] does not have to point to writable memory, because argc can be 0. In this case argv[0] is supposed to be NULL, which would segfault the program.
If you had to solve this question (it would be better not to ask it, because you don't learn much), I think the solution:
argv[0] = "NewName";
would be better. It's at least shorter. int main()
{
char *args[] = { 0 };
execve("./zero", args, 0L);
}
zero will have argc == 0.Certainly on all real-world platforms with a conforming main() implementation (i.e. there are some embedded systems which have stubbed mains, or just use something like _start directly) argv is passed on the stack and is writable.
Also, while argv itself may be passed on the stack, the memory each entry of argv points to is not.
But once again, we're arguing esoteric edge cases that have no place in an interview, let alone in professional code.
And the bit about argv not being passed on the stack is simply wrong on all real platforms. The argv[] array of pointers and the memory they point to is absolutely on the stack at process start.
5.1.2.2.1 Program Startup: "The parameters argc and argv and the strings pointed to by the argv array shall be modifiable by the program, and retain their last-stored values between program startup and program termination."
However, nothing says they must be on the stack. I ran the following program to test this:
int main(int argc, const char * argv[])
{
char buff1[0x1000];
char buff2[0x1000];
printf("buff1 = %p\n", buff1);
printf("buff2 = %p\n", buff2);
printf("argv = %p\n", argv);
for(int i = 0; i < argc; i++)
{
printf("arg %d = %p\n", i, argv[i]);
}
return 0;
}
I passed it the params "1 2 3" and got the following: buff1 = 0x7fff5fbfe7b0
buff2 = 0x7fff5fbfd7b0
argv = 0x7fff5fbff7f8
arg 0 = 0x7fff5fbff970
arg 1 = 0x7fff5fbff9e9
arg 2 = 0x7fff5fbff9eb
arg 3 = 0x7fff5fbff9ed
It seems odd that there's a 376 byte gap between what's clearly the stack and what addresses the arguments reside at. They also appear in ascending order despite the fact that the stack is descending (a required convention, maybe?). It's still pretty damn close to the stack so it might very well be the stack with a bunch of process-specific stuff in it, or it could just be that the OS put the start of the stack close to the startup parameters.Either way, this is very esoteric stuff that has no place in an interview. I've read through the complete spec a number of times and I STILL get stuff wrong!
Question 12 is even worse, as the processing order is implementation defined. On my compiler, it prints out 60..40..60.
C questions should be designed to show whether or not the candidate can write robust, professional quality code, not to test esoteric knowledge that even the interviewer can't get right.
I was asked questions like these in an interview once. It was such a massive red flag to me that I went with another company (the final straw was arguing over the size of int, which he insisted was always 32 bits).