is it a good strlcat() implementation?

Question

I'd like to know if i respect strlcat(3) behiour with my implementation, cause i'm not really sure to understand strlcat particular behaviour

int my_strlcat(char *dest, char *src, int size)
{
  int i;
  int src_len;
  int dest_len;

  i = 0;
  dest_len = strlen(dest);
  src_len = strlen(src);
  if (size <= 0)
   return dest_len;
  while (dest_len < size)
  {
    dest[dest_len] = src[i];
    dest_len++;
    i++;
  }
  dest[dest_len] = '\0';
  return (strlen(dest));
}

Answer 1

while (dest_len < size)
  {
    dest[dest_len] = src[i];
    dest_len++;
    i++;
  }
dest[dest_len] = '\0';

At the end of the loop dest_len will be equal to size, and the dest[des_len] will write beyond the allowed offset.

UPDATE: this will probably work

size_t my_strlcat(char *dest, char *src, size_t size)
{
size_t src_len, dest_len;

  dest_len = strlen(dest);
  src_len = strlen(src);

  if (dest_len+src_len>= size) return dest_len+src_len;

  memcpy(dest+dest_len, src, src_len+1);

  return dest_len+src_len;
}

Answer 2

• src_len is not used..
• the strlen in the return statement is not needed.. you know the length from dest_len.

IMHO very weird implementation :)

Answer 3

There are a few things wrong if this is meant to be a implementation of the standard strlcat():

• The function definition should be of the form: size_t my_strlcat(char *dst, const char *src, size_t size);
• You are always overflowing the destination buffer by one when you NUL terminate.
• You are overflowing the source buffer reads depending on the input. For example, consider if dest_len=1, src_len=2 and size=1000.
• While not wrong it is better to try to minimize the use of strlen() unless needed. You probably only need one strlen(dest).

See here for an example implementation of strlcat().

Answer 4

You're basically right I think. Checking the man page for strlcpy() shows one discrepancy I can see - the null termination of the destination only happens if there's room in dest after the copying. Although that seems kind of dangerous to me, it depends how well you want to replicate the semantics. Your current implementation always null-terminates, which is nice and safe but might end up diverging from the stock implementation in that edge case.

For performance, you should check size <= 0 before you strlen() both of the strings, as in that case you only need to call strlen(dest). That might seem minor, but strlen runs in O(N) time so you don't want to be calling it if you don't have to. So basically just move the check on size to before the call to strlen(src).