我的 strlcpy 版本

Question

gcc 4.4.4 c89

我的程序做了很多字符串处理。我不想使用 strncpy 因为它不会终止。而且我不能使用 strlcpy 因为它不可移植。

只是几个问题。我怎样才能让我的功能通过它的步伐，以确保它是完全安全和稳定的。单元测试？

这足以用于生产吗？

size_t s_strlcpy(char *dest, const char *src, const size_t len)
{
    size_t i = 0;

    /* Always copy 1 less then the destination to make room for the nul */
    for(i = 0; i < len - 1; i++)
    {
        /* only copy up to the first nul is reached */
        if(*src != '\0') {
            *dest++ = *src++;
        }
        else {
            break;
        }
    }

    /* nul terminate the string */
    *dest = '\0';

    /* Return the number of bytes copied */
    return i;
}

非常感谢您的任何建议，

Answer 1

虽然您可以按照另一篇文章的建议简单地使用另一个 strlcpy 函数，或者使用 snprintf(dest, len, "%s", src)（它总是终止缓冲区），但我在查看您的代码时注意到以下几点：

size_t s_strlcpy(char *dest, const char *src, const size_t len)
{
    size_t i = 0;

无需在此处设置len const，但它会很有帮助，因为它会检查以确保您没有修改它。

    /* Always copy 1 less then the destination to make room for the nul */
    for(i = 0; i < len - 1; i++)
    {

哎呀。如果 len 为 0 怎么办？ size_t 通常是无符号的，所以 (size_t)0 - 1 最终会变成类似于 4294967295 的东西，导致您的例程在程序内存中翻滚并崩溃到一个未映射的页面。

        /* only copy up to the first nul is reached */
        if(*src != '\0') {
            *dest++ = *src++;
        }
        else {
            break;
        }
    }

    /* nul terminate the string */
    *dest = '\0';

上面的代码对我来说很好。

    /* Return the number of bytes copied */
    return i;
}

根据Wikipedia，strlcpy返回strlen(src)（字符串的实际长度），而不是复制的字节数。因此，您需要继续计数src 中的字符，直到您点击'\0'，即使它超过了len。

此外，如果您的 for 循环在 len - 1 条件下终止，您的函数将返回 len-1，而不是像您期望的那样返回 len。

---

当我编写这样的函数时，我通常更喜欢使用开始指针（称为 S）和结束指针（称为 E）。 S 指向第一个字符，而 E 指向一个字符在最后一个字符之后（这使得 E - S 是字符串的长度）。尽管这种技术可能看起来丑陋且晦涩难懂，但我发现它相当强大。

这是我如何编写 strlcpy 的一个过度注释的版本：

size_t s_strlcpy(char *dest, const char *src, size_t len)
{
    char *d = dest;
    char *e = dest + len; /* end of destination buffer */
    const char *s = src;

    /* Insert characters into the destination buffer
       until we reach the end of the source string
       or the end of the destination buffer, whichever
       comes first. */
    while (*s != '\0' && d < e)
        *d++ = *s++;

    /* Terminate the destination buffer, being wary of the fact
       that len might be zero. */
    if (d < e)        // If the destination buffer still has room.
        *d = 0;
    else if (len > 0) // We ran out of room, so zero out the last char
                      // (if the destination buffer has any items at all).
        d[-1] = 0;

    /* Advance to the end of the source string. */
    while (*s != '\0')
        s++;

    /* Return the number of characters
       between *src and *s,
       including *src but not including *s . 
       This is the length of the source string. */
    return s - src;
}

Answer 2

恕我直言，只需使用 original strlcpy，Ignacio Vazquez-Abram 简洁地说。 OpenBSDs 代码经过了实战测试，许可条款很重要；）。

至于您的代码，我会在其他人已经说过的内容中添加一些内容，这只是个人喜好问题：

/* only copy up to the first nul is reached */
if(*src != '\0') {
    *dest++ = *src++;
}
else {
    break;
}

我会这样写：

