libssh2+websocketpp做后端，vue xterm做前端的web端shell终端

已于 2022-07-22 14:33:26 修改
阅读量1.5k 收藏 1
点赞数
分类专栏： C/C++ web前端开发 文章标签： vue.js javascript ssh 终端
于 2022-07-22 14:20:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/canlynetsky/article/details/125931262
版权

之前发布了一篇文章，前端是一样的，只不过后端用的nodejs技术做的后台脚本，那个脚本太简单了，毕竟是解释性语言，就是节省开发时间，而且性能也不会太差。
这次则用C++方式实现了一版后台，用了boost做xml解析和互斥锁，websocketpp做websocket库，libssh2则是与sshd交互的库。程序采用多线程方式，有心跳监测，经过大量测试，运行相对很稳定的一段程序。
后台典型代码：

// global.h
#ifndef __GLOBAL_H__
#define __GLOBAL_H__

#include <iostream>
#include <list>
#include <vector>
#include <map>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <thread>
#include <signal.h>

using namespace std;

#endif


// SSH.h
#ifndef _SSH_H_20220720__
#define _SSH_H_20220720__
#include <iostream>
#include <map>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <libgen.h>
#include <fcntl.h>
#include <errno.h>
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/epoll.h>
#include <termios.h>
#include <libssh2.h>

using namespace std;

class SSH
{
private:
    const char *host = NULL;
    unsigned short port = 0;
    const char *username = NULL;
    const char *password = NULL;

    int sock = -1;
    LIBSSH2_SESSION *session = NULL;
    LIBSSH2_CHANNEL *channel = NULL;

public:
    SSH(const char *host, const unsigned short port, const char *username, const char *password);
    ~SSH();
    bool Connect();
    void DissConnect();
    ssize_t Write(const char *buffer, int n);
    ssize_t Read(char *buffer, int n);
    int Resize(int width, int height);
    int Socket() {return sock;}
    bool ChannelEof() {return libssh2_channel_eof(channel) == 1;}
};

#endif

// SSH.cpp
#include "SSH.h"

SSH::SSH(const char *host, const unsigned short port, const char *username, const char *password)
{
    this->host = host;
    this->port = port;
    this->username = username;
    this->password = password;
}

SSH::~SSH()
{
    DissConnect();
}

void SSH::DissConnect()
{
    if (channel)
    {
        libssh2_channel_free(channel);
        channel = NULL;
    }
    if (session)
    {
        libssh2_session_disconnect(session, "Session Shutdown, Thank you for playing");
        libssh2_session_free(session);
        session = NULL;
    }
    if (sock != -1)
    {
        close(sock);
        sock = -1;
    }
    libssh2_exit();
}

bool SSH::Connect()
{
    if (libssh2_init(0) != 0)
    {
        fprintf(stderr, "libssh2 initialization failed\n");
        return false;
    }

    LIBSSH2_SESSION *session = NULL;
    LIBSSH2_CHANNEL *channel = NULL;

    int sock = socket(AF_INET, SOCK_STREAM, 0);
    this->sock = sock;
    unsigned long hostaddr = inet_addr(this->host);
    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_port = htons(this->port);
    sin.sin_addr.s_addr = hostaddr;
    if (connect(sock, (struct sockaddr *)&sin, sizeof(struct sockaddr_in)) != 0)
    {
        fprintf(stderr, "Failed to established connection!\n");
        DissConnect();
        return false;
    }

    int sockFlags = fcntl(sock, F_GETFL, 0);
    fcntl(sock, F_SETFL, sockFlags | O_NONBLOCK);

    /* Open a session */
    session = libssh2_session_init();
    this->session = session;
    if (libssh2_session_startup(session, sock) != 0)
    {
        fprintf(stderr, "Failed Start the SSH session\n");
        DissConnect();
        return false;
    }

    /* Authenticate via password */
    if (libssh2_userauth_password(session, username, password) != 0)
    {
        fprintf(stderr, "Failed to authenticate\n");
        DissConnect();
        return false;
    }

    /* Open a channel */
    channel = libssh2_channel_open_session(session);
    if (channel == NULL)
    {
        fprintf(stderr, "Failed to open a new channel\n");
        DissConnect();
        return false;
    }
    this->channel = channel;

    /* Request a PTY */
    if (libssh2_channel_request_pty(channel, "xterm") != 0)
    {
        fprintf(stderr, "Failed to request a pty\n");
        DissConnect();
        return false;
    }

    /* Request a shell */
    if (libssh2_channel_shell(channel) != 0)
    {
        fprintf(stderr, "Failed to open a shell\n");
        DissConnect();
        return false;
    }

    libssh2_channel_set_blocking(channel, false);

    return true;
}

