Ошибка сегмента с многопоточным запросом curl

ProgramBox

Ошибка сегмента с многопоточным запросом curl

Post author:admin
Запись опубликована:12 мая, 2023
Post category:Вопросы по программированию

#c #linux #multithreading #curl #libcrypto

#c #linux #многопоточность #curl #libcrypto

Вопрос:

У меня возникли некоторые проблемы с программой на C . По сути, я написал простую оболочку для http-запросов с возможностью выполнять несколько запросов одновременно. Работает абсолютно нормально, но когда я выполняю httpS-запросы, он случайным образом вылетает в многопоточном режиме. Я использую потоки curl и posix. Обратная трассировка выглядит следующим образом:

 ======= Backtrace: =========
/lib/x86_64-linux-gnu/libc.so.6( 0x80996)[0x7fea9046d996]
/lib/x86_64-linux-gnu/libc.so.6( 0x82b80)[0x7fea9046fb80]
/lib/x86_64-linux-gnu/libc.so.6(realloc 0xf2)[0x7fea90470ae2]
/lib/x86_64-linux-gnu/libcrypto.so.1.0.0(CRYPTO_realloc 0x49)[0x7fea8f9c6169]
/lib/x86_64-linux-gnu/libcrypto.so.1.0.0(lh_insert 0x101)[0x7fea8fa4bfb1]
/lib/x86_64-linux-gnu/libcrypto.so.1.0.0( 0xe844e)[0x7fea8fa4e44e]
/lib/x86_64-linux-gnu/libcrypto.so.1.0.0(ERR_get_state 0xde)[0x7fea8fa4eeee]
/lib/x86_64-linux-gnu/libcrypto.so.1.0.0(ERR_clear_error 0x15)[0x7fea8fa4f065]
/usr/lib/x86_64-linux-gnu/libcurl.so.4( 0x24e79)[0x7fea90f10e79]
/usr/lib/x86_64-linux-gnu/libcurl.so.4( 0x39ea0)[0x7fea90f25ea0]
/usr/lib/x86_64-linux-gnu/libcurl.so.4( 0xf8fd)[0x7fea90efb8fd]
/usr/lib/x86_64-linux-gnu/libcurl.so.4( 0x219f5)[0x7fea90f0d9f5]
/usr/lib/x86_64-linux-gnu/libcurl.so.4( 0x35538)[0x7fea90f21538]
/usr/lib/x86_64-linux-gnu/libcurl.so.4(curl_multi_perform 0x91)[0x7fea90f21d31]
/usr/lib/x86_64-linux-gnu/libcurl.so.4(curl_easy_perform 0x107)[0x7fea90f19457]
./exbot[0x40273a]
/lib/x86_64-linux-gnu/libpthread.so.0( 0x7f6e)[0x7fea90cd6f6e]
/lib/x86_64-linux-gnu/libc.so.6(clone 0x6d)[0x7fea904e79cd]

Может ли это быть ошибкой в libcrypto?
Могу ли я как-то сказать curl, чтобы он не использовал libcrypto? Есть альтернативы?
Это упрощает wenn только с использованием запросов httpS и отлично работает даже с 10000 одновременными http-запросами.

Приветствую, Томас

Просто для полноты моего кода:

 // simple wrapper for http requests

#ifndef _REQUEST_H_
#define _REQUEST_H_


#include <curl/curl.h>
#include <pthread.h>
#include <string>
#include <iostream>


//////////////////////////////////
// MACROS
//////////////////////////////////
#define ERR(_msg) std::cerr << __FUNCTION__ << ": " << _msg << std::endl


//////////////////////////////////
// REQUEST WRAPPER
//////////////////////////////////
typedef unsigned int uint;
class RequestWrapper
{
private: // non copyable
    RequestWrapper();
    RequestWrapper(const RequestWrapper amp;that);
    RequestWrapper amp;operator=(const RequestWrapper amp;that);

public:
    struct Response
    {
        Response() : msg(""), success(false) {}
        std::string msg;
        bool success;
    };

    static Response simpleGET(std::string url, uint timeout);
    static size_t write(char *content, size_t size, size_t nmemb, void *userp);
};