if(*src == '\0') {
    break;
}
*dest++ = *src++;

既是因为它减少了人们需要阅读的不必要代码的数量，又因为我的“风格”是始终如一地这样写，而不是if (ok) { do } else { handle error }。 if 上面的注释也是多余的（参见 for 循环上面的注释）。

Answer 3

为什么不使用 memccpy() 之类的东西而不是自己滚动？你只需要以一个空字节结束，但是增加一个标准函数比从头开始更容易而且通常更快。

一些架构会大量优化甚至使用汇编字符串函数来发挥它们的良好性能。

无需构建或调试：

str = memccpy (dest, src, '\0', len);
if(str)
    *str = '\0';

Answer 4

是的，单元测试。检查大量随机生成的字符串。

不过在我看来还不错。

Answer 5

我建议White-box testing 对于这样的功能（一种单元测试形式）很有用。

Answer 6

DRY 原则是“不要重复自己”。换句话说，不要创建新的代码来做已经完成的事情——检查标准 C 库，如上面的示例 (WilrWind) 所示。

一个原因是提到的测试。标准 C 库已经过多年测试，因此可以肯定它可以像宣传的那样工作。

通过玩代码来学习是个好主意，请继续尝试。

Answer 7

单元测试？ 这足以用于生产吗？

对于像这样的“简单”函数可能就足够了，尽管测试函数的唯一真正方法是尝试破坏它。

向它传递 NULL 指针、10k 字符长的字符串、len 的负值、以某种方式损坏的数据等等。一般认为：如果你是一个恶意用户试图破解它，你会怎么做？

查看我的回复here中的链接

Answer 8

我认为如此依赖长度并对其进行算术运算是错误的。

size_t 类型是无符号的。考虑一下如果使用 0 大小的目标调用您的函数将如何表现。

Answer 9

总是有static code analysis。 编辑：List of tools for static code analysis

Answer 10

嗯，没想到这是一篇旧帖。

这足以用于生产吗？
完全安全稳定（？）

缺点：
无法正确处理 len == 0 - 易于修复。
当源很长时返回值有问题 - 易于修复。
（尚未讨论）不考虑重叠dest, src。

if(*src != '\0') { *dest++ = *src++; } 在读取之前覆盖 null 字符 很容易导致意外结果，因此迭代冒险超出了原始 '\0'。

// pathological example                 
char buf[16] = "abc";
const char *src = buf;       // "abc"
const char *dest = buf + 2;  // "c"
size_t dest_sz = sizeof buf - 2;
s_strlcpy(dest, src, dest_sz);
puts(dest); // "ababababababa", usual expectation "abc"

两个解决方案：

restrict
从 C99 开始，C 具有restrict，这向编译器表明它可以假设通过src 读取和通过dest 写入的数据不会重叠。这允许编译器使用某些优化，否则它不能使用。 restrict 还通知用户不应提供重叠缓冲区。

• 代码仍然会像上面那样失败，但那是调用者违反合同，而不是s_strlcpy()。

注意：const size_t len 中的 const 是函数声明中的干扰项。使用size_t size 也比使用size_t len 更清晰。

size_t s_strlcpy(char * restrict dest, const char * restrict src, size_t size);

这种restrict 用法类似于标准库strcpy() 等。

char *strcpy(char * restrict s1, const char * restrict s2);

处理重叠
另一种是让s_strlcpy() 容忍重叠内存，如下所示。这几乎意味着代码需要使用memmove()。

size_t s_strlcpy(char *dest, const char *src, const size_t dest_size) {
  size_t src_len = strlen(src);
  if (src_len < dest_size) {
    memmove(dest, src, src_len + 1);  // handles overlap without UB
  } else if (dest_size > 0) {
    // Not enough room
    memmove(dest, src, dest_size - 1);  // handles overlap without UB
    dest[dest_size - 1] = '\0';
  }
  return src_len;  // I do not think OP's return value is correct. S/B src length.
}

希望我正确编码了strlcpy() 的所有功能。边缘情况需要时间来解决。