ssize_t SSH::Write(const char *buffer, int n)
{
    return libssh2_channel_write(channel, buffer, n);
}

ssize_t SSH::Read(char *buffer, int n)
{
    return libssh2_channel_read(channel, buffer, n);
}

int SSH::Resize(int width, int height)
{
    return libssh2_channel_request_pty_size(channel, width, height);
}


// websocket.h
#ifndef __WEBSOCKET_H_20220722__
#define __WEBSOCKET_H_20220722__

#include "global.h"

void RunWebsocketServer(); // 启动并运行websocket服务端
void WebSocketCheckClientAlive(); // 主动给客户端发心跳，保持其在线状态，踢掉超时的客户端

void RunEPollSockt();
#endif


// websocket.cpp
#include "SSH.h"

#include <websocketpp/config/asio_no_tls.hpp>
#include <websocketpp/server.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <json.hpp>

using namespace nlohmann;

#define EVENT_NUM 5

typedef websocketpp::server<websocketpp::config::asio> WebsocketServer;
typedef WebsocketServer::message_ptr message_ptr;

static map<string, string> config;
static WebsocketServer server;

// 标志唯一的客户端(client_ip_port变量)：固定的前缀+客户端IP+客户端PORT组成，如 [::ffff:1.119.166.13]:61662

// 每个客户端 -> 连接句柄
static map<string, websocketpp::connection_hdl> client_hdl_map;

// 客户端连接句柄，对应的是活跃时间戳
static map<string, time_t> client_time_map;

static map<string, SSH *> client_ssh_map;
static map<int, SSH *> sock_ssh_map;
static map<int, websocketpp::connection_hdl> sock_hdl_map;

boost::mutex map_mutex; // 互斥锁

int epfd = -1;

void AddSockToEpoll(int sock)
{
	struct epoll_event ev;
	ev.data.fd = sock;						   // 要监视的文件描述符，可以是任何打开的在/proc/pid/fd/目录下的fd
	ev.events = EPOLLIN;					   // 监听读状态同时设置LT模式
	epoll_ctl(epfd, EPOLL_CTL_ADD, sock, &ev); // 注册epoll事件
}

void DelSockFromEpoll(int sock)
{
	struct epoll_event ev;
	ev.data.fd = sock;						   // 要监视的文件描述符，可以是任何打开的在/proc/pid/fd/目录下的fd
	ev.events = EPOLLIN;					   // 监听读状态同时设置LT模式
	epoll_ctl(epfd, EPOLL_CTL_DEL, sock, &ev); // 移除epoll事件
}

static WebsocketServer::connection_ptr GetConFromHdl(websocketpp::connection_hdl hdl)
{
	try
	{
		return server.get_con_from_hdl(hdl);
	}
	catch (websocketpp::exception const &e)
	{
		cout << "GetConFromHdl failed: " << e.what() << endl;
		return NULL;
	}
}

