第二次调用函数时出现分段错误？

Question

编辑（解决方案）

我遵循了使用 -fsanitize=address & valgrind 进行调试的建议。我只使用了 -fsanitize（我以前从未听说过）并发现了问题所在，在另一个函数中有一个对析构函数的遗留调用，并且该对象被销毁了两次。记忆在此时完全危及。

非常感谢您的帮助和其他建议。

我正在用 C++ 编写代码以使用套接字与 CouchDB 通信（CouchDB 是 Apache 的一个数据库，具有 HTTP API）。我创建了一个完整的 class 来处理它，它基本上是一个连接和关闭的套接字客户端。

我的一个功能是发送一个 HTTP 请求，然后读取响应并使用它，它在第一次调用时工作正常，但当我第二次调用时失败。

但它在失败的地方不一致，有时是其中一个字符串函数中的 SEGFAULT，其他时候是 return 中的 SIGABORT。我用 ->

标记了崩溃的行

最糟糕的是它只在运行 "second" 次时失败，实际上是第 10 次。说明：当 class 被实例化时，一个套接字被创建， sendRequest 被调用 8 次（所有工作，总是），我关闭套接字。然后我有另一个 class 控制套接字服务器，它接收命令并创建一个执行命令的远程用户对象，然后远程用户命令调用 CouchDB class 来操作数据库。第一次请求命令有效，但第二次失败并导致程序崩溃。

额外信息：在 short int httpcode 行中，gdb 跟踪显示 substr 发生崩溃，SIGABORT 崩溃跟踪显示 free().

出现问题

我已经调试了很多次，对在何处以及如何实例化字符串和缓冲区进行了一些更改，但我迷路了。任何人都知道为什么它可以多次正常工作但在随后的调用中崩溃？

CouchDB::response CouchDB::sendRequest(std::string req_method, std::string req_doc, std::string msg)
{
    std::string responseBody;
    char buffer[1024];
    // zero message buffer
    memset(buffer, 0, sizeof(buffer));

    std::ostringstream smsg;
    smsg << req_method << " /" << req_doc << " HTTP/1.1\r\n"
         << "Host: " << user_agent << "\r\n"
         << "Accept: application/json\r\n"
         << "Content-Length: " << msg.size() << "\r\n"
         << (msg.size() > 0 ? "Content-Type: application/json\r\n" : "")
         << "\r\n"
         << msg;

    /*std::cout << "========== Request ==========\n"
              << smsg.str() << std::endl;*/

    if (sendData((void*)smsg.str().c_str(), smsg.str().size())) {
        perror("@CouchDB::sendRequest, Error writing to socket");
        std::cerr << "@CouchDB::sendRequest, Make sure CouchDB is running in " << user_agent << std::endl;
        return {-1, "ERROR"};
    }

    // response
    int len = recv(socketfd, buffer, sizeof(buffer), 0);

    if (len < 0) {
        perror("@CouchDB::sendRequest, Error reading socket");
        return {-1, "ERROR"};
    }
    else if (len == 0) {
        std::cerr << "@CouchDB::sendRequest, Connection closed by server\n";
        return {-1, "ERROR"};
    }

    responseBody.assign(buffer);
    // HTTP code is the second thing after the protocol name and version
->  short int httpcode = std::stoi(responseBody.substr(responseBody.find(" ") + 1));

    bool chunked = responseBody.find("Transfer-Encoding: chunked") != std::string::npos;
    /*std::cout << "========= Response =========\n"
              << responseBody << std::endl;*/
    // body starts after two CRLF
    responseBody = responseBody.substr(responseBody.find("\r\n\r\n") + 4);

    // chunked means that the response comes in multiple packets
    // we must keep reading the socket until the server tells us it's over, or an error happen
    if (chunked) {
        std::string chunkBody;
        unsigned long size = 1;

        while (size > 0) {
            while (responseBody.length() > 0) {
                // chunked requests start with the size of the chunk in HEX
                size = std::stoi(responseBody, 0, 16);
                // the chunk is on the next line
                size_t chunkStart = responseBody.find("\r\n") + 2;
                chunkBody += responseBody.substr(chunkStart, size);
                // next chunk might be in this same request, if so, there must have something after the next CRLF
                responseBody = responseBody.substr(chunkStart + size + 2);
            }

            if (size > 0) {
                len = recv(socketfd, buffer, sizeof(buffer), 0);

                if (len < 0) {
                    perror("@CouchDB::sendRequest:chunked, Error reading socket");
                    return {-1, "ERROR"};
                }
                else if (len == 0) {
                    std::cerr << "@CouchDB::sendRequest:chunked, Connection closed by server\n";
                    return {-1, "ERROR"};
                }

                responseBody.assign(buffer);
            }
        }
        // move created body from chunks to responseBody
->      responseBody = chunkBody;
    }
    return {httpcode, responseBody};
}

