#include "CurlFtp.h"
#include <regex>
#include <iosfwd>
#include <filesystem>
#include <fstream>
// #include "fmtlog.h"
#include "spdlog/spdlog.h"
#ifndef SPDLOG_ACTIVE_LEVEL
#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
#endif
#if defined(_WIN32)
#endif /* _WIN32 */
/* ==================================================================================
* *********************************** 全局变量 *************************************
* ==================================================================================
*/
/* 是否有初始化实例，主要用于静态函数调用curl_global_cleanup()函数前判断，有实例就不调用 */
static bool hasInstace = false;
/* 记录上传或者下载的时间，thread_local是C++11加入的关键字，表示在每个线程中都有自己的lastTime */
static thread_local std::chrono::system_clock::time_point lastTime;
static thread_local uint64_t dCount;
static thread_local uint64_t uCount;
static thread_local uint64_t dSpeed; /* 保存最后的下载速度 */
static thread_local uint64_t uSpeed; /* 保存最后的上传速度 */
/* ==================================================================================
* *********************************** 全局函数 *************************************
* ==================================================================================
*/
/**
* @brief 写入回调函数
*
* @param contents curl的数据缓冲区
* @param size 数据大小，单位是size_t
* @param nmemb size_t的单位字节数
* @param userStr 用户提供的字符串，格式可以是任意的
* @return size_t 总共获取到的数据大小，单位是字节
*/
static size_t writeStringCallback(void *contents, size_t size, size_t nmemb, std::string *userStr)
{
// size_t newLength = size * nmemb;
// size_t oldLength = userStr->size();
// try
// {
// userStr->resize(oldLength + newLength);
// }
// catch(std::bad_alloc &e)
// {
// //handle memory problem
// return 0;
// }
// std::copy_n((char*)contents, newLength, userStr->begin() + oldLength);
userStr->append((char*)contents, size * nmemb);
return size * nmemb;
}
/**
* @brief 写入回调函数，listFiles需要调用
*
* @param buffer curl下载回来的数据
* @param size 数据大小
* @param nmemb 数据单位字节数
* @param userp 用户传进来的容器
* @return int 返回拷贝的字节数
*/
static int writeStringListCallback(void* buffer, size_t size, size_t nmemb, void* userp)
{
std::vector<std::string>* fileList = static_cast<std::vector<std::string>*>(userp);
std::string line(static_cast<char*>(buffer), size * nmemb);
// printf("line = %s\n", line.c_str());
fileList->push_back(line);
return size * nmemb;
}
/**
* @brief 写入文件回调函数
*
* @param contents 读取到的数据内容
* @param size 数据大小
* @param nmemb 数据单位
* @param pFile 文件指针
* @return size_t 实际读取的大小
*/
static size_t writeFileCallBack(void* contents, size_t size, size_t nmemb, std::ostream* pFile)
{
pFile->write(reinterpret_cast<char*>(contents), size * nmemb);
return size * nmemb;
}
/**
* @brief 写入数据到vector中
*
* @param contents
* @param size
* @param nmemb
* @param vecData
* @return size_t
*/
static size_t writeDataCallBack(void* contents, size_t size, size_t nmemb, std::vector<char>* vecData)
{
size_t copySize = size * nmemb;
vecData->insert(vecData->end(), (char*)contents, (char*)contents + copySize);
return copySize;
}
/**
* @brief 读取文件回调函数
*
* @param contents 下载到的数据内容
* @param size 数据大小
* @param nmemb 数据单位
* @param pFile 文件指针
* @return size_t 写入的大小
*/
static size_t readFileCallBack(void* contents, size_t size, size_t nmemb, std::istream* pFile)
{
pFile->read(reinterpret_cast<char*>(contents), size * nmemb);
/* 获取读取到的字节数，可能读取到文件末尾，所以不能直接使用传入的字节数 */
size_t readSize = pFile->gcount();
return readSize;
}
/**
* @brief
*
* @param contents ftp需要的目标内容
* @param size 拷贝的数据大小
* @param nmemb 单个数据的字节数
* @param pData 源指针
* @return size_t 已拷贝的数据大小
*/
static size_t readDataCallBack(void* contents, size_t size, size_t nmemb, CF_ArrayInfo* pData)
{
if(pData == nullptr)
{
return 0;
}
/* 判断是否还够本次拷贝的字节数 */
size_t copySize = size * nmemb;
if(pData->size - pData->pos < copySize)
{
copySize = pData->size - pData->pos;
}
memcpy(contents, pData->data + pData->pos, copySize);
pData->pos += copySize;
return copySize;
}
/**
* @brief 计算速度
*
* @param speed
* @param retSpeed
* @param unit
*/
void computeSpeed(uint64_t speed, double& retSpeed, std::string& unit)
{
double KB = speed / 1024.0;
double MB = KB / 1024.0;
double GB = MB / 1024.0;
if(GB > 1)
{
unit = "GB/S";
retSpeed = GB;
}
else if(MB > 1)
{
unit = "MB/S";
retSpeed = MB;
}
else if(KB > 1)
{
unit = "KB/S";
retSpeed = KB;
}
else {
unit = "B/S";
retSpeed = speed;
}
}
/**
* @brief 打印进度条
*
* @param type 上传还是下载类型
* @param total 总大小，单位字节
* @param now 现在的进度，单位字节
*/
void printProgress(CF_TransType type, curl_off_t total, curl_off_t now)
{
std::string transType;
uint64_t count = 0;
if(type == CF_TransType::DOWNLOAD)
{
transType = "Download";
count = now - dCount;
dCount = now;
}
else if (type == CF_TransType::UPLOAD)
{
transType = "Upload";
count = now - uCount;
uCount = now;
}
/* 计算进度，百分比 */
double percent = (double)now / (double)total * 100;
/* 计算单位 */
double tKB = total / 1024.0;
double tMB = tKB / 1024.0;
double tGB = tMB / 1024.0;
/* 计算速度 */
double speed = 0.0;
std::string unit;
computeSpeed(count, speed, unit);
// if(speed == 0.0)
// {
// if(CF_TransType::DOWNLOAD == type)
// {
// speed = dSpeed;
// }else if (CF_TransType::UPLOAD == type) {
// speed = uSpeed;
// }
// }else {
// if(CF_TransType::DOWNLOAD == type)
// {
// dSpeed = speed;
// }else if (CF_TransType::UPLOAD == type) {
// uSpeed = speed;
// }
// }
if(tGB > 1)
{
double dGB = now / 1024.0 / 1024.0 / 1024.0;
double speed = count / 1024.0 / 1024.0;
printf("%s Total / now : %.2fGB / %.2fGB, %.2f%%, Speed:%.2f %s\r", transType.c_str(), tGB, dGB, percent, speed, unit.c_str());
// printf("Download Total / now : {:.2f}GB / {:.2f}GB, {:.2f}%\r", tGB, dGB, percent);
}
else if(tMB > 1)
{
double dMB = now / 1024.0 / 1024.0;
printf("%s Total / now : %.2fMB / %.2fMB, %.2f%%, Speed:%.2f %s\r", transType.c_str(), tMB, dMB, percent, speed, unit.c_str());
// printf("Download Total / now : {:.2f}MB / {:.2f}MB, {:.2f}%\r", tMB, dMB, percent);
}
else if(tKB > 1)
{
double dKB = now / 1024.0;
printf("%s Total / now : %.2fKB / %.2fKB, %.2f%%, Speed:%.2f %s\r", transType.c_str(), tKB, dKB, percent, speed, unit.c_str());
}
else
{
printf("%s Total / now : %ldB / %ldB, %.2f%%, Speed:%.2f %s\r", transType.c_str(), total, now, percent, speed, unit.c_str());
}
fflush(stdout);
}
/**
* @brief 上传和下载进度回调函数，这个函数kennel会被多次调用，即使是没有在下载的时候，因此需要判断传入的数据是否是0
* 必须将 CURLOPT_NOPROGRESS 设为 0 才能真正调用该函数。
*
* @param clientp 通过CURLOPT_XFERINFODATA 设置的指针，libcurl 不会使用它，只会将其从应用程序传递给回调函数。
* 可以通过这个指针将下载的进度传递给应用程序
* @param dltotal 下载的总字节数，上传的时候这个为0
* @param dlnow 已经下载的总字节数
* @param ultotal 需要上传的总字节数，下载的时候这个为0
* @param ulnow 已经上传的总字节数
* @return int 返回0表示正常，非0表示异常
*/
static int progress_callback(void *clientp,
curl_off_t dltotal,
curl_off_t dlnow,
curl_off_t ultotal,
curl_off_t ulnow)
{
// SPDLOG_DEBUG("dTotal: {}, dNow: {}, uTotal: {}, uNow: {}", dltotal, dlnow, ultotal, ulnow);
if(dltotal == 0 && ultotal == 0)
{
dCount = 0;
uCount = 0;
dSpeed = 0;
uSpeed = 0;
return 0;
}
std::chrono::system_clock::time_point nowTime = std::chrono::system_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(nowTime - lastTime).count();
// SPDLOG_DEBUG("duration:{}", duration);
if((duration < 1000) && ((dltotal != dlnow) || (ultotal != ulnow)))
{
return 0;
}
lastTime = nowTime;
/* 正在下载 */
if(dltotal > 0)
{
printProgress(CF_TransType::DOWNLOAD, dltotal, dlnow);
// printf("Download Total / now : {} / {}, {:.2f}%\r", dltotal, dlnow, downloadPercent);
}
/* 正在上传 */
else if(ultotal > 0)
{
printProgress(CF_TransType::UPLOAD, ultotal, ulnow);
// double uploadPercent = (double)ulnow / (double)ultotal * 100;
// printf("Upload Total / now : {} / {}, {:.2f}%\r", ultotal, ulnow, uploadPercent);
}
return 0;
}
/* 使用Windows API进行编码转换 */
#if defined(_WIN32)
static char* GBToUTF8(const char* gb2312)
{
int len = MultiByteToWideChar(CP_ACP, 0, gb2312, -1, NULL, 0);
wchar_t* wstr = new wchar_t[len+1];
memset(wstr, 0, len+1);
MultiByteToWideChar(CP_ACP, 0, gb2312, -1, wstr, len);
len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
char* str = new char[len+1];
memset(str, 0, len+1);
WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, len, NULL, NULL);
if(wstr) delete[] wstr;
return str;
}
#endif /* _WIN32 */
/* 正则表达式，匹配多个空格 */
const std::regex parseRegSpace(R"(( )+)");
/* 匹配以非空格开头的字符，空格隔开，中间任意字符，空格隔开，非空格组成的结尾
* (文件类型) ... (文件大小,$5) ... (文件名)
*/
const std::regex parseReg1(R"(^([^ ]+) (\d*) (\w*) (\w*) (\d*) (.*) ([^ ]+)$)");
// SPDLOG_INFO("\n-------------------\n");
/* 匹配换行符，分割每一行 */
const std::regex parseReg2(R"(\n)");
/* 匹配文件夹 */
const std::regex parseReg3(R"(^d.*)");
/* 匹配文件 */
const std::regex parseReg4(R"(^-.*$)");
/**
* @brief 解析字符串文件信息，如果FTP服务器规定好个编码，不需要进行转换
*
* @param strSrc 读取到的字符串
* @param fileList 文件信息列表
* @return true
* @return false
*/
static bool parseFileInfo(const std::string& strSrc, std::vector<CF_FileInfo>& fileInfo)
{
#if defined(_WIN32)
// auto str1 = GBToUTF8(strSrc.c_str());
std::string str2 = strSrc;
#else
std::string str2 = strSrc;
#endif /* _WIN32 */
// SPDLOG_DEBUG("\n{}", str2);
// /* 正则表达式，匹配多个空格 */
// std::regex regSpace(R"(( )+)");
// /* 匹配以非空格开头的字符，空格隔开，中间任意字符，空格隔开，非空格组成的结尾
// * (文件类型) ... (文件大小,$5) ... (文件名)
// */
// std::regex reg1(R"(^([^ ]+) (\d*) (\w*) (\w*) (\d*) (.*) ([^ ]+)$)");
// // SPDLOG_INFO("\n-------------------\n");
// /* 匹配换行符，分割每一行 */
// std::regex reg2(R"(\n)");
// /* 匹配文件夹 */
// std::regex reg3(R"(^d.*)");
// /* 匹配文件 */
// std::regex reg4(R"(^-.*$)");
/* -1 表示对正则表达式之前的子序列感兴趣
* 0 表示对正则表达式本身感兴趣，输出的就是换行符 */
std::sregex_token_iterator it2(str2.begin(), str2.end(), parseReg2, -1);
/* 这里取出每一行 */
for(; it2 != std::sregex_token_iterator(); ++it2)
{
/* 去掉多余的空格 */
auto line = std::regex_replace(it2->str(), parseRegSpace, " ");
// SPDLOG_INFO("{}", line);
CF_FileInfo fi;
/* 取出文件类型 */
std::string strFileType = std::regex_replace(line, parseReg1, "$1");
if(std::regex_match(strFileType, parseReg3))
{
fi.type = CF_FileType::DIR;
}else if (std::regex_match(strFileType, parseReg4))
{
fi.type = CF_FileType::FILE;
}
/* 取出文件大小 */
std::string strFileSize = std::regex_replace(line, parseReg1, "$5");
fi.size = std::stoull(strFileSize);
/* 取出文件名 */
std::string strFileName = std::regex_replace(line, parseReg1, "$7");
fi.name = strFileName;
/* 加入队列 */
fileInfo.push_back(fi);
}
return true;
}
/* ==================================================================================
* *********************************** 成员函数 *************************************
* ================================================================================== */
CurlFtp::CurlFtp()
{
/* 调用初始化函数，这个函数可以重复调用 */
curl_global_init(CURL_GLOBAL_DEFAULT);
/* 初始化curl */
hasInstace = true;
}
CurlFtp::~CurlFtp()
{
/* 清理curl */
curl_easy_cleanup(m_curl);
curl_global_cleanup();
hasInstace = false;
}
/* 设置用户名和密码 */
bool CurlFtp::setUsernameAndPassword(const std::string& username, const std::string& password)
{
m_username = username;
m_password = password;
return true;
}
/* 设置IP和端口 */
bool CurlFtp::setFtpIPAndPort(const std::string& IP, const int port)
{
/*先判断是否有ftp器前缀，通过正则表达式，取出IP地址和端口号，去掉前缀和后面的'/ */
m_IP = IP;
m_port = port;
m_ftpUrl = "ftp://" + m_IP + ":" + std::to_string(m_port);
SPDLOG_INFO("Set ftpUrl = {}", m_ftpUrl);
m_isSftp = false;
return true;
}
/* 设置SFTP的IP和端口 */
bool CurlFtp::setSftpIPAndPort(const std::string& IP, const int port)
{
m_IP = IP;
m_port = port;
m_ftpUrl = "sftp://" + m_IP + ":" + std::to_string(m_port);
SPDLOG_INFO("Set sftpUrl = {}", m_ftpUrl);
m_isSftp = true;
return true;
}
/* 设置是否忽略SSL证书，使用SFTP不建议忽略 */
void CurlFtp::setIgnoreSSLCert(bool isIgnore)
{
m_isIgnoreSSLCert = isIgnore;
}
/* 设置CA证书文件 */
void CurlFtp::setCaCertFile(const std::string& caCertFile)
{
m_caCertFile = caCertFile;
}
/* 设置是否启用CURL的调试信息 */
void CurlFtp::enableCurlDebug(bool isPrint)
{
m_enableCurlDebug = isPrint;
}
/* 列出文件列表 */
bool CurlFtp::getFileList(std::string dir, std::vector<std::string>& fileList)
{
if(m_IP.empty())
{
SPDLOG_WARN("IP or port is empty");
return false;
}
/* 检查dir，添加前缀“/” */
auto dirTmp = checkDirPath(dir);
// CURL *curl = nullptr;
// curl = curl_easy_init();
// if(curl == nullptr)
// {
// SPDLOG_ERROR("curl init failed !");
// return false;
// }
resetCurl(m_curl);
std::vector<CF_FileInfo> listInfo;
/* 获取文件信息 */
listAll(m_curl, dirTmp, listInfo);
for(const CF_FileInfo& fi : listInfo)
{
// SPDLOG_INFO("type = {}, size = {}, name = {}", (int)fi.type, fi.size, fi.name);
if(fi.type == CF_FileType::FILE)
{
fileList.push_back(fi.name);
}
}
// curl_easy_cleanup(curl);
return true;
}
/* 获取文件夹列表 */
bool CurlFtp::getDirList(std::string dir, std::vector<std::string>& dirList)
{
if(m_IP.empty())
{
SPDLOG_WARN("IP or port is empty");
return false;
}
/* 检查dir，添加前缀“/” */
auto dirTmp = checkDirPath(dir);
// CURL *curl = nullptr;
// curl = curl_easy_init();
// if(curl == nullptr)
// {
// SPDLOG_ERROR("curl init failed !");
// return false;
// }
resetCurl(m_curl);
std::vector<CF_FileInfo> listInfo;
/* 获取文件信息 */
listAll(m_curl, dirTmp, listInfo);
for(const CF_FileInfo& fi : listInfo)
{
// SPDLOG_INFO("type = {}, size = {}, name = {}", (int)fi.type, fi.size, fi.name);
if(fi.type == CF_FileType::DIR)
{
dirList.push_back(fi.name);
}
}
// curl_easy_cleanup(curl);
return true;
}
/**
* @brief 判断文件夹是否存在，FTP和SFTP判断方式不同
* FTP使用curl检测判断，但是SFTP无论文件夹是否存在都会返回真，所以只能通过列出文件夹的方式判断
*
* @param dir
* @return true
* @return false
*/
bool CurlFtp::isDirExist(const std::string& dir)
{
SPDLOG_DEBUG("Check remote dir: {}", dir);
if(m_ftpUrl.empty())
{
SPDLOG_ERROR("ftpUrl is empty");
return false;
}
if(dir == "/")
{
return true;
}
bool result = false;
if(m_isSftp)
{
result = checkSftpDirExist(dir);
}else {
result = checkFtpDirExist(dir);
}
return result;
}
/**
* @brief 创建FTP文件夹，只能创建一层文件夹
*
* @param ftpDir 文件夹路径
* @return true 文件夹创建成功或者文件夹存在
* @return false
*/
bool CurlFtp::createDirectory(const std::string& ftpDir)
{
if(m_ftpUrl.empty())
{
SPDLOG_ERROR("ftpUrl is empty");
return false;
}
/* 先检查FTP文件夹是否存在，如果存在直接返回true */
if(isDirExist(ftpDir))
{
return true;
}
/* 检查传入的文件夹格式 */
auto dirTmp = checkDirPath(ftpDir);
// CURL *curl = curl_easy_init();
// if(curl == nullptr)
// {
// SPDLOG_ERROR("Create FTP DIR, curl init failed !");
// return false;
// }
resetCurl(m_curl);
curl_easy_setopt(m_curl, CURLOPT_URL, m_ftpUrl.c_str());
curl_easy_setopt(m_curl, CURLOPT_USERNAME, m_username.c_str());
curl_easy_setopt(m_curl, CURLOPT_PASSWORD, m_password.c_str());
/* 创建FTP头信息 */
struct curl_slist *headerlist = NULL;
std::string mkdir;
if(m_isSftp)
{
mkdir = "MKDIR " + dirTmp;
}else {
mkdir = "MKD " + dirTmp;
}
headerlist = curl_slist_append(headerlist, mkdir.c_str());
/* 设置FTP命令行选项 */
curl_easy_setopt(m_curl, CURLOPT_QUOTE, headerlist);
/* 不包含实体 */
curl_easy_setopt(m_curl, CURLOPT_NOBODY, 1L);
/* 启用跟随重定向 */
curl_easy_setopt(m_curl, CURLOPT_FOLLOWLOCATION, 1L);
/* 设置超时时间 */
curl_easy_setopt(m_curl, CURLOPT_TIMEOUT, 30L);
curl_easy_setopt(m_curl, CURLOPT_CONNECTTIMEOUT, 30L);
/* 设置SFTP */
setSftp(m_curl);
if(m_enableCurlDebug)
{
/* 启用调试信息 */
curl_easy_setopt(m_curl, CURLOPT_VERBOSE, 1L);
}
// 启用持久连接
// curl_easy_setopt(m_curl, CURLOPT_TCP_KEEPALIVE, 1L);
SPDLOG_DEBUG("Create remote dir: {}", dirTmp);
// CURLcode res = curl_easy_perform(curl);
bool ret = performCurl(m_curl);
if(!ret)
{
SPDLOG_ERROR("Failed to create remote Dir");
}
// curl_easy_cleanup(curl);
curl_slist_free_all(headerlist);
return ret;
}
/* 创建FTP文件夹，递归创建 */
bool CurlFtp::createDirectories(const std::string& ftpDir)
{
/* 检查路径格式，并去掉第一个 / */
std::string ftpDirTmp = checkDirPath(ftpDir);
std::string ftpDir2 = ftpDirTmp.substr(1, ftpDirTmp.size() -1);
/* 将文件夹分开，取出每一个文件夹名称 */
std::vector<std::string> strList;
std::regex reg(R"(/)");
std::sregex_token_iterator it(ftpDir2.begin(), ftpDir2.end(), reg, -1);
for( ; it != std::sregex_token_iterator(); ++it)
{
strList.push_back(it->str());
}
/* 将每一层拼接起来，逐层递归 */
std::vector<std::string> dirList;
for(const std::string& dir : strList)
{
std::string dirTmp = "/";
if(!dirList.empty())
{
dirTmp = dirList.back();
dirTmp += "/";
}
dirTmp += dir;
dirList.push_back(dirTmp);
}
/* 逐层创建 */
for(const std::string& dir : dirList)
{
// SPDLOG_DEBUG("Create dir: {}", dir);
if(!createDirectory(dir))
{
SPDLOG_ERROR("Failed to create dir: {}", dir);
return false;
}
}
return true;
}
/**
* @brief 下载文件
*
* @param remoteFile
* @param localFile
* @param timeout 超时时间，单位秒
* @return true
* @return false
*/
bool CurlFtp::downloadFile(const std::string& remoteFile, const std::string& localFile, size_t timeout)
{
if(m_ftpUrl.empty())
{
SPDLOG_ERROR("ftpUrl is empty");
return false;
}
/* 检查传入的文件是否符合规范 */
std::string remoteFileTmp = checkFilePath(remoteFile);
std::string ftpUrl = m_ftpUrl + remoteFileTmp;
/* 检查本地文件夹是否存在，不存在则创建 */
// std::string localDir = localFile.substr(0, localFile.find_last_of("/")); /* 去掉最后的 / */
std::string localDirTmp = localFile.substr(0, localFile.find_last_of("/"));
if(!checkLocalDir(localDirTmp))
{
SPDLOG_ERROR("Failed to create local dir: {}", localDirTmp);
return false;
}
// CURL* curl = nullptr;
// curl = curl_easy_init();
// if(curl == nullptr)
// {
// SPDLOG_ERROR("curl init failed !");
// return false;
// }
resetCurl(m_curl);
/* 打开文件 */
std::ofstream ofs;
ofs.open(localFile, std::ios::out | std::ios::binary | std::ios::trunc);
/* 设置FTP地址 */
curl_easy_setopt(m_curl, CURLOPT_URL, ftpUrl.c_str());
curl_easy_setopt(m_curl, CURLOPT_PORT, m_port);
/* 设置用户名和密码 */
curl_easy_setopt(m_curl, CURLOPT_USERNAME, m_username.c_str());
curl_easy_setopt(m_curl, CURLOPT_PASSWORD, m_password.c_str());
curl_easy_setopt(m_curl, CURLOPT_USERPWD, (m_username + ":" + m_password).c_str());
/* 启用跟随重定向 */
curl_easy_setopt(m_curl, CURLOPT_FOLLOWLOCATION, 1L);
/* 设置回调函数 */
curl_easy_setopt(m_curl, CURLOPT_WRITEFUNCTION, writeFileCallBack);
curl_easy_setopt(m_curl, CURLOPT_WRITEDATA, &ofs);
/* 设置超时时间 */
// curl_easy_setopt(curl, CURLOPT_TIMEOUT, 30L);
curl_easy_setopt(m_curl, CURLOPT_CONNECTTIMEOUT, timeout);
/* 设置进度回调函数 */
curl_easy_setopt(m_curl, CURLOPT_XFERINFOFUNCTION, progress_callback);
curl_easy_setopt(m_curl, CURLOPT_XFERINFODATA, nullptr);
/* 启用下载进度回调函数 */
curl_easy_setopt(m_curl, CURLOPT_NOPROGRESS, 0L);
/* 设置SFTP */
setSftp(m_curl);
if(m_enableCurlDebug)
{
/* 启用调试信息 */
curl_easy_setopt(m_curl, CURLOPT_VERBOSE, 1L);
}
/* 启用持久连接 */
curl_easy_setopt(m_curl, CURLOPT_TCP_KEEPALIVE, 1L);
/* 发送请求 */
bool ret = performCurl(m_curl);
if(!ret)
{
SPDLOG_ERROR("Failed to get file list, Url = {}", ftpUrl);
/* 清理下载失败的文件 */
ofs.close();
std::remove(localFile.c_str());
return false;
}
/* 关闭文件，清理curl */
ofs.close();
// curl_easy_cleanup(curl);
/* 打印一个换行符 */
// printf("\n");
printf("\n");
return true;
}
/* 下载文件到数组 */
bool CurlFtp::downloadToArray(const std::string& remoteFile, std::vector<char>& arrayInfo, size_t timeout)
{
if(m_ftpUrl.empty())
{
SPDLOG_ERROR("ftpUrl is empty");
return false;
}
/* 检查传入的文件是否符合规范 */
std::string remoteFileTmp = checkFilePath(remoteFile);
std::string ftpUrl = m_ftpUrl + remoteFileTmp;
// CURL* curl = nullptr;
// curl = curl_easy_init();
// if(curl == nullptr)
// {
// SPDLOG_ERROR("curl init failed !");
// return false;
// }
resetCurl(m_curl);
/* 设置FTP地址 */
curl_easy_setopt(m_curl, CURLOPT_URL, ftpUrl.c_str());
curl_easy_setopt(m_curl, CURLOPT_PORT, m_port);
/* 设置用户名和密码 */
curl_easy_setopt(m_curl, CURLOPT_USERNAME, m_username.c_str());
curl_easy_setopt(m_curl, CURLOPT_PASSWORD, m_password.c_str());
curl_easy_setopt(m_curl, CURLOPT_USERPWD, (m_username + ":" + m_password).c_str());
/* 启用跟随重定向 */
curl_easy_setopt(m_curl, CURLOPT_FOLLOWLOCATION, 1L);
/* 设置回调函数 */
curl_easy_setopt(m_curl, CURLOPT_WRITEFUNCTION, writeDataCallBack);
curl_easy_setopt(m_curl, CURLOPT_WRITEDATA, &arrayInfo);
/* 设置超时时间 */
// curl_easy_setopt(curl, CURLOPT_TIMEOUT, 30L);
curl_easy_setopt(m_curl, CURLOPT_CONNECTTIMEOUT, timeout);
/* 设置进度回调函数 */
curl_easy_setopt(m_curl, CURLOPT_XFERINFOFUNCTION, progress_callback);
curl_easy_setopt(m_curl, CURLOPT_XFERINFODATA, nullptr);
/* 启用下载进度回调函数 */
curl_easy_setopt(m_curl, CURLOPT_NOPROGRESS, 0L);
/* 设置SFTP */
setSftp(m_curl);
if(m_enableCurlDebug)
{
/* 启用调试信息 */
curl_easy_setopt(m_curl, CURLOPT_VERBOSE, 1L);
}
/* 启用持久连接 */
curl_easy_setopt(m_curl, CURLOPT_TCP_KEEPALIVE, 1L);
/* 发送请求 */
bool ret = performCurl(m_curl);
if(!ret)
{
SPDLOG_ERROR("Failed to get file list, Url = {}", ftpUrl);
}
/* 清理curl */
// curl_easy_cleanup(curl);
/* 打印一个换行符 */
// printf("\n");
printf("\n");
return ret;
}
/**
* @brief 上传文件
*
* @param localFile 本地文件
* @param remoteFile 远程文件
* @param timeout 超时时间，单位秒
* @return true
* @return false
*/
bool CurlFtp::uploadFile(const std::string& localFile, const std::string& remoteFile, size_t timeout, bool isCreateDir)
{
if(m_ftpUrl.empty())
{
SPDLOG_ERROR("Url is empty");
return false;
}
/* 检查本地文件是否存在 */
if(!std::filesystem::exists(localFile))
{
SPDLOG_ERROR("Local file is not exist: {}", localFile);
return false;
}
/* 检查FTP文件名是否符合规范 */
std::string remoteFileTmp = checkFilePath(remoteFile);
std::string remoteDirTmp = remoteFileTmp.substr(0, remoteFileTmp.find_last_of("/"));
/* 检查远程FTP上的文件夹是否存在，不存在则创建 */
if(!isDirExist(remoteDirTmp))
{
if(isCreateDir)
{
if(!createDirectories(remoteDirTmp))
{
// SPDLOG_ERROR("Failed to create remote dir: {}", remoteFileTmp);
return false;
}
}else {
SPDLOG_ERROR("Remote dir is not exist: {}", remoteDirTmp);
return false;
}
}
/* 拼接远程文件的url */
std::string ftpUrl = m_ftpUrl + remoteFileTmp;
/* 打开文件 */
std::ifstream ifs;
ifs.open(localFile, std::ios::in | std::ios::binary);
if(!ifs.is_open())
{
SPDLOG_ERROR("Failed to open local file: {}", localFile);
return false;
}
/* 获取文件大小 */
// auto startPos = ifs.tellg();
ifs.seekg(0, std::ios::end);
auto fileSize = ifs.tellg();
/* 恢复指针到文件头 */
ifs.seekg(0, std::ios::beg);
SPDLOG_DEBUG("File size: {}", (long)fileSize);
// CURL* curl = nullptr;
// curl = curl_easy_init();
// if(curl == nullptr)
// {
// SPDLOG_ERROR("curl init failed !");
// ifs.close();
// return false;
// }
if(!resetCurl(m_curl))
{
ifs.close();
return false;
}
/* 设置FTP地址 */
curl_easy_setopt(m_curl, CURLOPT_URL, ftpUrl.c_str());
curl_easy_setopt(m_curl, CURLOPT_PORT, m_port);
/* 设置用户名和密码 */
curl_easy_setopt(m_curl, CURLOPT_USERNAME, m_username.c_str());
curl_easy_setopt(m_curl, CURLOPT_PASSWORD, m_password.c_str());
/* 启用跟随重定向 */
curl_easy_setopt(m_curl, CURLOPT_FOLLOWLOCATION, 1L);
/* 启用上传 */
curl_easy_setopt(m_curl, CURLOPT_UPLOAD, 1L);
/* 设置回调函数 */
curl_easy_setopt(m_curl, CURLOPT_READFUNCTION, readFileCallBack);
curl_easy_setopt(m_curl, CURLOPT_READDATA, &ifs);
/* 设置上传文件的大小 */
curl_easy_setopt(m_curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)fileSize);
/* 设置超时时间 */
// curl_easy_setopt(curl, CURLOPT_TIMEOUT, 30L);
curl_easy_setopt(m_curl, CURLOPT_CONNECTTIMEOUT, timeout);
/* 设置进度回调函数 */
curl_easy_setopt(m_curl, CURLOPT_XFERINFOFUNCTION, progress_callback);
curl_easy_setopt(m_curl, CURLOPT_XFERINFODATA, nullptr);
/* 启用下载进度回调函数 */
curl_easy_setopt(m_curl, CURLOPT_NOPROGRESS, 0L);
/* 设置SFTP */
setSftp(m_curl);
/* 启用调试信息 */
if(m_enableCurlDebug)
{
curl_easy_setopt(m_curl, CURLOPT_VERBOSE, 1L);
}
/* 启用持久连接 */
curl_easy_setopt(m_curl, CURLOPT_TCP_KEEPALIVE, 1L);
/* 发送请求 */
bool ret = performCurl(m_curl);
if(!ret)
{
SPDLOG_ERROR("Upload file failed, Url = {}", ftpUrl);
}
/* 关闭文件，清理curl */
ifs.close();
// curl_easy_cleanup(curl);
/* 打印一个换行符 */
printf("\n");
return ret;
}
/**
* @brief 上传文件，上传数据
* 注意：函数内不会拷贝数据，因此在上传完成前需要保证该指针的有效性，拷贝完成后也不会销毁源数据
* 默认超时时间是30秒，也无法设置
*
* @param srcData 数据指针
* @param size 数据大小
* @param remoteFile 远程文件名，包括地址
* @param timeout 超时时间，单位秒
* @return true
* @return false
*/
bool CurlFtp::uploadData(char* srcData, size_t size, const std::string& remoteFile, size_t timeout, bool isCreateDir)
{
if(m_ftpUrl.empty())
{
SPDLOG_ERROR("Url is empty");
return false;
}
/* 初始化本地数据 */
CF_ArrayInfo arrayInfo;
arrayInfo.data = srcData;
arrayInfo.size = size;
arrayInfo.pos = 0;
/* 检查FTP文件名是否符合规范 */
std::string remoteFileTmp = checkFilePath(remoteFile);
std::string remoteDirTmp = remoteFileTmp.substr(0, remoteFileTmp.find_last_of("/"));
/* 检查远程FTP上的文件夹是否存在，不存在则创建 */
if(!isDirExist(remoteDirTmp))
{
if(isCreateDir)
{
if(!createDirectories(remoteDirTmp))
{
// SPDLOG_ERROR("Failed to create remote dir: {}", remoteFileTmp);
return false;
}
}else {
SPDLOG_ERROR("Remote dir is not exist: {}", remoteDirTmp);
return false;
}
}
/* 拼接远程文件的url */
std::string ftpUrl = m_ftpUrl + remoteFileTmp;
SPDLOG_DEBUG("Data size: {}", arrayInfo.size);
// CURL* curl = nullptr;
// curl = curl_easy_init();
// if(curl == nullptr)
// {
// SPDLOG_ERROR("curl init failed !");
// return false;
// }
if(!resetCurl(m_curl))
{
return false;
}
/* 设置FTP地址 */
curl_easy_setopt(m_curl, CURLOPT_URL, ftpUrl.c_str());
curl_easy_setopt(m_curl, CURLOPT_PORT, m_port);
/* 设置用户名和密码 */
// curl_easy_setopt(curl, CURLOPT_USERNAME, m_username.c_str());
// curl_easy_setopt(curl, CURLOPT_PASSWORD, m_password.c_str());
curl_easy_setopt(m_curl, CURLOPT_USERPWD, (m_username + ":" + m_password).c_str());
/* 启用跟随重定向 */
curl_easy_setopt(m_curl, CURLOPT_FOLLOWLOCATION, 1L);
/* 启用上传 */
curl_easy_setopt(m_curl, CURLOPT_UPLOAD, 1L);
/* 设置回调函数 */
curl_easy_setopt(m_curl, CURLOPT_READFUNCTION, readDataCallBack);
curl_easy_setopt(m_curl, CURLOPT_READDATA, &arrayInfo);
/* 设置上传文件的大小 */
curl_easy_setopt(m_curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)arrayInfo.size);
/* 设置超时时间 */
// curl_easy_setopt(curl, CURLOPT_TIMEOUT, 30L);
curl_easy_setopt(m_curl, CURLOPT_CONNECTTIMEOUT, timeout);
/* 设置进度回调函数 */
curl_easy_setopt(m_curl, CURLOPT_XFERINFOFUNCTION, progress_callback);
curl_easy_setopt(m_curl, CURLOPT_XFERINFODATA, nullptr);
/* 启用下载进度回调函数 */
curl_easy_setopt(m_curl, CURLOPT_NOPROGRESS, 0L);
// 禁用被动模式（如果需要）
curl_easy_setopt(m_curl, CURLOPT_FTP_USE_EPSV, 1L);
if(m_enableCurlDebug)
{
/* 启用调试信息 */
curl_easy_setopt(m_curl, CURLOPT_VERBOSE, 1L);
}
/* 启用持久连接 */
curl_easy_setopt(m_curl, CURLOPT_TCP_KEEPALIVE, 1L);
/* 发送请求 */
bool ret = performCurl(m_curl);
if(!ret)
{
SPDLOG_ERROR("Upload file failed, Url = {}", ftpUrl);
}
/* 关闭文件，清理curl */
// curl_easy_cleanup(curl);
/* 打印一个换行符 */
printf("\n");
return ret;
}
/**
* @brief 列出文件列表，这个需要的参数很多，无法设置成静态函数
*
* @param curl CURL句柄
* @param dir 文件夹，相对路径，不带有IP和端口号
* @param fileList 返回值，文件列表
* @return true
* @return false
*/
bool CurlFtp::listAll(CURL* curl, std::string dir, std::vector<CF_FileInfo>& fileInfoList)
{
if(m_IP.empty())
{
SPDLOG_ERROR("IP is empty");
return false;
}
bool result = false;
std::string strSrc;
/* 先设置FTP地址 */
std::string ftpUrl = m_ftpUrl + dir;
curl_easy_setopt(curl, CURLOPT_URL, ftpUrl.c_str());
curl_easy_setopt(curl, CURLOPT_PORT, m_port);
/* 设置用户名和密码 */
curl_easy_setopt(curl, CURLOPT_USERNAME, m_username.c_str());
curl_easy_setopt(curl, CURLOPT_PASSWORD, m_password.c_str());
/* 设置列出文件命令，只列出文件名称，不携带信息 */
// curl_easy_setopt(m_curl, CURLOPT_DIRLISTONLY, 1L);
/* 设置回调函数 */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeStringCallback);
/* 设置需要写入的容器，回调函数的第四个参数 */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &strSrc);
/* 设置超时时间 */
curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);
curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 10L);
// 禁用被动模式，设置为0是禁用（如果需要）
// curl_easy_setopt(curl, CURLOPT_FTP_USE_EPSV, 1L);
if(m_enableCurlDebug)
{
/* 启用调试信息 */
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
}
/* 发送请求 */
// CURLcode res = curl_easy_perform(curl);
bool ret = performCurl(curl);
if(!ret)
{
SPDLOG_ERROR("Failed to get file listUrl = {}", ftpUrl);
return false;
}
/* 解析字符串 */
parseFileInfo(strSrc, fileInfoList);
return true;
}
/* 检查文件夹路径是否合规，不合规就修改 */
std::string CurlFtp::checkDirPath(const std::string& dir)
{
std::string dirTmp = dir;
/* 检查是否以“/”开头 */
std::regex reg(R"(^/[.]*)");
if(!std::regex_match(dirTmp, reg))
{
dirTmp = "/" + dirTmp;
}
/* 如果有重复的“/”，替换成一个 “/” */
std::regex reg1(R"(//)");
dirTmp = std::regex_replace(dirTmp, reg1, "/");
/* 检查是否以“/”结束 */
std::regex reg2(R"([.]*/$)");
if(!std::regex_match(dirTmp, reg2))
{
dirTmp = dirTmp + "/";
}
return dirTmp;
}
/* 检查文件路径是否合规 */
std::string CurlFtp::checkFilePath(const std::string& file)
{
std::string dirTmp = file;
/* 检查是否以“/”结束，如果是以“/”结尾，返回空字符串，并报错 */
std::regex reg2(R"([.]*/$)");
if(std::regex_match(dirTmp, reg2))
{
SPDLOG_ERROR("File path is not correct, end with '/'");
return std::string();
}
/* 检查是否以“/”开头 */
std::regex reg(R"(^/[.]*)");
if(!std::regex_match(dirTmp, reg))
{
dirTmp = "/" + dirTmp;
}
/* 如果有重复的“/”，替换成一个 “/” */
std::regex reg1(R"(//)");
dirTmp = std::regex_replace(dirTmp, reg1, "/");
return dirTmp;
}
/**
* @brief 检查本地文件夹是否存在，不存在则创建
* 这里默认传入的是文件夹路径，不是文件路径，如果最后有‘/’，会自动去掉
*
* @param localDir 文件夹路径
* @return true
* @return false
*/
bool CurlFtp::checkLocalDir(const std::string& localDir)
{
/* 去掉最后的‘/’ */
std::regex reg(R"([.]*/$)");
std::string localDirTmp = std::regex_replace(localDir, reg, "");
/* 检查文件夹是否存在 */
if(std::filesystem::exists(localDirTmp))
{
return true;
}
/* 创建文件夹 */
if(!std::filesystem::create_directories(localDirTmp))
{
SPDLOG_ERROR("Failed to create local dir: {}", localDirTmp);
return false;
}
return true;
}
/* 执行curl，添加重试机制 */
bool CurlFtp::performCurl(CURL* curl)
{
int retry = 3;
while(retry > 0)
{
CURLcode res = curl_easy_perform(curl);
if(res == CURLE_OK)
{
return true;
}
else if (res == CURLE_LOGIN_DENIED)
{
SPDLOG_ERROR("Login failed, error code: {} ,{}", (int)res, curl_easy_strerror(res));
/* 设置用户名和密码 */
curl_easy_setopt(curl, CURLOPT_USERNAME, m_username.c_str());
curl_easy_setopt(curl, CURLOPT_PASSWORD, m_password.c_str());
}
else
{
SPDLOG_ERROR("Perform curl failed, error code: {} ,{}", (int)res, curl_easy_strerror(res));
SPDLOG_ERROR("Retry times: {}", 4 - retry);
}
retry--;
}
return false;
}
/* 重置curl设置 */
bool CurlFtp::resetCurl(CURL* curl)
{
if(m_curl == nullptr)
{
m_curl = curl_easy_init();
if(m_curl == nullptr)
{
SPDLOG_ERROR("curl init failed !");
return false;
}
}else {
curl_easy_reset(m_curl);
}
return true;
}
/* 设置sftp，如果是sftp就设置 */
bool CurlFtp::setSftp(CURL* curl)
{
/* 判断是否是SFTP */
if(m_isSftp)
{
/* 判断是否需要设置CA证书 */
if(m_isIgnoreSSLCert)
{
/* 忽略证书验证 */
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
/* 忽略主机名验证 */
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
} else
{
/* 设置CA证书 */
curl_easy_setopt(curl, CURLOPT_CAINFO, m_caCertFile.c_str());
}
}
return true;
}
/**
* @brief 检查FTP文件夹是否存在，注意，传入的文件夹最后一定要带/，否则会检查的是文件
*
* @param dir
* @return true
* @return false
*/
bool CurlFtp::checkFtpDirExist(const std::string& dir)
{
/* 检查传入的文件夹 */
auto dirTmp = checkDirPath(dir);
resetCurl(m_curl);
std::string ftpUrl = m_ftpUrl + dirTmp;
curl_easy_setopt(m_curl, CURLOPT_URL, ftpUrl.c_str());
curl_easy_setopt(m_curl, CURLOPT_USERNAME, m_username.c_str());
curl_easy_setopt(m_curl, CURLOPT_PASSWORD, m_password.c_str());
/* 获取文件夹是否存在，不需要接收文件 */
curl_easy_setopt(m_curl, CURLOPT_NOBODY, 1L);
// curl_easy_setopt(m_curl, CURLOPT_HEADER, 1L);
/* 设置SFTP */
setSftp(m_curl);
/* 启用调试信息 */
if(m_enableCurlDebug)
{
curl_easy_setopt(m_curl, CURLOPT_VERBOSE, 1L);
}
/* 启用持久连接 */
// curl_easy_setopt(m_curl, CURLOPT_TCP_KEEPALIVE, 1L);
/* 这里只需要执行一次 */
CURLcode res = curl_easy_perform(m_curl);
bool result = true;
if(res == CURLE_REMOTE_FILE_NOT_FOUND)
{
result = false;
}
else if(res == CURLE_OK)
{
result = true;
} else
{
SPDLOG_ERROR("Check remote dir error, error code: {} ,{}", (int)res, curl_easy_strerror(res));
result = false;
}
// SPDLOG_DEBUG("Check remote dir: {}, res: {}", dir, (int)res);
return result;
}
/* 检查SFTP文件夹是否存在，这里通过列出上一层的文件夹中的内容，然后进行对比判断的 */
bool CurlFtp::checkSftpDirExist(const std::string& dir)
{
/* 取出上一层文件夹路径 */
std::string parentDir = std::filesystem::path(dir).parent_path().string();
// SPDLOG_DEBUG("Parent dir: {}", parentDir);
std::vector<std::string> vecDir;
bool ret = getDirList(parentDir, vecDir);
if(!ret)
{
SPDLOG_ERROR("Failed to check sftp dir: {}", dir);
return false;
}
/* 取出本层文件夹名称 */
std::string dirName = std::filesystem::path(dir).filename().string();
// SPDLOG_DEBUG("Dir name: {}", dirName);
/* 判断是否存在 */
bool result = false;
for(const std::string& str : vecDir)
{
if(str == dirName)
{
result = true;
break;
}
}
return result;
}