fanyi/handle.cpp

#include "handle.h"
#include <iomanip>
#include <iostream>
#include <random>
#include <sstream>
#include <SimpleIni.h>
#include <cctype>

CHttpsHandle::CHttpsHandle()
{
    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();
}

CHttpsHandle::~CHttpsHandle()
{
    if (curl) {
        curl_easy_cleanup(curl);
    }
    curl_global_cleanup();
}

std::string CHttpsHandle::sendGetRequest(const std::string& url)
{
    // 用于保存响应数据
    std::string response_data;
    if (curl) {
        // 设置请求 URL
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl, CURLOPT_POST, 0L);
        // 设置回调函数，用于获取响应数据
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_data);

        // 设置不验证 SSL 证书（如果使用自签名证书或测试环境时可以忽略）
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);   // 忽略 SSL 证书验证
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);   // 忽略主机名验证

        // 执行请求
        CURLcode res = curl_easy_perform(curl);

        // 检查请求是否成功
        if (res != CURLE_OK) {
            std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
            return "";
        }
    }
    return response_data;
}

size_t CHttpsHandle::WriteCallback(void* contents, size_t size, size_t nmemb, void* userp)
{
    size_t total_size = size * nmemb;
    std::string* response_data = (std::string*)userp;
    response_data->append((char*)contents, total_size);
    return total_size;
}

std::string CUtil::generateMD5(const std::string& input)
{
    EVP_MD_CTX* mdctx = EVP_MD_CTX_new();
    if (mdctx == nullptr) {
        std::cerr << "Error creating MD5 context!" << std::endl;
        return "";
    }
    if (EVP_DigestInit_ex(mdctx, EVP_md5(), nullptr) != 1) {
        std::cerr << "Error initializing MD5!" << std::endl;
        EVP_MD_CTX_free(mdctx);
        return "";
    }
    if (EVP_DigestUpdate(mdctx, input.c_str(), input.length()) != 1) {
        std::cerr << "Error updating MD5!" << std::endl;
        EVP_MD_CTX_free(mdctx);
        return "";
    }

    unsigned char md_value[EVP_MAX_MD_SIZE];
    unsigned int md_len = 0;

    if (EVP_DigestFinal_ex(mdctx, md_value, &md_len) != 1) {
        std::cerr << "Error finalizing MD5!" << std::endl;
        EVP_MD_CTX_free(mdctx);
        return "";
    }
    EVP_MD_CTX_free(mdctx);
    std::ostringstream md5String;
    for (unsigned int i = 0; i < md_len; ++i) {
        md5String << std::setw(2) << std::setfill('0') << std::hex << (int)md_value[i];
    }

    return md5String.str();
}

std::string CUtil::generateRandomNumStr()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(100000000, 999999999);
    long long random_number = dis(gen);
    return std::to_string(random_number);
}

void CTransTool::set_id(const str_t& id, const str_t& secret_key)
{
    appid_ = id;
    secret_key_ = secret_key;
}

std::string CTransTool::combine(const str_t& words, const str_t& from, const str_t& to)
{
    char* buffer = new char[2048];
    std::string radom_str = CUtil::generateRandomNumStr();
    std::string str1 = appid_ + words + radom_str + secret_key_;
    std::string md5 = CUtil::generateMD5(str1);
    std::string req_word = CUtil::urlEncode(words);
    std::snprintf(buffer, 2048, "q=%s&from=%s&to=%s&appid=%s&salt=%s&sign=%s", req_word.c_str(), from.c_str(),
                  to.c_str(), appid_.c_str(), radom_str.c_str(), md5.c_str());
    std::string source_pre(buffer);
    delete[] buffer;
    return source_pre;
}

std::string CUtil::urlEncode(const std::string& str)
{
    std::ostringstream encoded;
    for (unsigned char c : str) {
        if (std::isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
            encoded << c;
        } else {
            encoded << '%' << std::uppercase << std::setw(2) << std::setfill('0') << std::hex << (int)c;
        }
    }
    return encoded.str();
}

bool CConfig::parse_config(ConfigInfo& config, const std::string& config_path)
{
    CSimpleIniA ini_handle{};
    SI_Error ret = ini_handle.LoadFile(config_path.c_str());
    if (ret != SI_OK) {
        return false;
    }
    if (!ini_handle.KeyExists("Config", "BaseURL")) {
        std::cerr << "Not Key Found Config/BaseURL in fanyi.ini" << std::endl;
        return false;
    }
    config.baseUrl = ini_handle.GetValue("Config", "BaseURL");

    if (!ini_handle.KeyExists("Config", "AppID")) {
        std::cerr << "Not Key Found Config/AppID in fanyi.ini" << std::endl;
        return false;
    }
    config.appID = ini_handle.GetValue("Config", "AppID");

    if (!ini_handle.KeyExists("Config", "SecretID")) {
        std::cerr << "Not Key Found Config/SecretID in fanyi.ini" << std::endl;
        return false;
    }
    config.secretID = ini_handle.GetValue("Config", "SecretID");

    if (!ini_handle.KeyExists("Config", "Interval")) {
        std::cerr << "Not Key Found Config/Interval in fanyi.ini" << std::endl;
        return false;
    }
    config.interval = ini_handle.GetValue("Config", "Interval");
    return true;
}