bool OnValidate(WebsocketServer *server, websocketpp::connection_hdl hdl)
{
	WebsocketServer::connection_ptr con = GetConFromHdl(hdl);
	if (!con)
	{
		return false;
	}
	string client_ip_port = con->get_remote_endpoint();

	string key = "Sec-WebSocket-Protocol";
	string token = con->get_request_header(key);
	std::cout << key << ": " << token << std::endl;
	if (token != "shell")
	{
		return false;
	}

	map_mutex.lock();
	SSH *ssh = new SSH(config["sshhost"].c_str(), atoi(config["sshport"].c_str()), config["sshusername"].c_str(), config["sshpassword"].c_str());
	if (!ssh->Connect())
	{
		delete ssh;
		return false;
	}
	client_ssh_map[client_ip_port] = ssh;
	client_hdl_map[client_ip_port] = hdl;
	client_time_map[client_ip_port] = time(NULL);
	sock_ssh_map[ssh->Socket()] = ssh;
	sock_hdl_map[ssh->Socket()] = hdl;
	AddSockToEpoll(ssh->Socket());

	con->append_header(key, token); // 以后回复数据都要加这个头部信息

	cout << client_ip_port << " write to memory ok!" << endl;
	map_mutex.unlock();

	return true;
}

void SendMsgToClient(websocketpp::connection_hdl hdl, const string msg)
{
	string client_ip_port = "Unknown";
	try
	{
		WebsocketServer::connection_ptr con = server.get_con_from_hdl(hdl);
		client_ip_port = con->get_remote_endpoint();
		server.send(hdl, msg, websocketpp::frame::opcode::text);
	}
	catch (websocketpp::exception const &e)
	{
		std::cout << "send msg to " << client_ip_port << " failed because: "
				  << "(" << e.what() << ")" << std::endl;
	}
}

void RunEPollSockt()
{
	char buffer[4096];
	struct epoll_event events[EVENT_NUM];
	epfd = epoll_create(EVENT_NUM);
	while (1)
	{
		int nfds = epoll_wait(epfd, events, 5, -1);
		for (int i = 0; i < nfds; i++)
		{
			int fd = events[i].data.fd;
			SSH *ssh = sock_ssh_map[fd];
			websocketpp::connection_hdl hdl = sock_hdl_map[fd];
			string str;
			while (1)
			{
				memset(buffer, 0, sizeof buffer);
				if (ssh->Read(buffer, sizeof buffer - 1) > 0)
				{
					str += buffer;
				}
				else
				{
					break;
				}
			}
			if (!str.empty())
			{
				SendMsgToClient(hdl, str);
			}
		}
	}
}

void OnOpen(WebsocketServer *server, websocketpp::connection_hdl hdl)
{
	WebsocketServer::connection_ptr con = GetConFromHdl(hdl);
	if (!con)
	{
		return;
	}
	string client_ip_port = con->get_remote_endpoint();
	cout << "client connected: " << client_ip_port << endl;
	server->send(hdl, config["copyright"] + "\r\n", websocketpp::frame::opcode::text);
}

map<string, websocketpp::connection_hdl>::iterator EraseMemory(const string &client_ip_port)
{
	map<string, websocketpp::connection_hdl>::iterator iter = client_hdl_map.begin();
	if (client_ip_port == "Unknown" || client_ip_port.empty())
	{
		cout << client_ip_port << ", Cann't erase memory!" << endl;
		return iter;
	}
	iter = client_hdl_map.find(client_ip_port);
	if (iter != client_hdl_map.end())
	{
		cout << client_ip_port << " closed, erase memory for it..." << endl;
		iter = client_hdl_map.erase(iter);
		client_time_map.erase(client_ip_port);

		SSH *ssh = client_ssh_map[client_ip_port];
		if (ssh)
		{
			DelSockFromEpoll(ssh->Socket());
			sock_ssh_map.erase(ssh->Socket());
			sock_hdl_map.erase(ssh->Socket());
			client_ssh_map.erase(client_ip_port);
			delete ssh;
		}

		cout << client_ip_port << " erase memory success!" << endl;
	}
	else
	{
		cout << client_ip_port << " no need to erase memory!" << endl;
	}
	return iter;
}

void OnClose(WebsocketServer *server, websocketpp::connection_hdl hdl)
{
	WebsocketServer::connection_ptr con = GetConFromHdl(hdl);
	if (!con)
	{
		return;
	}
	map_mutex.lock();
	string client_ip_port = con->get_remote_endpoint();
	EraseMemory(client_ip_port);
	map_mutex.unlock();
}

