sftp通信攻关——qt环境下使用c++实现

最新推荐文章于 2024-09-05 23:15:17 发布

njlite

最新推荐文章于 2024-09-05 23:15:17 发布

阅读量1k

点赞数

分类专栏： Qt

原文链接：https://blog.csdn.net/qq_38977538/article/details/89213085

版权

Qt 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

最近涉及到sftp通信编码。上传测试代码记录一下。

头文件：

#ifndef SFTPMANAGER_H
#define SFTPMANAGER_H
#ifdef WIN32
#include "libssh2/win32/libssh2_config.h"
#endif
#include <mutex>
#include <memory>
#include <QThread>
#include <iostream>
#include <vector>
#include <libssh2/libssh2.h>
#ifdef WIN32
#include <windows.h>
#include <winsock2.h>
#pragma comment(lib, "Ws2_32.lib")
#else
#include <sys/socket.h>
#include <unistd.h>
#include <arpa/inet.h>
#endif
class SftpManager
{
public:
SftpManager();
virtual ~SftpManager();
bool connect(std::string szIp, int nPort = 22);
bool createSession();
bool login(std::string szUserName, std::string szPassword);
bool read();
bool mkdir();
bool readAndWrite();
private:
SOCKET m_socket;
LIBSSH2_SESSION *m_session = nullptr;
std::vector<LIBSSH2_CHANNEL*> m_channels;
//std::vector<std::mutex *> m_channel_mutexs;
std::vector<std::shared_ptr<std::mutex>> m_channel_mutexs;
static std::string m_ipAddress;
static int m_port;
static std::string m_username;
static std::string m_password;
static void initConnectionInfo();
static int waitsocket(int socket_fd, LIBSSH2_SESSION *session);
void shutDown();
static std::string ipAddress();
static std::string username();
static std::string password();
static int port();
};
#endif // SFTPMANAGER_H

源文件：

