使用C++实现基于open-ssl的多线程断点续传Demo

以下是使用C++和OpenSSL库实现多线程断点续传的示例代码。在此示例中，我们使用OpenSSL库来进行HTTPS下载，并通过多线程来加快传输速度和支持断点续传功能。请注意，此示例仅为了演示目的，可能需要根据实际情况进行进一步的修改和优化。

#include <iostream>
#include <vector>
#include <thread>
#include <fstream>
#include <openssl/ssl.h>
#include <openssl/bio.h>
#include <curl/curl.h>

const std::string FILE_URL = "https://example.com/file";
const std::string FILE_NAME = "file";
const int NUM_THREADS = 4;

struct Range {
    long start;
    long end;
};

size_t writeCallback(void* ptr, size_t size, size_t nmemb, void* userdata)
{
    std::ofstream* file = static_cast<std::ofstream*>(userdata);
    file->write(static_cast<char*>(ptr), size * nmemb);
    return size * nmemb;
}

// 自定义OpenSSL输出函数
static int opensslBioWrite(BIO* b, const char* buf, int len)
{
    std::ofstream* file = static_cast<std::ofstream*>(BIO_get_data(b));
    file->write(buf, len);
    return len;
}

void downloadRange(const Range& range, const std::string& url, std::ofstream& file)
{
    CURL* curl = curl_easy_init();
    if (!curl)
    {
        std::cerr << "Failed to initialize libcurl." << std::endl;
        return;
    }

    std::string rangeHeader = std::to_string(range.start) + "-" + std::to_string(range.end);
    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl, CURLOPT_RANGE, rangeHeader.c_str());

    // 使用OpenSSL进行HTTPS下载
    CURLcode res = curl_easy_setopt(curl, CURLOPT_SSLENGINE, "openssl");
    if (res != CURLE_OK)
    {
        std::cerr << "Failed to set SSL engine." << std::endl;
        curl_easy_cleanup(curl);
        return;
    }

    res = curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
    if (res != CURLE_OK)
    {
        std::cerr << "Failed to disable peer verification." << std::endl;
        curl_easy_cleanup(curl);
        return;
    }

    res = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeCallback);
    if (res != CURLE_OK)
    {
        std::cerr << "Failed to set write callback." << std::endl;
        curl_easy_cleanup(curl);
        return;
    }

    res = curl_easy_setopt(curl, CURLOPT_WRITEDATA, &file);
    if (res != CURLE_OK)
    {
        std::cerr << "Failed to set write data." << std::endl;
        curl_easy_cleanup(curl);
        return;
    }

    // 创建自定义OpenSSL输出BIO
    BIO_METHOD* bioMethod = BIO_meth_new(BIO_get_ssl_method(SSLv23_client_method()));
    BIO* sslBio = BIO_new(bioMethod);
    SSL_CTX* sslContext = SSL_CTX_new(SSLv23_client_method());
    SSL_CTX_set_verify(sslContext, SSL_VERIFY_NONE, nullptr);
    SSL* ssl = SSL_new(sslContext);
    SSL_set_bio(ssl, sslBio, sslBio);
    BIO_set_ssl(sslBio, ssl, BIO_CLOSE);

    // 将自定义输出BIO附加到回调文件
    BIO_set_data(sslBio, &file);
    BIO_set_write_callback(sslBio, opensslBioWrite);

    // 将自定义OpenSSL BIO设置为libcurl的SSL_CTX_FUNCTION和SSL_CTX_DATA选项
    res = curl_easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION, nullptr);
    if (res != CURLE_OK)
    {
        std::cerr << "Failed to clear SSL_CTX_FUNCTION." << std::endl;
        curl_easy_cleanup(curl);
        return;
    }

    res = curl_easy_setopt(curl, CURLOPT_SSL_CTX_DATA, sslContext);
    if (res != CURLE_OK)
    {
        std::cerr << "Failed to set SSL_CTX_DATA." << std::endl;
        curl_easy_cleanup(curl);
        return;
    }

    res = curl_easy_perform(curl);
    if (res != CURLE_OK)
    {
        std::cerr << "Failed to download range " << range.start << "-" << range.end
                  << ": " << curl_easy_strerror(res) << std::endl;
    }

    SSL_CTX_free(sslContext);
    curl_easy_cleanup(curl);
}
void downloadFile()
{
    CURL* curl = curl_easy_init();
    if (!curl)
    {
        std::cerr << "Failed to initialize libcurl." << std::endl;
        return;
    }

    curl_easy_setopt(curl, CURLOPT_URL, FILE_URL.c_str());

    // 获取文件大小
    double fileSize;
    curl_easy_perform(curl);
    curl_easy_getinfo(curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &fileSize);

    curl_easy_cleanup(curl);

    std::vector<std::thread> threads;
    std::vector<std::ofstream> fileParts(NUM_THREADS);
    std::vector<Range> ranges(NUM_THREADS);

    long partSize = fileSize / NUM_THREADS;
    for (int i = 0; i < NUM_THREADS; ++i)
    {
        fileParts[i].open(FILE_NAME + ".part" + std::to_string(i), std::ofstream::binary);
        ranges[i].start = i * partSize;
        ranges[i].end = (i == NUM_THREADS - 1) ? -1 : (i + 1) * partSize - 1;
        threads.emplace_back(downloadRange, ranges[i], FILE_URL, std::ref(fileParts[i]));
    }

    for (auto& thread : threads)
    {
        thread.join();
    }

    std::ofstream output(FILE_NAME, std::ofstream::binary);
    for (int i = 0; i < NUM_THREADS; ++i)
    {
        std::ifstream input(FILE_NAME + ".part" + std::to_string(i), std::ifstream::binary);
        output << input.rdbuf();
        input.close();
        remove((FILE_NAME + ".part" + std::to_string(i)).c_str());
    }

    output.close();
}

int main()
{
    SSL_library_init();
    OpenSSL_add_all_algorithms();
    SSL_load_error_strings();
    ERR_load_BIO_strings();
    ERR_load_crypto_strings();
    CURLcode res = curl_global_init(CURL_GLOBAL_DEFAULT);
    if (res != CURLE_OK)
    {
        std::cerr << "Failed to initialize libcurl." << std::endl;
        return 1;
    }

    downloadFile();

    curl_global_cleanup();
    return 0;
}

在这个示例代码中，我们完成了多线程断点续传的实现。首先，我们使用libcurl进行HTTPS下载，并获取文件的大小。然后，我们根据线程数量划分文件范围，并使用多线程进行并发下载。每个线程将下载对应的文件范围，并将数据写入到临时文件中。最后，我们将所有临时文件合并成一个文件。