void OnMessage(WebsocketServer *server, websocketpp::connection_hdl hdl, message_ptr data)
{
	WebsocketServer::connection_ptr con = GetConFromHdl(hdl);
	if (!con)
	{
		return;
	}
	string str = data->get_payload();
	json obj = json::parse(str, nullptr, false);
	if (obj.is_discarded())
	{
		cout << "Not valid msg: " << str << endl;
	}
	else
	{
		map_mutex.lock();
		string client_ip_port = con->get_remote_endpoint();
		SSH *ssh = client_ssh_map[client_ip_port];
		if (obj["Op"] == "stdin")
		{
			string msg = obj["Data"];
			cout << "receive msg from " << client_ip_port << ": " << msg << endl;
			ssh->Write(msg.c_str(), msg.size());
		}
		else
		{
			int width = obj["Cols"];
			int height = obj["Rows"];
			printf("%s resize pty width = %d height = %d\n", client_ip_port.c_str(), width, height);
			ssh->Resize(width, height);
		}
		map_mutex.unlock();
	}
}

// 如果客户端发来ping，可以更新活跃时间戳，并回复pong
bool OnPing(WebsocketServer *server, websocketpp::connection_hdl hdl, std::string payload)
{

	server->get_alog().write(websocketpp::log::alevel::app, payload);

	WebsocketServer::connection_ptr con = GetConFromHdl(hdl);
	if (!con)
	{
		return false;
	}

	map_mutex.lock();
	string client_ip_port = con->get_remote_endpoint();
	cout << "recv ping from " << client_ip_port << ": " << payload << endl;

	if (client_time_map.find(client_ip_port) != client_time_map.end())
	{
		client_time_map[client_ip_port] = time(NULL); // 客户端ping时更新时间戳
		try
		{
			server->pong(hdl, "pong"); // 客户端ping时回复pong
		}
		catch (websocketpp::exception const &e)
		{
			cout << "pong failed: " << e.what() << endl;
		}
	}
	map_mutex.unlock();
	return true;
}

// 服务器会定时发送ping给客户端，客户端会自动回复pong，回复时更新活跃时间戳
bool OnPong(WebsocketServer *server, websocketpp::connection_hdl hdl, std::string payload)
{
	server->get_alog().write(websocketpp::log::alevel::app, payload);

	WebsocketServer::connection_ptr con = GetConFromHdl(hdl);
	if (!con)
	{
		return false;
	}
	string client_ip_port = con->get_remote_endpoint();
	cout << "recv pong from " << client_ip_port << ": " << payload << endl;

	map_mutex.lock();
	if (client_time_map.find(client_ip_port) != client_time_map.end())
	{
		client_time_map[client_ip_port] = time(NULL); // 客户端回复pong时更新活跃时间戳
	}
	map_mutex.unlock();

	return true;
}

static void ReadConfigXml()
{
	config["port"] = "8880";
	using boost::property_tree::ptree;
	ptree pt;
	ptree root;
	string cfg_path = "config.xml";
	try
	{
		read_xml(cfg_path, pt);
		root = pt.get_child("root");
	}
	catch (std::exception &e)
	{
		std::cout << "Error: " << e.what() << endl;
		return;
	}
	std::string str = pt.get<string>("root.server.<xmlattr>.port");
	if (!str.empty())
	{
		config["port"] = str;
	}

	str = pt.get<string>("root.ssh.<xmlattr>.host");
	if (!str.empty())
	{
		config["sshhost"] = str;
	}
	str = pt.get<string>("root.ssh.<xmlattr>.port");
	if (!str.empty())
	{
		config["sshport"] = str;
	}
	str = pt.get<string>("root.ssh.<xmlattr>.username");
	if (!str.empty())
	{
		config["sshusername"] = str;
	}
	str = pt.get<string>("root.ssh.<xmlattr>.password");
	if (!str.empty())
	{
		config["sshpassword"] = str;
	}
	str = pt.get<string>("root.ssh.<xmlattr>.copyright");
	if (!str.empty())
	{
		config["copyright"] = str;
	}
}