//////////////////////////////////
// GET
//////////////////////////////////
inline size_t RequestWrapper::write(char *content, size_t size, size_t nmemb, void *userp)
{
    std::string *buf = static_cast<std::string *>(userp);
    size_t realsize = size * nmemb;
    for (uint i = 0; i < realsize;   i)
    {
        buf->push_back(content[i]);
    }
    return realsize;
}
inline RequestWrapper::Response RequestWrapper::simpleGET(std::string url, uint timeout)
{
    Response resp;
    CURL *curl;
    CURLcode res;
    std::string buf;

    // send request
    buf.clear();
    curl = curl_easy_init();
    if (!curl)
    {
        //ERR("libcurl init failed");
        return resp;
    }
    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, static_cast<void *>(amp;buf));
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);
    res = curl_easy_perform(curl);
    if(res != CURLE_OK)
    {
        //ERR("libcurl request failed, CODE: " << res);
        return resp;
    }
    curl_easy_cleanup(curl);

    // done
    resp.msg = buf;
    resp.success = true;
    return resp;
}


//////////////////////////////////
// MULTITHREADED REQUEST
//////////////////////////////////
class RequestList
{
private:
    std::vector<std::string> _reqs;
    static void *sender(void *payload);
    static pthread_mutex_t _mutex;

public:
    inline void add(std::string request)
    {
        _reqs.push_back(request);
    }

    inline void clear()
    {
        _reqs.clear();
    }

    std::vector<std::string> send(uint timeout) const;

    struct Payload
    {
        std::string url;
        std::vector<std::string> *out;
        uint tout, index;
        Payload(std::string url,
                std::vector<std::string> *out,
                uint tout, uint index) : url(url), out(out), tout(tout), index(index) { }
        Payload() : url(""), out(NULL), tout(0), index(0) { }
    };
};


//////////////////////////////////
// SEND MT REQUEST
//////////////////////////////////
pthread_mutex_t RequestList::_mutex;
void *RequestList::sender(void *payload)
{
    Payload *pl = static_cast<Payload *>(payload);
    RequestWrapper::Response resp = RequestWrapper::simpleGET(pl->url, pl->tout);
    pthread_mutex_lock(amp;_mutex);
    if (resp.success)
    {
        pl->out->at(pl->index) = resp.msg;
        std::cerr << ".";
    }
    else
    {
        std::cerr << "x";
    }
    pthread_mutex_unlock(amp;_mutex);
    return NULL;
}
inline std::vector<std::string> RequestList::send(uint timeout) const
{
    std::vector<std::string> resp;
    resp.resize(_reqs.size());
    Payload *payloads = new Payload[_reqs.size()];
    pthread_t *tids = new pthread_t[_reqs.size()];

    // create mutex
    pthread_mutex_init(amp;_mutex, NULL);

    // prepare payload and create thread
    for (uint i = 0; i < _reqs.size();   i)
    {
        payloads[i] = Payload(_reqs[i], amp;resp, timeout, i);
        pthread_create(amp;tids[i], NULL, RequestList::sender, static_cast<void *>(amp;payloads[i]));
    }

    // wait for threads to finish
    for (uint i = 0; i < _reqs.size();   i)
    {
        pthread_join(tids[i], NULL);
    }
    std::cerr << std::endl;

    //destroy mutex
    pthread_mutex_destroy(amp;_mutex);

    delete[] payloads;
    delete[] tids;
    return resp;
}


#endif

1. Ваш сбой где-то внутри realloc в libc. Для меня это наводит на мысль о повреждении кучи. Если это так, ошибка может быть где угодно.

2. Согласно этому , OpenSSL, включая libcrypto , по умолчанию не является потокобезопасным. Вы можете предоставить необходимые функции блокировки в OpenSSL или создать libcurl с другой потокобезопасной библиотекой SSL.

Ответ №1:

Libcrypto является частью OpenSSL, которая не является потокобезопасной, если вы не предоставите необходимые обратные вызовы. Согласно документации, в системе, совместимой с POSIX (которая имеет thread-local errno ), реализация идентификатора потока по умолчанию приемлема, поэтому вам просто нужна функция блокировки:

 void locking_function(int mode, int n, const char *file, int line);

Этой функции потребуется поддерживать набор CRYPTO_num_locks() мьютексов и блокировать или разблокирует n -й мьютекс в зависимости от значения mode . Вы можете ознакомиться с документацией для получения более подробной информации. На веб-сайте libcurl действительно есть некоторый пример кода, показывающий, как это сделать.

В качестве альтернативы вы можете создать libcurl с использованием другой потокобезопасной библиотеки SSL, такой как GnuTLS.