Re: generic strncpy - off-by-one error

Timothy Miller
2003-08-13T18:50:10Z

Erik Andersen wrote:

> char *strncpy(char * s1, const char * s2, size_t n)
> {
> register char *s = s1;
> while (n) {
> if ((*s = *s2) != 0) s2++;
> ++s;
> --n;
> }
> return s1;
> }

Nice!

How about this:

char *strncpy(char * s1, const char * s2, size_t n)
{
register char *s = s1;

while (n && *s2) {
n--;
*s++ = *s2++;
}
while (n--) {
*s++ = 0;
}
return s1;
}

This reminds me a lot of the ORIGINAL, although I didn't pay much
attention to it at the time, so I don't remember. It may be that the
original had "n--" in the while () condition of the first loop, rather
than inside the loop.

I THINK the original complaint was that n would be off by 1 upon exiting
the first loop. The fix is to only decrement n when n is nonzero.

If s2 is short enough, then we'll exit the first loop on the nul byte
and fill in the rest in the second loop. Since n is only decremented
with we actually write to s, we will only ever write n bytes. No
off-by-one.

If s2 is too long, the first loop will exit on n being zero, and since
it doesn't get decremented in that case, it'll be zero upon entering the
second loop, thus bypassing it properly.

Erik's code is actually quite elegant, and its efficiency is probably
essentially the same as my first loop. But my second loop would
probably be faster at doing the zero fill.

Now, consider this for the second loop!

while (n&3) {
*s++ = 0;
n--;
}
l = n>>2;
while (l--) {
*((int *)s)++ = 0;
}
n &= 3;
while (n--) {
*s++ = 0;
}

This is only a win for relatively long nul padding. How often is the
padding long enough?