#include "SftpManager.h"
#include <QtXml>
#include <libssh2/libssh2_sftp.h>
#define STORAGE "d:\\src\\test.txt"
std::string SftpManager::m_password;
std::string SftpManager::m_username;
std::string SftpManager::m_ipAddress;
int SftpManager::m_port;
const char *sftppath = "/home/loohos-01/abc/test";
const char *m_sftppath = "/home/loohos-01/abc/test_mkdir";
const char *m_dest = "/home/loohos-01/abc/test_dest";
SftpManager::SftpManager()
{
}
SftpManager::~SftpManager()
{
if (!m_channels.empty()){
for (auto channel : m_channels) if (nullptr != channel) libssh2_channel_free(channel);
m_channels.clear();
}
/*
if (!m_channel_mutexs.empty()){
for (auto mtx : m_channel_mutexs) delete mtx;
m_channel_mutexs.clear();
}
*/
if (nullptr != m_session){
libssh2_session_disconnect(m_session, "Bye bye, Thank you");
libssh2_session_free(m_session);
m_session = nullptr;
}
libssh2_exit();
if (INVALID_SOCKET != m_socket) closesocket(m_socket);
#ifdef WIN32
WSACleanup();
#endif
}
int SftpManager::waitsocket(int socket_fd, LIBSSH2_SESSION *session )
{
struct timeval timeout;
int rc;
fd_set fd;
fd_set *writefd = NULL;
fd_set *readfd = NULL;
int dir;
timeout.tv_sec = 10;
timeout.tv_usec = 0;
FD_ZERO(&fd);
FD_SET(socket_fd, &fd);
dir = libssh2_session_block_directions(session);
if(dir & LIBSSH2_SESSION_BLOCK_INBOUND)
readfd = &fd;
if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
writefd = &fd;
rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
return rc;
}
bool SftpManager::connect(std::string szIp, int nPort)
{
unsigned long hostaddr;
int sock, i, auth_pw = 1;
struct sockaddr_in sin;
const char *fingerprint;
LIBSSH2_SESSION *session;
const char *username = "loohos-01";
const char *password = "liuhe1688";
#ifdef HAVE_GETTIMEOFDAY
struct timeval start;
struct timeval end;
long time_ms;
#endif
int rc;
int total = 0;
int spin = 0;
LIBSSH2_SFTP *sftp_session;
LIBSSH2_SFTP_HANDLE *sftp_handle;
#ifdef WIN32
WSADATA wsadata;
int err;
err = WSAStartup(MAKEWORD(2,0), &wsadata);
if(err != 0)
{
qDebug() << "WSAStartup failed with error:" << err;
return false;
}
#endif
if(szIp == ""){
szIp = ipAddress();
}
if(nPort < 1){
nPort = port();
}
rc = libssh2_init(0);
if(rc != 0){
qDebug() << "libssh2 initialization failed." << rc;
return false;
}
hostaddr = inet_addr(szIp.c_str());
m_socket = socket(AF_INET, SOCK_STREAM, 0);
sin.sin_family = AF_INET;
sin.sin_port = htons(22);
sin.sin_addr.s_addr = hostaddr;
rc = ::connect(m_socket, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in));
if ( rc != 0) {
qDebug() << "Failed to connect!" << rc;
return false;
}
return true;
}
bool SftpManager::createSession()
{
int rc = 0;
LIBSSH2_KNOWNHOSTS *nh = nullptr;
size_t len;
int type;
const char *fingerprint;
m_session = libssh2_session_init();
if(!m_session){
qDebug() << "Create session instance failed.";
return false;
}
/* Since we have set non-blocking, tell libssh2 we are non-blocking */
libssh2_session_set_blocking(m_session, 1);
while ((rc = libssh2_session_handshake(m_session, m_socket)) == LIBSSH2_ERROR_EAGAIN);
if(rc){
qDebug() << "Failure establishing SSH session." << rc;
return false;
}
fingerprint = libssh2_hostkey_hash(m_session, LIBSSH2_HOSTKEY_HASH_SHA1);
qDebug() << "Fingerprint: ";
for (int i =0; i < 20; i++) {
qDebug() << "%02X " << (unsigned char)fingerprint[i];
}
qDebug() << "\n";
return true;
}
bool SftpManager::login(std::string szUserName, std::string szPassword)
{
int rc = 0;
int auth_pw = 1;
if(szUserName == ""){
szUserName = username();
}
if(szPassword == ""){
szPassword = password();
}
if(szPassword.size() > 0){
/* We could authenticate via password */
while ((rc = libssh2_userauth_password(m_session, "loohos-01", "liuhe1688")) ==
LIBSSH2_ERROR_EAGAIN);
if (rc) {
qDebug() << "Authentication by password failed.";
shutDown();
return false;
}
}else{
/* Or by public key */
while ((rc = libssh2_userauth_publickey_fromfile(m_session, m_username.c_str(),
"/home/user/"
".ssh/id_rsa.pub",
"/home/user/"
".ssh/id_rsa",
m_password.c_str())) ==
LIBSSH2_ERROR_EAGAIN);
if (rc) {
qDebug() << "Authentication by public key failed.";
shutDown();
}
}
return true;
}
bool SftpManager::read()
{
LIBSSH2_SFTP *m_sftp_session;
LIBSSH2_SFTP_HANDLE *m_sftp_handle;
int rc,total,spin = 0;
m_sftp_session = libssh2_sftp_init(m_session);
if(!m_sftp_session)
{
qDebug() << "Unable to init SFTP session\n";
shutDown();
}
qDebug() << "libssh2_sftp_open()!\n";
/* Request a file via SFTP */
do{
m_sftp_handle =
libssh2_sftp_open(m_sftp_session, sftppath, LIBSSH2_FXF_READ, 0);
if(!m_sftp_handle)
{
if(libssh2_session_last_errno(m_session) != LIBSSH2_ERROR_EAGAIN){}
qDebug() << "Unable to open file with SFTP\n";
shutDown();
}else {
qDebug() << "non-blocking open\n";
/*waitsocket(m_socket, m_session); *//* now we wait */
}
}while(!m_sftp_handle);
qDebug() << "libssh2_sftp_open() is done, now receive data!\n";
do {
char mem[1024*24];
/* loop until we fail */
while ((rc = libssh2_sftp_read(m_sftp_handle, mem,
sizeof(mem))) == LIBSSH2_ERROR_EAGAIN) {
spin++;
waitsocket(m_socket, m_session); /* now we wait */
}
if (rc > 0) {
total += rc;
write(1, mem, rc);
} else {
qDebug() << "the messages with sftp are : " <<mem;
break;
}
} while (1);
libssh2_sftp_close(m_sftp_handle);
libssh2_sftp_shutdown(m_sftp_session);
return true;
}
bool SftpManager::mkdir()
{
LIBSSH2_SFTP *m_sftp_session;
m_sftp_session = libssh2_sftp_init(m_session);
if(!m_sftp_session)
{
qDebug() << "Unable to init SFTP session\n";
shutDown();
}
qDebug() << "libssh2_sftp_open()!\n";
while(libssh2_sftp_mkdir(m_sftp_session,m_sftppath,LIBSSH2_SFTP_S_IRWXU|
LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IXGRP|
LIBSSH2_SFTP_S_IROTH|LIBSSH2_SFTP_S_IXOTH)
== LIBSSH2_ERROR_EAGAIN);
libssh2_sftp_shutdown(m_sftp_session);
}
bool SftpManager::readAndWrite()
{
char mem[1000];
LIBSSH2_SFTP *m_sftp_session;
LIBSSH2_SFTP_HANDLE *m_sftp_handle;
int rc;
int total,spin = 0;
struct timeval timeout;
fd_set fd;
FILE *tempstorage = NULL;
tempstorage = fopen(STORAGE, "wb");
if(!tempstorage){
qDebug() << "can't open temp storage file\n" << STORAGE;
shutDown();
}
m_sftp_session = libssh2_sftp_init(m_session);
if(!m_sftp_session)
{
qDebug() << "Unable to init SFTP session\n";
shutDown();
}
qDebug() << "libssh2_sftp_open()!\n";
/* Request a file via SFTP */
do{
m_sftp_handle =
libssh2_sftp_open(m_sftp_session, sftppath, LIBSSH2_FXF_READ, 0);
if(!m_sftp_handle)
{
if(libssh2_session_last_errno(m_session) != LIBSSH2_ERROR_EAGAIN){}
qDebug() << "Unable to open file with SFTP\n";
shutDown();
}else {
qDebug() << "non-blocking open\n";
/*waitsocket(m_socket, m_session); *//* now we wait */
}
}while(!m_sftp_handle);
qDebug() << "libssh2_sftp_open() is done, now receive data!\n";
do{
do {
rc = libssh2_sftp_read(m_sftp_handle,mem,sizeof (mem));
qDebug() << "libssh2_sftp_read returned %d/n" << rc;
if(rc > 0){
write(2,mem,rc);
fwrite(mem,rc,1,tempstorage);
}
} while (rc>0);
if (rc != LIBSSH2_ERROR_EAGAIN){
break;
}
timeout.tv_sec = 10;
timeout.tv_usec = 0;
FD_ZERO(&fd);
FD_SET(m_socket,&fd);
rc = select(m_socket + 1, &fd, &fd, NULL, &timeout);
if(rc <= 0){
qDebug() << "SFTP download timed out: %d\n" << rc;
break;
}
}while(1);
libssh2_sftp_close(m_sftp_handle);
fclose(tempstorage);
tempstorage = fopen(STORAGE, "rb+");
if(!tempstorage){
qDebug() << "can't open %s for reading\n" << STORAGE;
shutDown();
}
m_sftp_handle =
libssh2_sftp_open(m_sftp_session, m_dest,
LIBSSH2_FXF_WRITE|LIBSSH2_FXF_CREAT,
LIBSSH2_SFTP_S_IRUSR|LIBSSH2_SFTP_S_IWUSR|
LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IROTH);
if(m_sftp_handle){
size_t nread;
char *ptr;
do{
nread = fread(mem, 1, sizeof (mem), tempstorage);
if(nread <= 0){
break;
}
ptr = mem;
do{
rc = libssh2_sftp_write(m_sftp_handle, ptr, nread);
ptr += rc;
nread -= nread;
}while(rc >= 0);
if(rc != LIBSSH2_ERROR_EAGAIN){
break;
}
timeout.tv_sec = 10;
timeout.tv_usec = 0;
FD_ZERO(&fd);
FD_SET(m_socket,&fd);
rc = select(m_socket+1,&fd,&fd,NULL,&timeout);
if(rc <= 0){
qDebug() << "SFTP up;oad timed out: %d\n" << rc ;
break;
}
}while(1);
qDebug() << "SFTP upload done!\n";
}
else {
qDebug() << "SFTP failed to open destination path: %s\n";
}
libssh2_sftp_shutdown(m_sftp_session);
shutDown();
libssh2_session_disconnect(m_session, "Normal Shutdown, Thank you for playing");
libssh2_session_free(m_session);
}
void SftpManager::initConnectionInfo()
{
QDomDocument doc;
QFile file("config/sftp.xml");
if(!file.open(QIODevice::ReadOnly)){
return;
}
//read file in doc
if(!doc.setContent(&file)){
file.close();
return;
}
//close file
file.close();
//root element
QDomElement docElement = doc.documentElement();
QDomNodeList nodeList = docElement.elementsByTagName("server");
for(int i = 0; i != nodeList.size(); ++i){
QDomNode node = nodeList.at(i);
if(!node.isNull()){
if(node.isElement()){
QDomElement e = node.toElement();
QDomNodeList ipList = e.elementsByTagName("ipAddress");
QString ipAddress = ipList.at(0).toElement().text();
m_ipAddress = ipAddress.toStdString();
QDomNodeList portList = e.elementsByTagName("port");
int port = portList.at(0).toElement().text().toInt();
m_port = port;
QDomNodeList usernameList = e.elementsByTagName("username");
QString username = usernameList.at(0).toElement().text();
m_username = username.toStdString();
QDomNodeList passwordList = e.elementsByTagName("password");
QString password = passwordList.at(0).toElement().text();
m_password = password.toStdString();
}
}
}
}
void SftpManager::shutDown()
{
libssh2_session_disconnect(m_session, "Normal Shutdown, Thank you for playing");
libssh2_session_free(m_session);
#ifdef WIN32
closesocket(m_socket);
#else
close(m_socket);
#endif
fprintf(stderr, "all done\n");
libssh2_exit();
}
std::string SftpManager::ipAddress()
{
if(m_ipAddress == ""){
//initConnectionInfo();
m_ipAddress = "192.168.0.124";
}
return m_ipAddress;
}
int SftpManager::port()
{
if(m_port < 1){
//initConnectionInfo();
m_port = 22;
}
return m_port;
}
std::string SftpManager::username()
{
if(m_username == ""){
//initConnectionInfo();
m_username = "loohos-01";
}
return m_username;
}
std::string SftpManager::password()
{
if(m_password == ""){
//initConnectionInfo();
m_password = "liuhe1688";
}
return m_password;
}