void RunWebsocketServer()
{
	ReadConfigXml();

	using websocketpp::lib::bind;
	using websocketpp::lib::placeholders::_1;
	using websocketpp::lib::placeholders::_2;

	server.set_reuse_addr(true); // 设置套接字选项SO_REUSEADDR

	server.set_ping_handler(bind(&OnPing, &server, ::_1, ::_2));
	server.set_pong_handler(bind(&OnPong, &server, ::_1, ::_2));

	// Set logging settings
	// server.set_access_channels(websocketpp::log::alevel::all);
	server.clear_access_channels(websocketpp::log::alevel::all); // 不输出日志

	// Initialize ASIO
	server.init_asio();

	// Register our open handler
	server.set_open_handler(bind(&OnOpen, &server, ::_1));

	// Register our close handler
	server.set_close_handler(bind(&OnClose, &server, _1));

	// Register our message handler
	server.set_message_handler(bind(&OnMessage, &server, _1, _2));

	server.set_validate_handler(bind(&OnValidate, &server, ::_1));

	// Listen on port 2152
	unsigned short port = atoi(config["port"].c_str());
	try
	{
		server.listen(port);
		cout << "listen at port " << port << endl;

		// Start the server accept loop
		server.start_accept();

		// Start the ASIO io_service run loop
		server.run();
	}
	catch (websocketpp::exception const &e)
	{
		cout << "error: " << e.what() << endl;
		exit(-1);
	}
}

// 定时扫描所有客户端，断开超时未回复的客户端
void WebSocketCheckClientAlive()
{
	int timeout = 3;
	while (1)
	{
		sleep(timeout);
		map_mutex.lock();
		printf("client size = %d\n", client_hdl_map.size());
		for (map<string, websocketpp::connection_hdl>::iterator iter = client_hdl_map.begin(); iter != client_hdl_map.end();)
		{
			string client_ip_port = iter->first;
			websocketpp::connection_hdl hdl = iter->second;
			printf("check [%s] alive?\n", client_ip_port.c_str());

			WebsocketServer::connection_ptr pconn;
			try
			{
				pconn = server.get_con_from_hdl(hdl);
			}
			catch (websocketpp::exception const &e)
			{
				cout << "get_con_from_hdl failed: " << e.what() << endl;
				iter = EraseMemory(client_ip_port);
				continue;
			}
			iter++;

			time_t last_seconds = client_time_map[client_ip_port];
			time_t this_seconds = time(NULL);
			int escaped_seconds = this_seconds - last_seconds;
			int pass_seconds = this_seconds - last_seconds;
			if (pass_seconds > timeout * 2 + 2)
			{
				printf("%s last pong is %d sec ago, timeout! Close it now!\n", client_ip_port.c_str(), escaped_seconds);
				try
				{
					pconn->close(websocketpp::close::status::normal, "timeout");
				}
				catch (websocketpp::exception const &e)
				{
					cout << "close failed: " << e.what() << endl;
				}
			}
			else if (pass_seconds >= timeout)
			{
				printf("%s last pong is %d sec ago. Now ping it!\n", client_ip_port.c_str(), escaped_seconds);
				try
				{
					server.ping(hdl, "ping");
				}
				catch (websocketpp::exception const &e)
				{
					cout << "ping failed: " << e.what() << endl;
				}
			}
			else
			{
				printf("%s last pong is %d sec ago! No need to ping!\n", client_ip_port.c_str(), escaped_seconds);
			}
		}
		map_mutex.unlock();
	}
}


// main.cpp
/**
 * @file main.cpp
 * @author 丁华能
 * @brief 连接过来的websocket带token，根据token查session中的信息，根据信息关联客户端，订阅消息，收到数据后根据关联客户端进行发送。
 * @version 0.1
 * @date 2022-05-18
 * 
 * @copyright Copyright (c) 2022
 * 
 */

#include "websocket.h"

using namespace std;

void epoll_thread()
{
	RunEPollSockt();
}

void websocket_thread()
{
	RunWebsocketServer();
}

