P2P TELNET
一 缘起
几年前做一个嵌入式的Linux平台上的一个控制和监测的项目。因为施工后，还有很大的可能需要对现场设备进行管理维护、以及应用软件的升级修改操作，而实际设备在安装后的网络环境非常复杂，有可能是多重NAT，也有可能采用的2G,3G或者4G网络。并且设备的安装在地域上的跨度非常大，维护工程师在远程无法访问设备，也就造成无法完成上述任务。
当时意识到如果有一个能够像telnet,ssh一样的P2P的软件，这个问题就可以迎刃迎刃而解了。但是由于工作的问题，想到这个东西了却一直没有动手去考虑实现。最近抽出时间简单的实现一个telnet
二 原理
远程无法访问设备的最根本的在于通讯无法进行。如果能够解决通讯问题则可以实现对应的功能，这个就类似QQ的远程桌面。
在网上找到有两个协议非常适合这样的一个任务，这两个协议分别是XMPP和SIP。因此软件的实现就基于这两个协议来实现。
将软件分成服务端和客户端，服务端是被控制的一端，客户端是控制的一端。现在XMPP和SIP的客户端软件非常多，都可以拿来作为客户端使用。因此软件的开发是开发服务端软件
2.1 XMPP协议。
XMPP是一种基于标准通用标记语言的子集XML的协议，它继承了在XML环境中灵活的发展性。因此，基于XMPP的应用具有超强的可扩展性。经过扩展以后的XMPP可以通过发送扩展的信息来处理用户的需求，以及在XMPP的顶端建立如内容发布系统和基于地址的服务等应用程序。而且，XMPP包含了针对服务器端的软件协议，使之能与另一个进行通话，这使得开发者更容易建立客户应用程序或给一个配好系统添加功能。
XMPP协议严格来讲并不是一个P2P的协议，XMPP的数据通讯需要有一个中间服务器进行转发，所以这是一个中继通讯的协议。考虑到即使有人使用这样的一个方式进行处理，远程设备的管理，因为管理的操作本身并发性不集中。所以XMPP协议完全可以使用，不用考虑它的中继特性了。
XMPP有很多开源的项目，其中gloox是一个用C++实现的XMPP协议客户端库，接口良好，文档也全面，并且整个库编译后也很小，大概1MB吧。完全可以用于嵌入场合。并且这个库是一个跨平台的库，也就意味着可以用于windows，Linux等，笔者也成功的将其移植到arm a8上。
2.2 SIP协议。
SIP（Session Initiation Protocol，会话初始协议）是由IETF（Internet Engineering Task Force，因特网工程任务组）制定的多媒体通信协议。它是一个基于文本的应用层控制协议，用于创建、修改和释放一个或多个参与者的会话。广泛应用于CS（Circuit Switched，电路交换）、NGN（Next Generation Network，下一代网络）以及IMS（IP Multimedia Subsystem，IP多媒体子系统）的网络中，可以支持并应用于语音、视频、数据等多媒体业务，同时也可以应用于Presence（呈现）、Instant Message（即时消息）等特色业务。可以说，有IP网络的地方就有SIP协议的存在。
SIP协议在会话发起之后可以选择采用UDP 的点到点通讯。因此SIP协议在使用的时候可以是一个真正意义上的点到点通讯。
pjsip是一个非常优秀的SIP协议开源库，这是一个用C/C++实现的库。整个库非常小完全可以用于嵌入式系统。并且这个库可以用于windows，Linux多个平台。
三 设计
程序的主要流程是：
四 然后就是干货，主要代码。如果有需要的整体代码包的可以联系我
4.1 执行器
#include "exec_linux.h"
#include <stdio.h>
#if defined( __LINUX__ )
CExecLinux::CExecLinux( const std::string& usr , const std::string& str , CP2Pbackend& msger) :
CP2PExec( usr, str, msger )
{
p_cmd_stdin = proc.GetOutputStream();
p_cmd_stdout = proc.GetInputStream();
p_cmd_stderr = proc.GetErrorStream();
}
////////////////////////////////////////////////////////////////////////////////
CExecLinux::~CExecLinux()
{
{
boost::mutex::scoped_lock l( m_mutex );
m_is_run = false;
}
my_sleep( 500 );
}
////////////////////////////////////////////////////////////////////////////////
size_t CExecLinux::exec_read( void* buff , size_t len , int& err )
{
if( buff == NULL ) return -4;
if( len > CP2PExec::READ_BUFF_SIZE ) len = CP2PExec::READ_BUFF_SIZE;
size_t ret = 0;
//读标准错误输出通道
ret = read( p_cmd_stderr , buff , len );
if( ret != (size_t)-1 ) err = 0;
else err = -2;
//读标准输出通道
if( err != -2 ){
if( len + ret > CP2PExec::READ_BUFF_SIZE ) len = CP2PExec::READ_BUFF_SIZE - ret;
ret = read( p_cmd_stdout , (char*)(buff + ret ), len );
if( ret != (size_t)-1 ) err = 0;
else err = 0;
}
else{
ret = read( p_cmd_stdout , buff , len );
if( ret != (size_t)-1 ) err = 0;
else err = 0;
}
return ret;
}
////////////////////////////////////////////////////////////////////////////////
size_t CExecLinux::exec_write( const void* buff , size_t len , int &err )
{
size_t ret = write( p_cmd_stdin , buff , len );
if( ret == (size_t)-1) err = -1;
else err = 0;
return ret;
}
////////////////////////////////////////////////////////////////////////////////
void CExecLinux::Start()
{
m_is_run = true;
my_sleep( 1000 );
boost::thread thd( boost::bind( &CExecLinux::do_run , this ));
}
////////////////////////////////////////////////////////////////////////////////
size_t CExecLinux::exec_write( const std::string& data )
{
int err = 0;
size_t ret = 0;
std::string cmd = data;
#if defined __DEBUG__
std::cout << "last cmd = " << m_last_cmd << std::endl;
#endif
if( data == "stop"){
if(m_last_cmd.empty() == false ){
cmd = "killall -9 " + m_last_cmd;
system( cmd.c_str() );
m_last_cmd.clear();
}
ret = 0;
}
else{
cmd = cmd + "\n";
size_t pos = data.find_first_of(' ');
if( pos != std::string::npos )
m_last_cmd = data.substr( 0, pos );
else
m_last_cmd = data;
ret = exec_write( cmd.c_str() , strlen( cmd.c_str() ) , err);
}
return ret;
}
#endif
4.2 通讯控制器
#include "inc.h"
#if USE_GLOOX_LIB == 1
#if defined(__WXMSW__)
#include <wx/wx.h>
#include <wx/process.h>
#endif // defined
#include <gloox/disco.h>
#include "CBackendGloox.h"
#if defined( _WIN32 ) || defined(__GNUWIN32__ ) || defined( __WXMSW__ )
#include "exec_win32.h"
#elif defined( __LINUX__ )
#include "exec_linux.h"
#endif // defined
#include <stdio.h>
CBackendGloox *globe_p2p_telnetd = NULL;
CBackendGloox::CBackendGloox(const std::string& svr , const std::string& usr , const std::string& passwd)
:CP2Pbackend( svr , usr , passwd )
{
do_connect(svr , usr , passwd );
// array_exec.clear();
}
CBackendGloox::~CBackendGloox()
{
}
void CBackendGloox::Re( const std::string& msg )
{
m_session->send( "\n" + msg );
}
void CBackendGloox::do_start_shell( const std::string& user )
{
#if defined(__WXMSW__ ) || defined(_WIN32) || defined( __GNUWIN32__ )
CExecWin32 *p_exec = NULL;
p_exec = new CExecWin32( user , "cmd.exe" , *this );
*p_exec << "telnet 127.0.0.1\r\n";
#elif defined( __LINUX__ )
CExecLinux *p_exec = NULL;
p_exec = new CExecLinux( user , "/bin/bash" , *this );
#endif
if( p_exec == NULL ) return;
p_exec->SetNotify( boost::bind( &CBackendGloox :: Re , this , _1 ));
p_exec->Start();
make_new_connection( p_exec );
}
void CBackendGloox::do_connect( const std::string& svr , const std::string& usr , const std::string& passwd )
{
#if defined __LINUX__
std::string sys = "lINUX";
#elif defined _WIN32
std::string sys = "Windows";
#endif // defined
std::stringstream ss;
ss << usr << "@" << svr ;
std::string str_jid = ss.str();
JID jid( ss.str() );
j = new gloox::Client( jid , passwd );
if( j == NULL ) throw j;
j->registerConnectionListener( this );
j->registerMessageSessionHandler( this , 0 );
j->disco()->setVersion( "p2ptelnetd", GLOOX_VERSION, "test" );
j->disco()->setIdentity( "client", "bot" );
j->disco()->addFeature( XMLNS_CHAT_STATES );
StringList ca;
ca.push_back( "/data/cacert.crt" );
j->setCACerts( ca );
j->logInstance().registerLogHandler( LogLevelDebug, LogAreaAll, this );
if( j->connect( ) ){//使用阻塞方式启动客户端
ConnectionError ce = ConnNoError;
while( ce == ConnNoError ) {
ce = j->recv();
}
printf( "ce: %d\n", ce );
}
delete( j );
}
//////////////////////////////////////////////////////////////////////////////////////
void CBackendGloox::handleMessage( const Message& msg, MessageSession * /*session*/ )
{
std::string user = msg.from().full();
//将远程发过来的数据发送给执行器，让执行器执行
//完成后执行器会自动调用反馈处理
//if( msg.body().empty() == true ) return;
process_msg( user , msg.body() );
}
void CBackendGloox::handleMessageEvent( const JID& from, MessageEventType event )
{
// printf( "received event: %d from: %s\n", event, from.full().c_str() );
}
void CBackendGloox::onDisconnect( ConnectionError e )
{
printf( "message_test: disconnected: %d\n", e );
if( e == ConnAuthenticationFailed )
printf( "auth failed. reason: %d\n", j->authError() );
}
void CBackendGloox::onConnect()
{
#if defined( __WXDEBUG__ ) || defined( __DEBUG__ )
std::cout << "connected server " << std::endl;
#endif // defined
}
bool CBackendGloox::onTLSConnect( const CertInfo& info )
{
time_t from( info.date_from );
time_t to( info.date_to );
printf( "status: %d\nissuer: %s\npeer: %s\nprotocol: %s\nmac: %s\ncipher: %s\ncompression: %s\n"
"from: %s\nto: %s\n",
info.status, info.issuer.c_str(), info.server.c_str(),
info.protocol.c_str(), info.mac.c_str(), info.cipher.c_str(),
info.compression.c_str(), ctime( &from ), ctime( &to ) );
return true;
}
void CBackendGloox::handleChatState( const JID& from, ChatStateType state )
{
printf( "received state: %d from: %s\n", state, from.full().c_str() );
}
void CBackendGloox::handleLog( LogLevel level, LogArea area, const std::string& message )
{
//printf("log: level: %d, area: %d, %s\n", level, area, message.c_str() );
}
void CBackendGloox::handleMessageSession( MessageSession *session )
{
j->disposeMessageSession( m_session );
m_session = session;
m_session->registerMessageHandler( this );
m_messageEventFilter = new MessageEventFilter( m_session );
m_messageEventFilter->registerMessageEventHandler( this );
m_chatStateFilter = new ChatStateFilter( m_session );
m_chatStateFilter->registerChatStateHandler( this );
}
void CBackendGloox :: disconnect()
{
j->disconnect();
}
#endif
转载于:https://my.oschina.net/u/3071588/blog/1542017