3

Cppcheck 1.67在我的源代码中在这一行提出了可移植性问题：

sscanf(s, "%d%*[,;.]%d", &f, &a);

这是我从中得到的信息：

在某些版本的 libc 上，没有字段宽度限制的 scanf 可能会因大量输入数据而崩溃。

格式字符串的初衷是接受两个整数之间的三个可能的限制字符之一，而今天 - 感谢 Cppcheck [1] - 我看到它%*[,;.]甚至接受限制字符的字符串。但是我怀疑我的格式字符串可能会导致崩溃，因为无限制的部分被忽略了。

缓冲区溢出是否可能存在问题？ ...也许在幕后？

[1] 如何在远视和失明之间迷路：

我试图通过%1*[,;.]（在一些 API doc之后）修复它，但 Cppcheck 坚持这个问题，所以我也尝试%*1[,;.]了同样的“成功”。看来我必须暂时压制它了……

4

2 回答 2

2

恭喜您在 Cppcheck 1.67（当前版本）中发现了一个错误。

您基本上有三种解决方法：

  1. 只需忽略误报。

  2. 修改您的格式（分配该字段，因为您只想匹配一个字符）。

    char tmp;
if(3 != sscanf(s, "%d %c%d", &f, &tmp, &a) || tmp!=',' && tmp!=';' && tmp!= '.')
    goto error;

  3. 直接抑制警告（最好是内联抑制）：

    //cppcheck-suppress invalidscanf_libc
if(2 != sscanf(s, "%d%1*[,;.]%d", &f, &a))
    goto error;

不要忘记将错误报告为“缺陷/误报”，这样您就可以尽快退休并忘记该解决方法。

于 2014-10-27T13:11:31.187 回答
1

何时量化 C sscanf 函数中忽略的模式匹配？

总是量化可能是个好主意（见下文），但过度量化也可能会分散您的意图。在上述情况下，必须跳过单个分隔符字符，量化肯定是有用的。

缓冲区溢出是否可能存在问题？...也许在幕后？

您的代码不会导致崩溃。至于处理“幕后”问题，我尝试了大输入字符串。在我测试的 C 库中，没有内部缓冲区溢出。我尝试了 Borland C++ 5.6.4 附带的 C lib，发现我无法触发大输入（超过 4 亿个字符）的缓冲区溢出。

令人惊讶的是，Cppcheck 并没有完全错误——存在可移植性问题，但有一个不同的问题：

#include <stdio.h>
#include <assert.h>
#include <sstream>

int traced_sscanf_set(const int count, const bool limited)
{
    const char sep = '.';
    printf("\n");
    std::stringstream ss;
    ss << "123" << std::string(count, sep) << "456";
    std::string s = ss.str();
    printf("string of size %d with %d '%c's in it\n", s.size(), count, sep);
    std::stringstream fs;
    fs << "%d%";
    if (limited) {
        fs << count;
    }
    fs << "*["<< sep << "]%d";
    std::string fmt = fs.str();
    printf("fmt: \"%s\"\n", fmt.c_str());
    int a = 0;
    int b = 0;
    const sscanfResult = sscanf(s.c_str(), fmt.c_str(), &a, &b);
    printf("sscanfResult=%d, a=%d, b=%d\n", sscanfResult, a, b);
    return sscanfResult;
}

void test_sscanf()
{
    assert(traced_sscanf_set(0x7fff, true)==2);
    assert(traced_sscanf_set(0x7fff, false)==2);
    assert(traced_sscanf_set(0x8000, true)==2);
    assert(traced_sscanf_set(0x8000, false)==1);
}

如果格式参数中没有明确指定的限制，我检查的库在内部将消耗（和跳过）的输入限制为 32767 (2 15 -1) 个字符。

对于那些感兴趣的人，这里是跟踪输出：

string of size 32773 with 32767 '.'s in it
fmt: "%d%32767*[.]%d"
sscanfResult=2, a=123, b=456

string of size 32773 with 32767 '.'s in it
fmt: "%d%*[.]%d"
sscanfResult=2, a=123, b=456

string of size 32774 with 32768 '.'s in it
fmt: "%d%32768*[.]%d"
sscanfResult=2, a=123, b=456

string of size 32774 with 32768 '.'s in it
fmt: "%d%*[.]%d"
sscanfResult=1, a=123, b=0
于 2014-10-28T12:17:24.110 回答