void init_daemon(void){
    pid_t pid;
    int i;
 
    pid = fork();
    if(pid < 0)
    {
        printf("Error Fork\n");
        exit(1);
    }
    else if(pid > 0)
    {
        exit(0);
    }
 
    setsid();
	
    // umask(0);

	//忽略SIGCHLD信号
    signal(SIGCHLD, SIG_IGN);
 
    for(i=0; i<3; close(i++));
	open("/dev/null", O_RDWR);
    open("/dev/null", O_RDWR);
    open("/dev/null", O_RDWR);
}

void ChangeDIRToCurrentApp(const char *argv0)
{
    string path(argv0);
    path = path.substr(0, path.find_last_of('/'));
    chdir(path.c_str());
}

int main(int argc, char **argv)
{
    ChangeDIRToCurrentApp(argv[0]);
    
	if (argc == 1)
	{
		init_daemon();
	}

	thread subscribe(epoll_thread);

	thread websocket(websocket_thread);

	WebSocketCheckClientAlive();

	subscribe.join();

	websocket.join();

	return 0;
}


<!-- config.xml -->
<?xml version="1.0" encoding="utf-8"?>
<root>
    <server port="92" />
    <ssh host="127.0.0.1" port="22" username="test" password="111111" copyright="版权所有&copy"/>
</root>

Makefile脚本内容如下：
.PHONY : clean

GCC = g++
ROOTDIR = …
INCLUDE = -I$(ROOTDIR)/lib/inc
LIB =
libs = -lboost_system -lpthread -lssh2
runlibs = -Wl,-rpath=.

src = $(wildcard *.cpp)
obj = $(patsubst %.cpp,%.o, $(src))

bin = sshserver
$(bin) : $(obj)
$(GCC) $(runlibs) $^ -o $@ $(LIB) $(libs)

$(obj): %.o : %.cpp
$(GCC) -c -g $(INCLUDE) $< -o $@

clean :
rm -f $(obj) $(bin)

websocketpp的下载地址：https://github.com/zaphoyd/websocketpp
boost的下载地址：https://www.boost.org/
libssh2下载地址：https://github.com/libssh2/libssh2

注意看main.cpp中支持参数部分，运行带任意参数就是调试模式，否则守护进程运行。

前端代码参考文章：https://blog.csdn.net/canlynetsky/article/details/125928915