调用上面的函数有时会SIGABORT

bool CouchDB::find(Database::db db_type, std::string keyValue, std::string &value)
{
    if (!createSocket()) {
        return false;
    }
    std::ostringstream doc;
    std::ostringstream json;
    doc << db_name << db_names[db_type] << "/_find";
    json << "{\"selector\":{" << keyValue << "},\"limit\":1,\"use_index\":\"index\"}";
->  CouchDB::response status = sendRequest("POST", doc.str(), json.str());
    close(socketfd);

    if (status.httpcode == 200) {
        value = status.body;
        return true;
    }
    return false;
}

您可能有疑问的一些位：

CouchDB::response 是一个 struct {httpcode: int, body: std::string}
CouchDB::db是一个enum选择不同的数据库
sendData 只发送任何字节，直到发送完所有字节

Answer 1

使其 int len = recv(socketfd, buffer, sizeof(buffer), 0); 可能会覆盖缓冲区中的最后一个 '[=11=]'。人们可能会想使用 sizeof(buffer) - 1 但这是错误的，因为您可能会在流中获得空字节。所以，改为这样做：responseBody.assign(buffer, len);。当然，只有在您确定 len >= 0 之后才这样做，您在错误检查中会这样做。

你必须在你打电话的每个地方都这样做 recv。但是，为什么您使用 recv 而不是 read 超出了我的范围，因为您没有使用任何标志。

此外，如果按照我的方式进行操作，您的缓冲区 memset 将毫无意义。您还应该在使用之前声明您的缓冲区。我必须通读你一半的功能才能弄清楚你是否对它做了任何事情。虽然，当然，你最终会第二次使用它。

哎呀，因为你的错误处理在这两种情况下基本上是相同的，我会做一个函数来完成它。不要重复自己。

最后，find 的结果是你玩得不亦乐乎。您实际上可能找不到您要找的东西，可能会 string::npos 返回，这也会给您带来有趣的问题。

另一件事，如果您使用的是 gcc 或 clang，请尝试 -fsanitize=address（或此处记录的其他一些清理选项）。 And/or 运行它在 valgrind 下。您的内存错误可能与崩溃的代码相去甚远。这些可能会帮助您接近它。

最后一点。你的逻辑完全乱了。您必须将阅读数据和解析分开，并为每个数据保留不同的状态机。无法保证您的第一次读取获得整个 HTTP header，无论该读取有多大。而且也不能保证您的 header 小于某个尺寸。

您必须继续阅读，直到您为 header 阅读的内容超过了您愿意阅读的内容并认为这是一个错误，或者直到您在结尾处获得 CR LN CR LN header.

最后几位不会导致您的代码崩溃，但会导致您出现虚假错误，尤其是在某些流量情况下，这意味着它们可能不会出现在测试中。

第二次调用函数时出现分段错误？

Segmentation fault on the second call of the function?

c++

string

stdstring

segmentation-fault

c++11