-快乐的程序员-
关注
专栏目录
【QT+QGIS跨平台编译】019：【libSSH2+Qt跨平台编译】（一套代码、一套框架，跨平台编译）
LuckyHanMo的博客
01-22 1074
通过一套libSSH2代码和框架，实现libSSH2跨平台编译。 在Qt环境下，集成libSSH2库的头文件、库文件，构建跨平台编译的pro文件。 通过构建的一套配置工程，基于Qt Creator IDE，完成跨平台编译实践。 在Windows、Linux、MacOS等操作系统上进行测试，成功编译，形成的成果（头文件、库文件等）可在不同系统下调用或使用，从而更好地构建跨平台解决方案。 采用的是libSSH2 1.10.0版本。 读者可参考博客中的集成原理和pro文件，构建不同版本的libSSH2跨平台包。
QT+OSG/osgEarth编译之十三：libSSH2+Qt编译（一套代码、一套框架，跨平台编译，版本：libSSH2-1.10.0）
LuckyHanMo的博客
11-10 1064
通过一套libssh2代码和框架，实现libssh2的跨平台编译。 在Qt环境下，集成libssh2库的头文件、库文件，构建跨平台编译的pro文件。 通过构建的一套配置工程，基于Qt Creator IDE，完成跨平台编译实践。 在Windows、Linux、MacOS等操作系统上进行测试，成功编译，形成的成果（头文件、库文件等）可在不同系统下调用或使用，从而更好地构建跨平台解决方案。 采用的是libssh2-1.10.0版本。 读者可参考博客中的集成原理和pro文件，构建不同版本的libssh2跨平台包。
vue shell终端后右代码poc-web-xterm
04-20
poc-web-xterm vue shell终端后右代码poc-web-xterm 文章详情：https://blog.csdn.net/hezhenfei8/article/details/124291574
vue实现webshell
Ang-l
06-02 8531
Webshell “web”的含义是显然需要服务器开放web服务，“shell”的含义是取得对服务器某种程度上操作权限。webshell常常被称为通过网站端口对网站服务器的某种程度上操作的权限。 一方面，webshell被站长常常用于网站管理、服务器管理等等，根据FSO权限的不同，作用有在线编辑网页脚本、上传下载文件、查看数据库、执行任意程序命令等。 另一方面，被入侵者利用，从而达到控制网站服务器的目的。这些网页脚本常称为WEB脚本木马，比较流行的asp或php木马，也有基于.NET的脚本木马与JSP脚本木
推荐开源项目：libssh2 - SSH2协议库
最新发布
gitblog_00908的博客
08-08 348
推荐开源项目：libssh2 - SSH2协议库 libssh2the SSH library项目地址:https://gitcode.com/gh_mirrors/li/libssh2 项目介绍 libssh2是一个实现SSH2协议的开源库，它以修订版BSD许可证授权。该项目提供了一种在各种编程语言中安全地执行远程操作的方法，如文件传输、命令执行等。通过libssh2，开发者可以轻松集成SSH...
Golang+Vue2从零开始搭建K8S后台管理系统（6）——web终端实现pod shell
kingu_crimson的博客
11-29 1934
上一章通过http chunked 长连接实现了pod的日志读取和展现；本章将通过前端的xterm.js库以及websocket来实现pod终端在浏览器页面上的实现。至此，我们就完成了pod shell的实现。在下一章中，我们将在此基础上进一步实现node shell。其实原理是类似的，基本思路就是通过ssh开启一个会话，并同样以其构造实现io.Reader和io.Writer接口的结构体。
libssh2的简单应用
热门推荐
wyc6668205的专栏
06-26 3万+
首先，libssh2.lib的这个库一定要有（下载地址提供：http://download.csdn.net/detail/wyc6668205/5651661） 其次，介绍一下libssh2的官网：www.libssh2.org；虽然这个网站里面内容是全英文的，我想所有的计算机从事者都能看懂这里面写的内容，这里面提供了很多例子，比如FTP的，shell命令的等等，我在这里介绍一下shell命令
C++:websocketpp使用
huiguo_的博客
04-24 1542
WebSocket++（简称WebSocketpp）是一个C++编写的WebSocket协议实现库，它提供了一个易于使用的接口，用于在C++应用程序中实现WebSocket客户端和服务器功能。WebSocket++支持WebSocket协议的最新标准，具有高度灵活性和可扩展性，适用于各种C++项目，包括网络服务器、实时通信应用程序等。个人感受：WebSocketpp是一个成熟稳定的项目，相比于其他c++的websocket项目，更具有健全性。
libssh2+websocketpp+boost实现的web终端C++后台
07-22
用了boost做xml解析和互斥锁，websocketpp做websocket库，libssh2则是与sshd交互的库。程序采用多线程方式，有心跳监测，经过大量测试，运行相对很稳定的一段程序。 网上有不少nodejs版本的ssh终端后台，虽然也很好...
libcurl7.65.3+openssl1.1.1e+nghttp2-1.40.0+libssh2+libzip.rar
03-24
libcurl7.65.3+openssl1.1.1e+nghttp2-1.40.0+libssh2+libzip ，源码+linux下的成果物。 用于编译lincurl使其支持dict file ftp ftps gopher ...
OpenSource+libssh2-1.10.0-x86-64-vc143
05-14
《OpenSource libssh2-1.10.0在Visual Studio 2022环境下的应用与实践》 libssh2是一个开源的SSH2客户端库，它为开发者提供了实现SSH2协议所需的各种功能，包括安全的远程登录、文件传输、隧道创建等。版本1.10.0是...
websocketpp实例代码
11-29
WebSocketpp是一个支持websocket功能的库，C++语言，本身不需要搭建什么环境，只要新建的项目引入相关的库就行。本实例代码包含了服务器，CS客户端、web客户端代码。
WebSocket++编程1
m0_50055258的博客
02-17 1551
公共类型： #include <connection.hpp> Public Types typedefconnection< config > type 此连接的类型 Type of this connection. typedef lib::shared_ptr<type> ptr 指向此连接的共享指针的类型 Type of a shared pointer to this connectio...
websocketpp最简单的服务器
qianbo042311的博客
07-21 856
预定义 1 WEBSOCKETPP_CPP11_TYPE_TRAITS 2 ASIO_STANDALONE; 3 SCL_SECURE_NO_WARNINGS; A 不要使用太新的版本 B 不使用boost 就把ASIO_STANDALONE 预定义加上，使用boost库毕竟比较庞大。 set_access_channels 函数定义输出的日志，输出日志太多效率就低了，这个一定要知道。 #define _SCL_SECURE_NO_WARNINGS #define WEBSOCKETPP_CPP11_TYP
linux libssh2 实例
whatday的专栏
02-19 3004
以下是包含必备头文件 #include "libssh2_config.h" #include<libssh2.h> #include<libssh2_sftp.h> 以下为定义的静态子串常量 const char *keyfile1 = "~/.ssh/id_rsa.pub"; const char *keyfile2 = "~/.ssh/id_rsa"; ...
基于QT+Boost环境下的websocketpp客户端开发
elvia7的博客
07-21 829
最近工作中需要基于QT写一个websocket的客户端，因为服务器是用websocketpp做的，所以客户端也采用同一个框架，避免通讯中出现异常。如果使用websocketpp，必需先安装boost环境。整个开发环境版本：boost_1_80_0 + vs2017+QT5.12.8。
linux环境下使用websocketpp，c++语言开发
xuan196的博客
12-23 3457
主要参考网站： https://zhuanlan.zhihu.com/p/59925926 环境：ubuntu16.04 依赖：boost，websocket 安装boost boost下载官网： https://www.boost.org/users/history/version_1_75_0.html 我下载的是版本是：boost_1_75_0.tar.bz2 https://dl.bintray.com/boostorg/release/1.75.0/source/boost_1_75_0.tar.
C++学习：使用libssh2实现交互式shell的ssh2，linux和windows通用
追风筝的人的专栏
04-05 2万+
使用ssh2实现shell自动化测试，实际工作中遇到非常多。各种语言都有相应的库可以使用。比如，c/c++语言可以使用libssh2；python可以使用paramkio库等。但这些库网上的帮助，都不是很全，都比较浅显。shell自动化，最基本的三个需求，一个是适合多重类型的操作系统；二是要能够支持交互式shell，比如使用sudo执行时，需要输入密码；三是读数据时要非阻塞的。
使用websocketpp编写websocket的服务端程序
adsd1218的博客
04-11 578
webscoketpp是一个基于boost库的websocket实现，实现的相对完善一些。主页地址：http://www.zaphoyd.com/websocketpp。 因为做项目需要用到，所以简单做了下分析，下面是关于如何编写server的介绍： 1. 自定义一个server_handler类，继承自websocketpp::server...
qt libssh2
08-28
Qt是一个跨平台的C++应用程序开发框架，它提供了丰富的工具和库来简化应用程序的开发。其中，libssh2是一个用于SSH通信的开源库。它提供了一些功能，比如建立SSH连接、执行远程命令、传输文件等。在Qt中使用libssh2可以方便地实现与远程服务器的通信。通过包含相应的头文件和链接库，你可以在Qt项目中使用libssh2的功能。在上述引用中的示例代码中，包含了libssh2的头文件，初始化了libssh2，并使用了libssh2的版本信息。同时，示例代码还展示了如何在Qt项目中使用libssh2的方式。所以，qt libssh2指的是在Qt项目中使用libssh2库来实现与远程服务器通信的方式。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [C/C++编程：libssh2学习（win10 + qt_creator+ qmake + vcpkg）](https://blog.csdn.net/zhizhengguan/article/details/112892367)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* [QT+OSG/osgEarth编译之十三：libSSH2+Qt编译（一套代码、一套框架，跨平台编译，版本：libSSH2-1.10.0）](https://blog.csdn.net/LuckyHanMo/article/details/127782635)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值