github
/
teleport
mirror of https://github.com/tp4a/teleport
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

.

pull/105/head
Apex Liu 2017-08-21 05:22:35 +08:00
parent 73d51a2563
commit 191d007678
21 changed files with 2132 additions and 2273 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
client/tp_assist/ts_const.h
View File

@ -1,11 +1,12 @@
#ifndef __TS_CONST_H__ #ifndef __TS_CONST_H__
#define __TS_CONST_H__ #define __TS_CONST_H__
#define TS_WEB_URL L"http://teleport.eomsoft.net/" #define TS_WEB_URL L"http://teleport.eomsoft.net/"
#define TS_BBS_URL L"http://bbs.eomsoft.net/" #define TS_BBS_URL L"http://bbs.eomsoft.net/"
#define TS_TRAY_MSG L"Teleport助手正常工作中" #define TS_TRAY_MSG L"Teleport助手正常工作中"
#define TS_HTTP_RPC_PORT 50022 #define TS_HTTP_RPC_PORT 50022
#define TS_HTTP_RPC_HOST "127.0.0.1" //#define TS_HTTP_RPC_HOST "127.0.0.1"
#define TS_HTTP_RPC_HOST "localhost"
#endif // __TS_CONST_H__
#endif // __TS_CONST_H__

3181
client/tp_assist/ts_http_rpc.cpp
View File

File diff suppressed because it is too large Load Diff

94
server/tp_core/common/base_env.cpp
View File

@ -1,47 +1,47 @@
#include "base_env.h" #include "base_env.h"
TppEnvBase::TppEnvBase() TppEnvBase::TppEnvBase()
{} {}
TppEnvBase::~TppEnvBase() TppEnvBase::~TppEnvBase()
{} {}
bool TppEnvBase::init(TPP_INIT_ARGS* args) bool TppEnvBase::init(TPP_INIT_ARGS* args)
{ {
if (NULL == args) if (NULL == args)
{ {
EXLOGE("invalid init args(1).\n"); EXLOGE("invalid init args(1).\n");
return false; return false;
} }
EXLOG_USE_LOGGER(args->logger); EXLOG_USE_LOGGER(args->logger);
exec_path = args->exec_path; exec_path = args->exec_path;
etc_path = args->etc_path; etc_path = args->etc_path;
replay_path = args->replay_path; replay_path = args->replay_path;
take_session = args->func_take_session; get_session = args->func_get_connect_info;
free_session = args->func_free_session; free_session = args->func_free_connect_info;
session_begin = args->func_session_begin; session_begin = args->func_session_begin;
session_end = args->func_session_end; session_end = args->func_session_end;
if (NULL == take_session || NULL == free_session || NULL == session_begin || NULL == session_end) if (NULL == get_session || NULL == free_session || NULL == session_begin || NULL == session_end)
{ {
EXLOGE("invalid init args(2).\n"); EXLOGE("invalid init args(2).\n");
return false; return false;
} }
if (NULL == args->cfg) if (NULL == args->cfg)
{ {
EXLOGE("invalid init args(3).\n"); EXLOGE("invalid init args(3).\n");
return false; return false;
} }
if (!_on_init(args)) if (!_on_init(args))
{ {
EXLOGE("invalid init args(4).\n"); EXLOGE("invalid init args(4).\n");
return false; return false;
} }
return true; return true;
} }

56
server/tp_core/common/base_env.h
View File

@ -1,28 +1,28 @@
#ifndef __TS_BASE_ENV_H__ #ifndef __TS_BASE_ENV_H__
#define __TS_BASE_ENV_H__ #define __TS_BASE_ENV_H__
#include "protocol_interface.h" #include "protocol_interface.h"
class TppEnvBase class TppEnvBase
{ {
public: public:
TppEnvBase(); TppEnvBase();
virtual ~TppEnvBase(); virtual ~TppEnvBase();
bool init(TPP_INIT_ARGS* args); bool init(TPP_INIT_ARGS* args);
public: public:
ex_wstr exec_path; ex_wstr exec_path;
ex_wstr etc_path; // 配置文件、SSH服务器的私钥文件的存放路径 ex_wstr etc_path; // 配置文件、SSH服务器的私钥文件的存放路径
ex_wstr replay_path; ex_wstr replay_path;
TPP_TAKE_SESSION_FUNC take_session; TPP_GET_CONNNECT_INFO_FUNC get_session;
TPP_FREE_SESSION_FUNC free_session; TPP_FREE_CONNECT_INFO_FUNC free_session;
TPP_SESSION_BEGIN_FUNC session_begin; TPP_SESSION_BEGIN_FUNC session_begin;
TPP_SESSION_END_FUNC session_end; TPP_SESSION_END_FUNC session_end;
protected: protected:
virtual bool _on_init(TPP_INIT_ARGS* args) = 0; virtual bool _on_init(TPP_INIT_ARGS* args) = 0;
}; };
#endif // __TS_BASE_ENV_H__ #endif // __TS_BASE_ENV_H__

2
server/tp_core/common/base_record.cpp
View File

@ -16,7 +16,7 @@ TppRecBase::~TppRecBase()
{ {
} }
void TppRecBase::begin(const wchar_t* base_path, const wchar_t* base_fname, int record_id, const TPP_SESSION_INFO* info) void TppRecBase::begin(const wchar_t* base_path, const wchar_t* base_fname, int record_id, const TPP_CONNECT_INFO* info)
{ {
m_start_time = ex_get_tick_count(); m_start_time = ex_get_tick_count();

173
server/tp_core/common/base_record.h
View File

@ -1,76 +1,97 @@
#ifndef __TS_BASE_RECORD_H__ #ifndef __TS_BASE_RECORD_H__
#define __TS_BASE_RECORD_H__ #define __TS_BASE_RECORD_H__
#include "base_env.h" #include "base_env.h"
#include "ts_membuf.h" #include "ts_membuf.h"
#include "protocol_interface.h" #include "protocol_interface.h"
#include <ex.h> #include <ex.h>
#define MAX_SIZE_PER_FILE 4194304 // 4M = 1024*1024*4 #define MAX_SIZE_PER_FILE 4194304 // 4M = 1024*1024*4
#pragma pack(push,1) #pragma pack(push,1)
// 录像文件头 // 录像文件头(随着录像数据写入，会改变的部分)
typedef struct TS_RECORD_HEADER typedef struct TS_RECORD_HEADER_INFO
{ {
ex_u32 magic; // "TPPR" 标志 TelePort Protocol Record ex_u32 packages; // 总包数
ex_u16 ver; // 录像文件版本，目前为2 ex_u32 time_ms; // 总耗时（毫秒）
ex_u16 protocol; // 协议：1=RDP, 2=SSH, 3=Telnet ex_u32 file_size; // 数据总大小（不包括文件头）
ex_u64 timestamp; // 本次录像的起始时间（UTC时间戳） }TS_RECORD_HEADER_INFO;
ex_u32 packages; // 总包数
ex_u32 time_ms; // 总耗时（毫秒） // 录像文件头(固定不变部分)
ex_u16 width; // 初始屏幕尺寸：宽 typedef struct TS_RECORD_HEADER_BASIC
ex_u16 height; // 初始屏幕尺寸：高 {
ex_u16 file_count; // 数据文件总数 ex_u32 magic; // "TPPR" 标志 TelePort Protocol Record
ex_u32 file_size; // 所有数据文件的总大小（不包括每个数据文件的头，即4字节的每文件大小） ex_u16 ver; // 录像文件版本，目前为3
char account[16]; // teleport账号
char username[16]; // 远程主机用户名 ex_u16 protocol_type; // 协议：1=RDP, 2=SSH, 3=Telnet
char ip[18]; ex_u16 protocol_sub_type; // 子协议：100=RDP, 200=SSH, 201=SFTP, 300=Telnet
ex_u16 port; ex_u64 timestamp; // 本次录像的起始时间（UTC时间戳）
ex_u16 width; // 初始屏幕尺寸：宽
// RDP专有 ex_u16 height; // 初始屏幕尺寸：高
ex_u8 rdp_security; // 0 = RDP, 1 = TLS char user_name[32]; // teleport账号
char account_name[32]; // 远程主机用户名
ex_u8 reserve[128 - 4 - 2 - 2 - 8 - 4 - 4 - 2 - 2 - 2 - 4 - 16 - 16 - 18 - 2 - 1]; // 保留
}TS_RECORD_HEADER; char real_remote_host_ip[40]; // 远程主机IP
char remote_host_ip[40]; // 远程主机IP
// 一个数据包的头 ex_u16 remote_host_port; // 远程主机端口
typedef struct TS_RECORD_PKG
{ char client_ip[40]; // 客户端IP
ex_u8 type; // 包的数据类型
ex_u32 size; // 这个包的总大小（不含包头） // RDP专有
ex_u32 time_ms; // 这个包距起始时间的时间差（毫秒，意味着一个连接不能持续超过49天） ex_u8 rdp_security; // 0 = RDP, 1 = TLS
ex_u8 reserve[3]; // 保留
}TS_RECORD_PKG; ex_u8 reserve[256 - 4 - 2 - 2 - 2 - 8 - 2 - 2 - 32 - 32 - 40 - 2 - 40 - 40 - 1 - 12]; // 保留，其中，最后12B是为header-info留出的空间
}TS_RECORD_HEADER_BASIC;
#pragma pack(pop) #define ts_record_header_basic_size sizeof(TS_RECORD_HEADER_BASIC)
class TppRecBase typedef struct TS_RECORD_HEADER
{ {
public: TS_RECORD_HEADER_INFO info;
TppRecBase(); TS_RECORD_HEADER_BASIC basic;
virtual ~TppRecBase(); }TS_RECORD_HEADER;
void begin(const wchar_t* base_path, const wchar_t* base_fname, int record_id, const TPP_SESSION_INFO* info); // header部分（header-info + header-basic） = 256B
void end(void); #define ts_record_header_size sizeof(TS_RECORD_HEADER)
virtual void record(ex_u8 type, const ex_u8* data, size_t size) = 0;
// 一个数据包的头
protected: typedef struct TS_RECORD_PKG
virtual void _on_begin(const TPP_SESSION_INFO* info) = 0; {
virtual void _on_end(void) = 0; ex_u8 type; // 包的数据类型
ex_u32 size; // 这个包的总大小（不含包头）
protected: ex_u32 time_ms; // 这个包距起始时间的时间差（毫秒，意味着一个连接不能持续超过49天）
int m_protocol; ex_u8 reserve[3]; // 保留
}TS_RECORD_PKG;
ex_wstr m_base_path; // 录像文件基础路径，例如 /usr/local/eom/teleport/data/replay/ssh/123，数字编号是内部附加的，作为本次会话录像文件的目录名称
ex_wstr m_base_fname; // 录像文件的文件名，不含扩展名部分，内部会以此为基础合成文件全名，并将录像文件存放在 m_base_path 指向的目录中 #pragma pack(pop)
ex_u64 m_start_time; class TppRecBase
ex_u64 m_last_time; {
public:
MemBuffer m_cache; TppRecBase();
}; virtual ~TppRecBase();
#endif // __TS_BASE_RECORD_H__ void begin(const wchar_t* base_path, const wchar_t* base_fname, int record_id, const TPP_CONNECT_INFO* info);
void end(void);
virtual void record(ex_u8 type, const ex_u8* data, size_t size) = 0;
protected:
virtual void _on_begin(const TPP_CONNECT_INFO* info) = 0;
virtual void _on_end(void) = 0;
protected:
int m_protocol;
ex_wstr m_base_path; // 录像文件基础路径，例如 /usr/local/eom/teleport/data/replay/ssh/123，数字编号是内部附加的，作为本次会话录像文件的目录名称
ex_wstr m_base_fname; // 录像文件的文件名，不含扩展名部分，内部会以此为基础合成文件全名，并将录像文件存放在 m_base_path 指向的目录中
ex_u64 m_start_time;
ex_u64 m_last_time;
MemBuffer m_cache;
};
#endif // __TS_BASE_RECORD_H__

148
server/tp_core/common/protocol_interface.h
View File

@ -1,73 +1,75 @@
#ifndef __TP_PROTOCOL_INTERFACE_H__ #ifndef __TP_PROTOCOL_INTERFACE_H__
#define __TP_PROTOCOL_INTERFACE_H__ #define __TP_PROTOCOL_INTERFACE_H__
#include "ts_const.h" #include "ts_const.h"
#include <ex.h> #include <ex.h>
#ifdef EX_OS_WIN32 #ifdef EX_OS_WIN32
# ifdef TPP_EXPORTS # ifdef TPP_EXPORTS
# define TPP_API __declspec(dllexport) # define TPP_API __declspec(dllexport)
# else # else
# define TPP_API __declspec(dllimport) # define TPP_API __declspec(dllimport)
# endif # endif
#else #else
# define TPP_API # define TPP_API
#endif #endif
typedef struct TPP_SESSION_INFO typedef struct TPP_CONNECT_INFO
{ {
char* sid; char* sid;
char* account_name; // 申请本次连接的用户名 char* user_name; // 申请本次连接的用户名
char* host_ip; char* real_remote_host_ip; // 真正的远程主机IP（如果是直接连接模式，则与remote_host_ip相同）
char* user_name; char* remote_host_ip; // 要连接的远程主机的IP（如果是端口映射模式，则为路由主机的IP）
char* user_auth; char* account_name; // 远程主机的账号
char* user_param; char* account_secret; // 远程主机账号的密码（或者私钥）
int host_port; char* user_param;
int protocol; int remote_host_port; // 要连接的远程主机的端口（如果是端口映射模式，则为路由主机的端口）
int auth_id; int protocol_type;
int auth_mode; int protocol_sub_type;
int sys_type; //int auth_id;
int ref_count; // 这个session可以被take_session()多少次 int auth_type;
ex_u64 ticket_start; int sys_type;
}TPP_SESSION_INFO; int ref_count; // 这个连接信息的引用计数，如果创建的连接信息从来未被使用，则超过60秒后自动销毁
ex_u64 ticket_start; // 此连接信息的创建时间（用于超时未使用就销毁的功能）
typedef TPP_SESSION_INFO* (*TPP_TAKE_SESSION_FUNC)(const char* sid); }TPP_CONNECT_INFO;
typedef void(*TPP_FREE_SESSION_FUNC)(TPP_SESSION_INFO* info);
typedef bool(*TPP_SESSION_BEGIN_FUNC)(const TPP_SESSION_INFO* info, int* db_id); typedef TPP_CONNECT_INFO* (*TPP_GET_CONNNECT_INFO_FUNC)(const char* sid);
typedef bool(*TPP_SESSION_END_FUNC)(int db_id, int ret); typedef void(*TPP_FREE_CONNECT_INFO_FUNC)(TPP_CONNECT_INFO* info);
typedef bool(*TPP_SESSION_BEGIN_FUNC)(const TPP_CONNECT_INFO* info, int* db_id);
typedef bool(*TPP_SESSION_END_FUNC)(const char* sid, int db_id, int ret);
typedef struct TPP_INIT_ARGS
{
ExLogger* logger; typedef struct TPP_INIT_ARGS
ex_wstr exec_path; {
ex_wstr etc_path; ExLogger* logger;
ex_wstr replay_path; ex_wstr exec_path;
ExIniFile* cfg; ex_wstr etc_path;
ex_wstr replay_path;
TPP_TAKE_SESSION_FUNC func_take_session; ExIniFile* cfg;
TPP_FREE_SESSION_FUNC func_free_session;
TPP_SESSION_BEGIN_FUNC func_session_begin; TPP_GET_CONNNECT_INFO_FUNC func_get_connect_info;
TPP_SESSION_END_FUNC func_session_end; TPP_FREE_CONNECT_INFO_FUNC func_free_connect_info;
}TPP_INIT_ARGS; TPP_SESSION_BEGIN_FUNC func_session_begin;
TPP_SESSION_END_FUNC func_session_end;
}TPP_INIT_ARGS;
#ifdef __cplusplus
extern "C"
{ #ifdef __cplusplus
#endif extern "C"
{
TPP_API ex_rv tpp_init(TPP_INIT_ARGS* init_args); #endif
TPP_API ex_rv tpp_start(void);
TPP_API ex_rv tpp_stop(void); TPP_API ex_rv tpp_init(TPP_INIT_ARGS* init_args);
TPP_API ex_rv tpp_start(void);
#ifdef __cplusplus TPP_API ex_rv tpp_stop(void);
}
#endif #ifdef __cplusplus
}
typedef ex_rv (*TPP_INIT_FUNC)(TPP_INIT_ARGS* init_args); #endif
typedef ex_rv (*TPP_START_FUNC)(void);
typedef ex_rv (*TPP_STOP_FUNC)(void); typedef ex_rv (*TPP_INIT_FUNC)(TPP_INIT_ARGS* init_args);
typedef ex_rv (*TPP_START_FUNC)(void);
#endif // __TP_PROTOCOL_INTERFACE_H__ typedef ex_rv (*TPP_STOP_FUNC)(void);
#endif // __TP_PROTOCOL_INTERFACE_H__

20
server/tp_core/common/ts_const.h
View File

@ -3,18 +3,18 @@
//#include "ts_types.h" //#include "ts_types.h"
// #define TS_RDP_PROXY_PORT 3389 #define TS_RDP_PROXY_PORT 52089
// #define TS_RDP_PROXY_HOST "0.0.0.0" #define TS_RDP_PROXY_HOST "0.0.0.0"
//
// #define TS_SSH_PROXY_PORT 22 #define TS_SSH_PROXY_PORT 52189
// #define TS_SSH_PROXY_HOST "0.0.0.0" #define TS_SSH_PROXY_HOST "0.0.0.0"
//
// #define TS_TELNET_PROXY_PORT 23 #define TS_TELNET_PROXY_PORT 52389
// #define TS_TELNET_PROXY_HOST "0.0.0.0" #define TS_TELNET_PROXY_HOST "0.0.0.0"
#define TS_HTTP_RPC_PORT 52080 #define TS_HTTP_RPC_PORT 52080
#define TS_HTTP_RPC_HOST "127.0.0.1" //#define TS_HTTP_RPC_HOST "127.0.0.1"
//#define TS_HTTP_RPC_HOST "0.0.0.0" #define TS_HTTP_RPC_HOST "localhost"
#define TS_RDP_PROTOCOL_RDP 0 #define TS_RDP_PROTOCOL_RDP 0

4
server/tp_core/core/ts_env.cpp
View File

@ -128,8 +128,8 @@ bool TsEnv::init(bool load_config)
else else
{ {
ex_wstr2astr(tmp, rpc_bind_ip); ex_wstr2astr(tmp, rpc_bind_ip);
if (rpc_bind_ip == "localhost") //if (rpc_bind_ip == "localhost")
rpc_bind_ip = "127.0.0.1"; // rpc_bind_ip = "127.0.0.1";
} }
if (!ps->GetInt(L"bind-port", rpc_bind_port)) if (!ps->GetInt(L"bind-port", rpc_bind_port))

178
server/tp_core/core/ts_http_rpc.cpp
View File

@ -647,181 +647,3 @@ void TsHttpRpc::_rpc_func_enc(const Json::Value& json_param, ex_astr& buf)
jr_data["c"] = cipher_text; jr_data["c"] = cipher_text;
_create_json_ret(buf, TPE_OK, jr_data); _create_json_ret(buf, TPE_OK, jr_data);
} }
#if 0
void TsHttpRpc::_rpc_func_get_auth_id(const ex_astr& func_args, ex_astr& buf)
{
// 获取所有的或者指定主机的认证ID
// 入参: {"host":"host-ip-address"} 或者 无
// 示例: {"host":"123.45.67.89"}
// host: 要查询的主机的IP地址
// 返回：
// data域为一个列表，其中每一个元素为一组键值对。
//
// 错误返回： {"code":1234}
Json::Reader jreader;
Json::Value jsRoot;
AuthInfo2Vec ret;
if (0 == func_args.length())
{
if (!g_db.get_auth_id_list_by_all(ret))
{
_create_json_ret(buf, TSR_DATA_LEN_ZERO);
return;
}
}
else
{
if (!jreader.parse(func_args.c_str(), jsRoot))
{
_create_json_ret(buf, TSR_INVALID_JSON_FORMAT);
return;
}
if (jsRoot.isArray())
{
_create_json_ret(buf, TSR_INVALID_JSON_PARAM);
return;
}
ex_astr host_ip;
if (jsRoot["host"].isNull() || !jsRoot["host"].isString())
{
_create_json_ret(buf, TSR_INVALID_JSON_PARAM);
return;
}
host_ip = jsRoot["host"].asCString();
if (host_ip.length() == 0)
{
_create_json_ret(buf, TSR_INVALID_JSON_PARAM);
return;
}
if (!g_db.get_auth_id_list_by_ip(host_ip, ret))
{
_create_json_ret(buf, TSR_DATA_LEN_ZERO);
return;
}
}
if (ret.size() == 0)
{
_create_json_ret(buf, TSR_DATA_LEN_ZERO);
return;
}
//EXLOGV("encrypt: [%s]=>[%s]\n", plain_text.c_str(), cipher_text.c_str());
Json::Value jr_root;
jr_root["code"] = TSR_OK;
int i = 0;
AuthInfo2Vec::iterator it = ret.begin();
for (; it != ret.end(); ++it)
{
jr_root["data"][i]["auth_id"] = (*it).auth_id;
jr_root["data"][i]["host_id"] = (*it).host_id;
jr_root["data"][i]["host_ip"] = (*it).host_ip;
jr_root["data"][i]["protocol"] = (*it).pro_type;
jr_root["data"][i]["auth_mode"] = (*it).auth_mode;
jr_root["data"][i]["host_status"] = (*it).host_lock;
i++;
}
_create_json_ret(buf, jr_root);
}
void TsHttpRpc::_rpc_func_get_auth_info(const ex_astr& func_args, ex_astr& buf)
{
// 获取所有的或者指定主机的认证INFO
// 入参: {"host":"host-ip-address"} 或者 无
// 示例: {"host":"123.45.67.89"}
// host: 要查询的主机的IP地址
// 返回：
// data域为一个列表，其中每一个元素为一组键值对。
//
// 错误返回： {"code":1234}
Json::Reader jreader;
Json::Value jsRoot;
AuthInfo3Vec ret;
if (0 == func_args.length())
{
if (!g_db.get_auth_info_list_by_all(ret))
{
_create_json_ret(buf, TSR_DATA_LEN_ZERO);
return;
}
}
else
{
if (!jreader.parse(func_args.c_str(), jsRoot))
{
_create_json_ret(buf, TSR_INVALID_JSON_FORMAT);
return;
}
if (jsRoot.isArray())
{
_create_json_ret(buf, TSR_INVALID_JSON_PARAM);
return;
}
ex_astr host_ip;
if (jsRoot["host"].isNull() || !jsRoot["host"].isString())
{
_create_json_ret(buf, TSR_INVALID_JSON_PARAM);
return;
}
host_ip = jsRoot["host"].asCString();
if (host_ip.length() == 0)
{
_create_json_ret(buf, TSR_INVALID_JSON_PARAM);
return;
}
if (!g_db.get_auth_info_list_by_ip(host_ip, ret))
{
_create_json_ret(buf, TSR_DATA_LEN_ZERO);
return;
}
}
if (ret.size() == 0)
{
_create_json_ret(buf, TSR_DATA_LEN_ZERO);
return;
}
//EXLOGV("encrypt: [%s]=>[%s]\n", plain_text.c_str(), cipher_text.c_str());
Json::Value jr_root;
jr_root["code"] = TSR_OK;
int i = 0;
AuthInfo3Vec::iterator it = ret.begin();
for (; it != ret.end(); ++it)
{
jr_root["data"][i]["host_id"] = (*it).host_id;
jr_root["data"][i]["host_ip"] = (*it).host_ip;
jr_root["data"][i]["username"] = (*it).host_user_name;
jr_root["data"][i]["password"] = (*it).host_user_pwd;
jr_root["data"][i]["auth_mode"] = (*it).auth_mode;
jr_root["data"][i]["key_id"] = (*it).cert_id;
jr_root["data"][i]["key_pri"] = (*it).cert_pri;
jr_root["data"][i]["key_pub"] = (*it).cert_pub;
i++;
}
_create_json_ret(buf, jr_root);
}
#endif

37
server/tp_core/core/ts_main.cpp
View File

@ -9,32 +9,34 @@
bool g_exit_flag = false; bool g_exit_flag = false;
TPP_SESSION_INFO* tpp_take_session(const char* sid) TPP_CONNECT_INFO* tpp_get_session(const char* sid)
{ {
TS_SESSION_INFO sinfo; TS_SESSION_INFO sinfo;
bool ret = g_session_mgr.take_session(sid, sinfo); bool ret = g_session_mgr.take_session(sid, sinfo);
if (!ret) if (!ret)
return NULL; return NULL;
TPP_SESSION_INFO* info = (TPP_SESSION_INFO*)calloc(1, sizeof(TPP_SESSION_INFO)); TPP_CONNECT_INFO* info = (TPP_CONNECT_INFO*)calloc(1, sizeof(TPP_CONNECT_INFO));
info->sid = (char*)calloc(1, sinfo.sid.length() + 1); info->sid = (char*)calloc(1, sinfo.sid.length() + 1);
ex_strcpy(info->sid, sinfo.sid.length() + 1, sinfo.sid.c_str()); ex_strcpy(info->sid, sinfo.sid.length() + 1, sinfo.sid.c_str());
info->account_name = (char*)calloc(1, sinfo.account_name.length() + 1); info->account_name = (char*)calloc(1, sinfo.account_name.length() + 1);
ex_strcpy(info->account_name, sinfo.account_name.length() + 1, sinfo.account_name.c_str()); ex_strcpy(info->account_name, sinfo.account_name.length() + 1, sinfo.account_name.c_str());
info->host_ip = (char*)calloc(1, sinfo.host_ip.length() + 1); info->real_remote_host_ip = (char*)calloc(1, sinfo.host_ip.length() + 1);
ex_strcpy(info->host_ip, sinfo.host_ip.length() + 1, sinfo.host_ip.c_str()); ex_strcpy(info->real_remote_host_ip, sinfo.host_ip.length() + 1, sinfo.host_ip.c_str());
info->remote_host_ip = (char*)calloc(1, sinfo.host_ip.length() + 1);
ex_strcpy(info->remote_host_ip, sinfo.host_ip.length() + 1, sinfo.host_ip.c_str());
info->user_name = (char*)calloc(1, sinfo.user_name.length() + 1); info->user_name = (char*)calloc(1, sinfo.user_name.length() + 1);
ex_strcpy(info->user_name, sinfo.user_name.length() + 1, sinfo.user_name.c_str()); ex_strcpy(info->user_name, sinfo.user_name.length() + 1, sinfo.user_name.c_str());
info->user_auth = (char*)calloc(1, sinfo.user_auth.length() + 1); info->account_secret = (char*)calloc(1, sinfo.user_auth.length() + 1);
ex_strcpy(info->user_auth, sinfo.user_auth.length() + 1, sinfo.user_auth.c_str()); ex_strcpy(info->account_secret, sinfo.user_auth.length() + 1, sinfo.user_auth.c_str());
info->user_param = (char*)calloc(1, sinfo.user_param.length() + 1); info->user_param = (char*)calloc(1, sinfo.user_param.length() + 1);
ex_strcpy(info->user_param, sinfo.user_param.length() + 1, sinfo.user_param.c_str()); ex_strcpy(info->user_param, sinfo.user_param.length() + 1, sinfo.user_param.c_str());
info->auth_id = sinfo.auth_id; //info->auth_id = sinfo.auth_id;
info->host_port = sinfo.host_port; info->remote_host_port = sinfo.host_port;
info->protocol = sinfo.protocol; info->protocol_type = sinfo.protocol;
info->auth_mode = sinfo.auth_mode; info->auth_type= sinfo.auth_mode;
info->sys_type = sinfo.sys_type; info->sys_type = sinfo.sys_type;
info->ref_count = sinfo.ref_count; info->ref_count = sinfo.ref_count;
info->ticket_start = sinfo.ticket_start; info->ticket_start = sinfo.ticket_start;
@ -42,21 +44,22 @@ TPP_SESSION_INFO* tpp_take_session(const char* sid)
return info; return info;
} }
void tpp_free_session(TPP_SESSION_INFO* info) void tpp_free_session(TPP_CONNECT_INFO* info)
{ {
if (NULL == info) if (NULL == info)
return; return;
free(info->sid); free(info->sid);
free(info->account_name);
free(info->host_ip);
free(info->user_name); free(info->user_name);
free(info->user_auth); free(info->real_remote_host_ip);
free(info->remote_host_ip);
free(info->account_name);
free(info->account_secret);
free(info->user_param); free(info->user_param);
free(info); free(info);
} }
bool tpp_session_begin(const TPP_SESSION_INFO* info, int* db_id) bool tpp_session_begin(const TPP_CONNECT_INFO* info, int* db_id)
{ {
if (NULL == info || NULL == db_id) if (NULL == info || NULL == db_id)
return false; return false;
@ -79,9 +82,9 @@ bool tpp_session_begin(const TPP_SESSION_INFO* info, int* db_id)
return ts_web_rpc_session_begin(sinfo, *db_id); return ts_web_rpc_session_begin(sinfo, *db_id);
} }
bool tpp_session_end(int db_id, int ret) bool tpp_session_end(const char* sid, int db_id, int ret)
{ {
return ts_web_rpc_session_end(db_id, ret); return ts_web_rpc_session_end(sid, db_id, ret);
} }
typedef struct TPP_LIB typedef struct TPP_LIB

14
server/tp_core/core/ts_session.cpp
View File

@ -105,7 +105,7 @@ ex_rv TsSessionManager::request_session(
return EXRV_FAILED; return EXRV_FAILED;
} }
bool TsSessionManager::take_session(const ex_astr& sid, TS_SESSION_INFO& info) bool TsSessionManager::get_session(const ex_astr& sid, TS_SESSION_INFO& info)
{ {
ExThreadSmartLock locker(m_lock); ExThreadSmartLock locker(m_lock);
@ -129,12 +129,12 @@ bool TsSessionManager::take_session(const ex_astr& sid, TS_SESSION_INFO& info)
info.ref_count = it->second->ref_count; info.ref_count = it->second->ref_count;
info.ticket_start = it->second->ticket_start; info.ticket_start = it->second->ticket_start;
it->second->ref_count--; it->second->ref_count++;
if (it->second->ref_count <= 0) // if (it->second->ref_count <= 0)
{ // {
delete it->second; // delete it->second;
m_sessions.erase(it); // m_sessions.erase(it);
} // }
return true; return true;
} }

146
server/tp_core/core/ts_session.h
View File

@ -1,73 +1,73 @@
#ifndef __TS_SESSION_H__ #ifndef __TS_SESSION_H__
#define __TS_SESSION_H__ #define __TS_SESSION_H__
#include "../common/ts_const.h" #include "../common/ts_const.h"
#include "../common/protocol_interface.h" #include "../common/protocol_interface.h"
#include <ex.h> #include <ex.h>
typedef struct TS_SESSION_INFO typedef struct TS_SESSION_INFO
{ {
ex_astr sid; ex_astr sid;
ex_astr account_name; // 申请本次连接的用户名 ex_astr account_name; // 申请本次连接的用户名
int auth_id; //int auth_id;
ex_astr host_ip; ex_astr host_ip;
int host_port; int host_port;
int protocol; int protocol;
ex_astr user_name; ex_astr user_name;
ex_astr user_auth; ex_astr user_auth;
ex_astr user_param; ex_astr user_param;
int auth_mode; int auth_mode;
int sys_type; int sys_type;
int ref_count; // 这个session可以被take_session()多少次 int ref_count;
ex_u64 ticket_start; ex_u64 ticket_start;
}TS_SESSION_INFO; }TS_SESSION_INFO;
typedef std::map<ex_astr, TS_SESSION_INFO*> ts_sessiones; typedef std::map<ex_astr, TS_SESSION_INFO*> ts_sessiones;
class TsSessionManager : public ExThreadBase class TsSessionManager : public ExThreadBase
{ {
public: public:
TsSessionManager(); TsSessionManager();
~TsSessionManager(); ~TsSessionManager();
// 申请一个session-id。 // 申请一个session-id。
ex_rv request_session( ex_rv request_session(
ex_astr& sid, // 返回的session-id ex_astr& sid, // 返回的session-id
ex_astr account_name, ex_astr account_name,
int auth_id, int auth_id,
const ex_astr& host_ip, // 要连接的主机IP const ex_astr& host_ip, // 要连接的主机IP
int host_port, // 要连接的主机端口 int host_port, // 要连接的主机端口
int sys_type, // 主机操作系统类型 int sys_type, // 主机操作系统类型
int protocol, // 要使用的协议，1=rdp, 2=ssh int protocol, // 要使用的协议，1=rdp, 2=ssh
const ex_astr& user_name, // 认证信息中的用户名 const ex_astr& user_name, // 认证信息中的用户名
const ex_astr& user_auth, // 认证信息，密码或私钥 const ex_astr& user_auth, // 认证信息，密码或私钥
const ex_astr& user_param, // const ex_astr& user_param, //
int auth_mode // 认证方式，1=password，2=private-key int auth_mode // 认证方式，1=password，2=private-key
); );
// 根据sid得到session信息，然后被查询的sid被从session管理器列表中移除 // 根据sid得到session信息
bool take_session(const ex_astr& sid, TS_SESSION_INFO& info); bool get_session(const ex_astr& sid, TS_SESSION_INFO& info);
protected: protected:
// 线程循环 // 线程循环
void _thread_loop(void); void _thread_loop(void);
// 设置停止标志，让线程能够正常结束 // 设置停止标志，让线程能够正常结束
void _set_stop_flag(void); void _set_stop_flag(void);
private: private:
bool _add_session(ex_astr& sid, TS_SESSION_INFO* info); bool _add_session(ex_astr& sid, TS_SESSION_INFO* info);
void _gen_session_id(ex_astr& sid, const TS_SESSION_INFO* info, int len); void _gen_session_id(ex_astr& sid, const TS_SESSION_INFO* info, int len);
void _check_sessions(void); void _check_sessions(void);
private: private:
ExThreadLock m_lock; ExThreadLock m_lock;
ts_sessiones m_sessions; ts_sessiones m_sessions;
}; };
extern TsSessionManager g_session_mgr; extern TsSessionManager g_session_mgr;
#endif // __TS_SESSION_H__ #endif // __TS_SESSION_H__

5
server/tp_core/core/ts_web_rpc.cpp
View File

@ -144,8 +144,11 @@ bool ts_web_rpc_session_begin(TS_SESSION_INFO& info, int& record_id)
} }
//session ½áÊø //session ½áÊø
bool ts_web_rpc_session_end(int record_id, int ret_code) bool ts_web_rpc_session_end(const char* sid, int record_id, int ret_code)
{ {
// TODO: 对指定的sid相关的会话的引用计数减一（但减到0时销毁）
Json::FastWriter json_writer; Json::FastWriter json_writer;
Json::Value jreq; Json::Value jreq;
jreq["method"] = "session_end"; jreq["method"] = "session_end";

2
server/tp_core/core/ts_web_rpc.h
View File

@ -14,7 +14,7 @@ int ts_web_rpc_get_conn_info(int conn_id, Json::Value& jret);
// 记录会话的开始 // 记录会话的开始
bool ts_web_rpc_session_begin(TS_SESSION_INFO& info, int& record_id); bool ts_web_rpc_session_begin(TS_SESSION_INFO& info, int& record_id);
//session 结束 //session 结束
bool ts_web_rpc_session_end(int id, int ret_code); bool ts_web_rpc_session_end(const char* sid, int id, int ret_code);
#endif // __TS_WEB_RPC_H__ #endif // __TS_WEB_RPC_H__

35
server/tp_core/protocol/ssh/ssh_recorder.cpp
View File

@ -1,4 +1,5 @@
#include "ssh_recorder.h" #include "ssh_recorder.h"
#include <teleport_const.h>
static ex_u8 TPP_RECORD_MAGIC[4] = { 'T', 'P', 'P', 'R' }; static ex_u8 TPP_RECORD_MAGIC[4] = { 'T', 'P', 'P', 'R' };
@ -7,9 +8,8 @@ TppSshRec::TppSshRec()
m_cmd_cache.reserve(MAX_SIZE_PER_FILE); m_cmd_cache.reserve(MAX_SIZE_PER_FILE);
memset(&m_head, 0, sizeof(TS_RECORD_HEADER)); memset(&m_head, 0, sizeof(TS_RECORD_HEADER));
memcpy((ex_u8*)(&m_head.magic), TPP_RECORD_MAGIC, sizeof(ex_u32)); memcpy((ex_u8*)(&m_head.basic.magic), TPP_RECORD_MAGIC, sizeof(ex_u32));
m_head.ver = 0x02; m_head.basic.ver = 0x02;
m_head.protocol = TS_PROXY_PROTOCOL_SSH;
} }
TppSshRec::~TppSshRec() TppSshRec::~TppSshRec()
@ -17,19 +17,22 @@ TppSshRec::~TppSshRec()
end(); end();
} }
void TppSshRec::_on_begin(const TPP_SESSION_INFO* info) void TppSshRec::_on_begin(const TPP_CONNECT_INFO* info)
{ {
if (NULL == info) if (NULL == info)
return; return;
m_head.timestamp = time(NULL); m_head.basic.timestamp = time(NULL);
m_head.port = info->host_port; m_head.basic.protocol_type = info->protocol_type;
m_head.basic.protocol_sub_type = info->protocol_sub_type;
m_head.basic.remote_host_port = info->remote_host_port;
// memcpy(m_head.account, info.account_name.c_str(), info.account_name.length() > 15 ? 15 : info.account_name.length()); // memcpy(m_head.account, info.account_name.c_str(), info.account_name.length() > 15 ? 15 : info.account_name.length());
// memcpy(m_head.username, info.user_name.c_str(), info.user_name.length() > 15 ? 15 : info.user_name.length()); // memcpy(m_head.username, info.user_name.c_str(), info.user_name.length() > 15 ? 15 : info.user_name.length());
// memcpy(m_head.ip, info.host_ip.c_str(), info.host_ip.length() > 17 ? 17 : info.host_ip.length()); // memcpy(m_head.ip, info.host_ip.c_str(), info.host_ip.length() > 17 ? 17 : info.host_ip.length());
memcpy(m_head.account, info->account_name, strlen(info->account_name) > 15 ? 15 : strlen(info->account_name)); memcpy(m_head.basic.account_name, info->account_name, strlen(info->account_name) >= 31 ? 31 : strlen(info->account_name));
memcpy(m_head.username, info->user_name, strlen(info->user_name) > 15 ? 15 : strlen(info->user_name)); memcpy(m_head.basic.user_name, info->user_name, strlen(info->user_name) >= 31 ? 31 : strlen(info->user_name));
memcpy(m_head.ip, info->host_ip, strlen(info->host_ip) > 17 ? 17 : strlen(info->host_ip)); memcpy(m_head.basic.real_remote_host_ip, info->real_remote_host_ip, strlen(info->real_remote_host_ip) >= 39 ? 39 : strlen(info->real_remote_host_ip));
memcpy(m_head.basic.remote_host_ip, info->remote_host_ip, strlen(info->remote_host_ip) >= 39 ? 39 : strlen(info->remote_host_ip));
} }
void TppSshRec::_on_end(void) void TppSshRec::_on_end(void)
@ -42,7 +45,7 @@ void TppSshRec::_on_end(void)
// ¸üÐÂÍ·ÐÅÏ¢ // ¸üÐÂÍ·ÐÅÏ¢
//m_head.timestamp = m_start_time; //m_head.timestamp = m_start_time;
m_head.time_ms = (ex_u32)(m_last_time - m_start_time); m_head.info.time_ms = (ex_u32)(m_last_time - m_start_time);
ex_wstr fname = m_base_path; ex_wstr fname = m_base_path;
ex_path_join(fname, false, m_base_fname.c_str(), NULL); ex_path_join(fname, false, m_base_fname.c_str(), NULL);
@ -64,7 +67,7 @@ void TppSshRec::record(ex_u8 type, const ex_u8* data, size_t size)
{ {
if (data == NULL || 0 == size) if (data == NULL || 0 == size)
return; return;
m_head.packages++; m_head.info.packages++;
if (sizeof(TS_RECORD_PKG) + size + m_cache.size() > m_cache.buffer_size()) if (sizeof(TS_RECORD_PKG) + size + m_cache.size() > m_cache.buffer_size())
_save_to_data_file(); _save_to_data_file();
@ -86,8 +89,8 @@ void TppSshRec::record(ex_u8 type, const ex_u8* data, size_t size)
void TppSshRec::record_win_size_startup(int width, int height) void TppSshRec::record_win_size_startup(int width, int height)
{ {
m_head.width = width; m_head.basic.width = width;
m_head.height = height; m_head.basic.height = height;
} }
void TppSshRec::record_win_size_change(int width, int height) void TppSshRec::record_win_size_change(int width, int height)
@ -127,7 +130,7 @@ void TppSshRec::record_command(const ex_astr cmd)
bool TppSshRec::_save_to_data_file(void) bool TppSshRec::_save_to_data_file(void)
{ {
wchar_t _str_file_id[24] = { 0 }; wchar_t _str_file_id[24] = { 0 };
ex_wcsformat(_str_file_id, 24, L".%03d", m_head.file_count); ex_wcsformat(_str_file_id, 24, L".%03d", 0);// m_head.file_count);
ex_wstr fname = m_base_path; ex_wstr fname = m_base_path;
ex_path_join(fname, false, m_base_fname.c_str(), NULL); ex_path_join(fname, false, m_base_fname.c_str(), NULL);
@ -148,8 +151,8 @@ bool TppSshRec::_save_to_data_file(void)
fflush(f); fflush(f);
fclose(f); fclose(f);
m_head.file_count++; //m_head.file_count++;
m_head.file_size += m_cache.size(); //m_head.file_size += m_cache.size();
m_cache.empty(); m_cache.empty();
return true; return true;

144
server/tp_core/protocol/ssh/ssh_recorder.h
View File

@ -1,72 +1,72 @@
#ifndef __TPP_SSH_RECORDER_H__ #ifndef __TPP_SSH_RECORDER_H__
#define __TPP_SSH_RECORDER_H__ #define __TPP_SSH_RECORDER_H__
#include "../../common/base_record.h" #include "../../common/base_record.h"
#define TS_RECORD_TYPE_SSH_TERM_SIZE 0x01 // 终端大小（行数与列数） #define TS_RECORD_TYPE_SSH_TERM_SIZE 0x01 // 终端大小（行数与列数）
#define TS_RECORD_TYPE_SSH_DATA 0x02 // 用于展示的数据内容 #define TS_RECORD_TYPE_SSH_DATA 0x02 // 用于展示的数据内容
#pragma pack(push,1) #pragma pack(push,1)
// 录像文件头 // 录像文件头
// typedef struct TS_RECORD_HEADER // typedef struct TS_RECORD_HEADER
// { // {
// ex_u32 magic; // "TPPR" 标志 TelePort Protocol Record // ex_u32 magic; // "TPPR" 标志 TelePort Protocol Record
// ex_u64 timestamp; // 本次录像的起始时间（UTC时间戳） // ex_u64 timestamp; // 本次录像的起始时间（UTC时间戳）
// ex_u32 packages; // 总包数 // ex_u32 packages; // 总包数
// ex_u32 time_ms; // 总耗时（毫秒） // ex_u32 time_ms; // 总耗时（毫秒）
// ex_u16 width; // 初始屏幕尺寸：宽 // ex_u16 width; // 初始屏幕尺寸：宽
// ex_u16 height; // 初始屏幕尺寸：高 // ex_u16 height; // 初始屏幕尺寸：高
// ex_u16 file_count; // 数据文件总数 // ex_u16 file_count; // 数据文件总数
// ex_u32 file_size; // 所有数据文件的总大小（不包括每个数据文件的头，即4字节的每文件大小） // ex_u32 file_size; // 所有数据文件的总大小（不包括每个数据文件的头，即4字节的每文件大小）
// char account[16]; // teleport账号 // char account[16]; // teleport账号
// char username[16]; // 远程主机用户名 // char username[16]; // 远程主机用户名
// char ip[18]; // char ip[18];
// ex_u16 port; // ex_u16 port;
// //
// ex_u8 reserve[128 - 4 - 8 - 4 - 4 - 2 - 2 - 2 - 4 - 16 - 16 - 18 - 2]; // 保留 // ex_u8 reserve[128 - 4 - 8 - 4 - 4 - 2 - 2 - 2 - 4 - 16 - 16 - 18 - 2]; // 保留
// }TS_RECORD_HEADER; // }TS_RECORD_HEADER;
// //
// // 一个数据包的头 // // 一个数据包的头
// typedef struct TS_RECORD_PKG // typedef struct TS_RECORD_PKG
// { // {
// ex_u8 type; // 包的数据类型 // ex_u8 type; // 包的数据类型
// ex_u32 size; // 这个包的总大小（不含包头） // ex_u32 size; // 这个包的总大小（不含包头）
// ex_u32 time_ms; // 这个包距起始时间的时间差（毫秒，意味着一个连接不能持续超过49天） // ex_u32 time_ms; // 这个包距起始时间的时间差（毫秒，意味着一个连接不能持续超过49天）
// ex_u8 reserve[3]; // 保留 // ex_u8 reserve[3]; // 保留
// }TS_RECORD_PKG; // }TS_RECORD_PKG;
// 记录窗口大小改变的数据包 // 记录窗口大小改变的数据包
typedef struct TS_RECORD_WIN_SIZE typedef struct TS_RECORD_WIN_SIZE
{ {
ex_u16 width; ex_u16 width;
ex_u16 height; ex_u16 height;
}TS_RECORD_WIN_SIZE; }TS_RECORD_WIN_SIZE;
#pragma pack(pop) #pragma pack(pop)
class TppSshRec : public TppRecBase class TppSshRec : public TppRecBase
{ {
public: public:
TppSshRec(); TppSshRec();
virtual ~TppSshRec(); virtual ~TppSshRec();
void record(ex_u8 type, const ex_u8* data, size_t size); void record(ex_u8 type, const ex_u8* data, size_t size);
void record_win_size_startup(int width, int height); void record_win_size_startup(int width, int height);
void record_win_size_change(int width, int height); void record_win_size_change(int width, int height);
void record_command(const ex_astr cmd); void record_command(const ex_astr cmd);
protected: protected:
void _on_begin(const TPP_SESSION_INFO* info); void _on_begin(const TPP_CONNECT_INFO* info);
void _on_end(void); void _on_end(void);
bool _save_to_data_file(void); bool _save_to_data_file(void);
bool _save_to_cmd_file(void); bool _save_to_cmd_file(void);
protected: protected:
TS_RECORD_HEADER m_head; TS_RECORD_HEADER m_head;
MemBuffer m_cmd_cache; MemBuffer m_cmd_cache;
}; };
#endif // __TPP_SSH_RECORDER_H__ #endif // __TPP_SSH_RECORDER_H__

119
server/tp_core/protocol/ssh/ssh_session.cpp
View File

@ -3,6 +3,7 @@
#include "tpp_env.h" #include "tpp_env.h"
#include <algorithm> #include <algorithm>
#include <teleport_const.h>
SshSession::SshSession(SshProxy *proxy, ssh_session sess_client) : SshSession::SshSession(SshProxy *proxy, ssh_session sess_client) :
ExThreadBase("ssh-session-thread"), ExThreadBase("ssh-session-thread"),
@ -10,10 +11,10 @@ SshSession::SshSession(SshProxy *proxy, ssh_session sess_client) :
m_cli_session(sess_client), m_cli_session(sess_client),
m_srv_session(NULL) m_srv_session(NULL)
{ {
m_retcode = SESS_STAT_RUNNING; m_retcode = TP_SESS_STAT_RUNNING;
m_db_id = 0; m_db_id = 0;
m_auth_mode = TS_AUTH_MODE_PASSWORD; m_auth_type = TP_AUTH_TYPE_PASSWORD;
m_is_first_server_data = true; m_is_first_server_data = true;
m_is_sftp = false; m_is_sftp = false;
@ -71,7 +72,7 @@ void SshSession::_set_stop_flag(void) {
} }
} }
bool SshSession::_on_session_begin(const TPP_SESSION_INFO* info) bool SshSession::_on_session_begin(const TPP_CONNECT_INFO* info)
{ {
if (!g_ssh_env.session_begin(info, &m_db_id)) if (!g_ssh_env.session_begin(info, &m_db_id))
{ {
@ -91,10 +92,10 @@ bool SshSession::_on_session_end(void)
EXLOGD("[ssh] session ret-code: %d\n", m_retcode); EXLOGD("[ssh] session ret-code: %d\n", m_retcode);
// 如果会话过程中没有发生错误，则将其状态改为结束，否则记录下错误值 // 如果会话过程中没有发生错误，则将其状态改为结束，否则记录下错误值
if (m_retcode == SESS_STAT_RUNNING) if (m_retcode == TP_SESS_STAT_RUNNING)
m_retcode = SESS_STAT_END; m_retcode = TP_SESS_STAT_END;
g_ssh_env.session_end(m_db_id, m_retcode); g_ssh_env.session_end(m_sid.c_str(), m_db_id, m_retcode);
} }
return true; return true;
@ -227,43 +228,43 @@ int SshSession::_on_auth_password_request(ssh_session session, const char *user,
EXLOGV("[ssh] authenticating, session-id: %s\n", _this->m_sid.c_str()); EXLOGV("[ssh] authenticating, session-id: %s\n", _this->m_sid.c_str());
int protocol = 0; int protocol = 0;
TPP_SESSION_INFO* sess_info = g_ssh_env.take_session(_this->m_sid.c_str()); TPP_CONNECT_INFO* sess_info = g_ssh_env.get_session(_this->m_sid.c_str());
if (NULL == sess_info) { if (NULL == sess_info) {
EXLOGW("[ssh] try to get login-info from ssh-sftp-session.\n"); // EXLOGW("[ssh] try to get login-info from ssh-sftp-session.\n");
// 尝试从sftp连接记录中获取连接信息（一个ssh会话如果成为sftp会话，内部会将连接信息记录下来备用） // 尝试从sftp连接记录中获取连接信息（一个ssh会话如果成为sftp会话，内部会将连接信息记录下来备用）
TS_SFTP_SESSION_INFO sftp_info; // TS_SFTP_SESSION_INFO sftp_info;
if (!_this->m_proxy->get_sftp_session_info(_this->m_sid, sftp_info)) { // if (!_this->m_proxy->get_sftp_session_info(_this->m_sid, sftp_info)) {
EXLOGE("[ssh] no such session: %s\n", _this->m_sid.c_str()); EXLOGE("[ssh] no such session: %s\n", _this->m_sid.c_str());
_this->m_have_error = true; _this->m_have_error = true;
_this->m_retcode = SESS_STAT_ERR_AUTH_DENIED; _this->m_retcode = TP_SESS_STAT_ERR_AUTH_DENIED;
return SSH_AUTH_DENIED; return SSH_AUTH_DENIED;
} // }
//
_this->m_server_ip = sftp_info.host_ip; // _this->m_remote_host_ip = sftp_info.host_ip;
_this->m_server_port = sftp_info.host_port; // _this->m_remote_host_port = sftp_info.host_port;
_this->m_auth_mode = sftp_info.auth_mode; // _this->m_auth_type = sftp_info.auth_mode;
_this->m_user_name = sftp_info.user_name; // _this->m_account_name = sftp_info.user_name;
_this->m_user_auth = sftp_info.user_auth; // _this->m_account_secret = sftp_info.user_auth;
protocol = TS_PROXY_PROTOCOL_SSH; // protocol = TP_PROTOCOL_TYPE_SSH;
//
// 因为是从sftp会话得来的登录数据，因此限制本会话只能用于sftp，不允许再使用shell了。 // // 因为是从sftp会话得来的登录数据，因此限制本会话只能用于sftp，不允许再使用shell了。
_this->_enter_sftp_mode(); // _this->_enter_sftp_mode();
} }
else { else {
_this->m_server_ip = sess_info->host_ip; _this->m_remote_host_ip = sess_info->remote_host_ip;
_this->m_server_port = sess_info->host_port; _this->m_remote_host_port = sess_info->remote_host_port;
_this->m_auth_mode = sess_info->auth_mode; _this->m_auth_type = sess_info->auth_type;
_this->m_user_name = sess_info->user_name; _this->m_account_name = sess_info->account_name;
_this->m_user_auth = sess_info->user_auth; _this->m_account_secret = sess_info->account_secret;
protocol = sess_info->protocol; protocol = sess_info->protocol_type;
} }
if (protocol != TS_PROXY_PROTOCOL_SSH) { if (protocol != TP_PROTOCOL_TYPE_SSH) {
g_ssh_env.free_session(sess_info); g_ssh_env.free_session(sess_info);
EXLOGE("[ssh] session '%s' is not for SSH.\n", _this->m_sid.c_str()); EXLOGE("[ssh] session '%s' is not for SSH.\n", _this->m_sid.c_str());
_this->m_have_error = true; _this->m_have_error = true;
_this->m_retcode = SESS_STAT_ERR_AUTH_DENIED; _this->m_retcode = TP_SESS_STAT_ERR_AUTH_DENIED;
return SSH_AUTH_DENIED; return SSH_AUTH_DENIED;
} }
@ -271,7 +272,7 @@ int SshSession::_on_auth_password_request(ssh_session session, const char *user,
{ {
g_ssh_env.free_session(sess_info); g_ssh_env.free_session(sess_info);
_this->m_have_error = true; _this->m_have_error = true;
_this->m_retcode = SESS_STAT_ERR_AUTH_DENIED; _this->m_retcode = TP_SESS_STAT_ERR_AUTH_DENIED;
return SSH_AUTH_DENIED; return SSH_AUTH_DENIED;
} }
@ -279,18 +280,18 @@ int SshSession::_on_auth_password_request(ssh_session session, const char *user,
sess_info = NULL; sess_info = NULL;
// 现在尝试根据session-id获取得到的信息，连接并登录真正的SSH服务器 // 现在尝试根据session-id获取得到的信息，连接并登录真正的SSH服务器
EXLOGV("[ssh] try to connect to real SSH server %s:%d\n", _this->m_server_ip.c_str(), _this->m_server_port); EXLOGV("[ssh] try to connect to real SSH server %s:%d\n", _this->m_remote_host_ip.c_str(), _this->m_remote_host_port);
_this->m_srv_session = ssh_new(); _this->m_srv_session = ssh_new();
ssh_options_set(_this->m_srv_session, SSH_OPTIONS_HOST, _this->m_server_ip.c_str()); ssh_options_set(_this->m_srv_session, SSH_OPTIONS_HOST, _this->m_remote_host_ip.c_str());
int port = (int)_this->m_server_port; int port = (int)_this->m_remote_host_port;
ssh_options_set(_this->m_srv_session, SSH_OPTIONS_PORT, &port); ssh_options_set(_this->m_srv_session, SSH_OPTIONS_PORT, &port);
#ifdef EX_DEBUG #ifdef EX_DEBUG
// int flag = SSH_LOG_FUNCTIONS; // int flag = SSH_LOG_FUNCTIONS;
// ssh_options_set(_this->m_srv_session, SSH_OPTIONS_LOG_VERBOSITY, &flag); // ssh_options_set(_this->m_srv_session, SSH_OPTIONS_LOG_VERBOSITY, &flag);
#endif #endif
if (_this->m_auth_mode != TS_AUTH_MODE_NONE) if (_this->m_auth_type != TP_AUTH_TYPE_NONE)
ssh_options_set(_this->m_srv_session, SSH_OPTIONS_USER, _this->m_user_name.c_str()); ssh_options_set(_this->m_srv_session, SSH_OPTIONS_USER, _this->m_account_name.c_str());
//#ifdef EX_DEBUG //#ifdef EX_DEBUG
// // int _timeout_us = 500000000; // 5 sec. // // int _timeout_us = 500000000; // 5 sec.
@ -303,9 +304,9 @@ int SshSession::_on_auth_password_request(ssh_session session, const char *user,
int rc = 0; int rc = 0;
rc = ssh_connect(_this->m_srv_session); rc = ssh_connect(_this->m_srv_session);
if (rc != SSH_OK) { if (rc != SSH_OK) {
EXLOGE("[ssh] can not connect to real SSH server %s:%d. [%d]%s\n", _this->m_server_ip.c_str(), _this->m_server_port, rc, ssh_get_error(_this->m_srv_session)); EXLOGE("[ssh] can not connect to real SSH server %s:%d. [%d]%s\n", _this->m_remote_host_ip.c_str(), _this->m_remote_host_port, rc, ssh_get_error(_this->m_srv_session));
_this->m_have_error = true; _this->m_have_error = true;
_this->m_retcode = SESS_STAT_ERR_CONNECT; _this->m_retcode = TP_SESS_STAT_ERR_CONNECT;
return SSH_AUTH_ERROR; return SSH_AUTH_ERROR;
} }
@ -324,7 +325,7 @@ int SshSession::_on_auth_password_request(ssh_session session, const char *user,
// } // }
if (_this->m_auth_mode == TS_AUTH_MODE_PASSWORD) { if (_this->m_auth_type == TP_AUTH_TYPE_PASSWORD) {
// 优先尝试交互式登录（SSHv2推荐） // 优先尝试交互式登录（SSHv2推荐）
int retry_count = 0; int retry_count = 0;
rc = ssh_userauth_kbdint(_this->m_srv_session, NULL, NULL); rc = ssh_userauth_kbdint(_this->m_srv_session, NULL, NULL);
@ -351,11 +352,11 @@ int SshSession::_on_auth_password_request(ssh_session session, const char *user,
const char* prompt = ssh_userauth_kbdint_getprompt(_this->m_srv_session, iprompt, &echo); const char* prompt = ssh_userauth_kbdint_getprompt(_this->m_srv_session, iprompt, &echo);
EXLOGV("[ssh] interactive login prompt: %s\n", prompt); EXLOGV("[ssh] interactive login prompt: %s\n", prompt);
rc = ssh_userauth_kbdint_setanswer(_this->m_srv_session, iprompt, _this->m_user_auth.c_str()); rc = ssh_userauth_kbdint_setanswer(_this->m_srv_session, iprompt, _this->m_account_secret.c_str());
if (rc < 0) { if (rc < 0) {
EXLOGE("[ssh] invalid password for interactive mode to login to real SSH server %s:%d.\n", _this->m_server_ip.c_str(), _this->m_server_port); EXLOGE("[ssh] invalid password for interactive mode to login to real SSH server %s:%d.\n", _this->m_remote_host_ip.c_str(), _this->m_remote_host_port);
_this->m_have_error = true; _this->m_have_error = true;
_this->m_retcode = SESS_STAT_ERR_AUTH_DENIED; _this->m_retcode = TP_SESS_STAT_ERR_AUTH_DENIED;
return SSH_AUTH_ERROR; return SSH_AUTH_ERROR;
} }
} }
@ -373,7 +374,7 @@ int SshSession::_on_auth_password_request(ssh_session session, const char *user,
} }
// 不支持交互式登录，则尝试密码方式 // 不支持交互式登录，则尝试密码方式
rc = ssh_userauth_password(_this->m_srv_session, NULL, _this->m_user_auth.c_str()); rc = ssh_userauth_password(_this->m_srv_session, NULL, _this->m_account_secret.c_str());
if (rc == SSH_AUTH_SUCCESS) { if (rc == SSH_AUTH_SUCCESS) {
EXLOGW("[ssh] logon with password mode.\n"); EXLOGW("[ssh] logon with password mode.\n");
_this->m_is_logon = true; _this->m_is_logon = true;
@ -383,17 +384,17 @@ int SshSession::_on_auth_password_request(ssh_session session, const char *user,
EXLOGD("[ssh] failed to login with password mode, got %d.\n", rc); EXLOGD("[ssh] failed to login with password mode, got %d.\n", rc);
} }
EXLOGE("[ssh] can not use password mode or interactive mode ot login to real SSH server %s:%d.\n", _this->m_server_ip.c_str(), _this->m_server_port); EXLOGE("[ssh] can not use password mode or interactive mode ot login to real SSH server %s:%d.\n", _this->m_remote_host_ip.c_str(), _this->m_remote_host_port);
_this->m_have_error = true; _this->m_have_error = true;
_this->m_retcode = SESS_STAT_ERR_AUTH_DENIED; _this->m_retcode = TP_SESS_STAT_ERR_AUTH_DENIED;
return SSH_AUTH_ERROR; return SSH_AUTH_ERROR;
} }
else if (_this->m_auth_mode == TS_AUTH_MODE_PRIVATE_KEY) { else if (_this->m_auth_type == TP_AUTH_TYPE_PRIVATE_KEY) {
ssh_key key = NULL; ssh_key key = NULL;
if (SSH_OK != ssh_pki_import_privkey_base64(_this->m_user_auth.c_str(), NULL, NULL, NULL, &key)) { if (SSH_OK != ssh_pki_import_privkey_base64(_this->m_account_secret.c_str(), NULL, NULL, NULL, &key)) {
EXLOGE("[ssh] can not import private-key for auth.\n"); EXLOGE("[ssh] can not import private-key for auth.\n");
_this->m_have_error = true; _this->m_have_error = true;
_this->m_retcode = SESS_STAT_ERR_BAD_SSH_KEY; _this->m_retcode = TP_SESS_STAT_ERR_BAD_SSH_KEY;
return SSH_AUTH_ERROR; return SSH_AUTH_ERROR;
} }
@ -406,19 +407,19 @@ int SshSession::_on_auth_password_request(ssh_session session, const char *user,
return SSH_AUTH_SUCCESS; return SSH_AUTH_SUCCESS;
} }
else { else {
EXLOGE("[ssh] failed to use private-key to login to real SSH server %s:%d.\n", _this->m_server_ip.c_str(), _this->m_server_port); EXLOGE("[ssh] failed to use private-key to login to real SSH server %s:%d.\n", _this->m_remote_host_ip.c_str(), _this->m_remote_host_port);
_this->m_have_error = true; _this->m_have_error = true;
_this->m_retcode = SESS_STAT_ERR_AUTH_DENIED; _this->m_retcode = TP_SESS_STAT_ERR_AUTH_DENIED;
return SSH_AUTH_ERROR; return SSH_AUTH_ERROR;
} }
} }
else if (_this->m_auth_mode == TS_AUTH_MODE_NONE) { else if (_this->m_auth_type == TP_AUTH_TYPE_NONE) {
return SSH_AUTH_ERROR; return SSH_AUTH_ERROR;
} }
else { else {
EXLOGE("[ssh] invalid auth mode.\n"); EXLOGE("[ssh] invalid auth mode.\n");
_this->m_have_error = true; _this->m_have_error = true;
_this->m_retcode = SESS_STAT_ERR_AUTH_DENIED; _this->m_retcode = TP_SESS_STAT_ERR_AUTH_DENIED;
return SSH_AUTH_ERROR; return SSH_AUTH_ERROR;
} }
} }
@ -1017,7 +1018,7 @@ int SshSession::_on_client_channel_subsystem_request(ssh_session session, ssh_ch
// 目前只支持SFTP子系统 // 目前只支持SFTP子系统
if (strcmp(subsystem, "sftp") != 0) { if (strcmp(subsystem, "sftp") != 0) {
EXLOGE("[ssh] support `sftp` subsystem only, but got `%s`.\n", subsystem); EXLOGE("[ssh] support `sftp` subsystem only, but got `%s`.\n", subsystem);
_this->m_retcode = SESS_STAT_ERR_UNSUPPORT_PROTOCOL; _this->m_retcode = TP_SESS_STAT_ERR_UNSUPPORT_PROTOCOL;
return SSH_ERROR; return SSH_ERROR;
} }
@ -1044,7 +1045,7 @@ int SshSession::_on_client_channel_subsystem_request(ssh_session session, ssh_ch
void SshSession::_enter_sftp_mode(void) { void SshSession::_enter_sftp_mode(void) {
if (!m_is_sftp) { if (!m_is_sftp) {
m_is_sftp = true; m_is_sftp = true;
m_proxy->add_sftp_session_info(m_sid, m_server_ip, m_server_port, m_user_name, m_user_auth, m_auth_mode); m_proxy->add_sftp_session_info(m_sid, m_remote_host_ip, m_remote_host_port, m_account_name, m_account_secret, m_auth_type);
} }
} }
@ -1066,7 +1067,7 @@ int SshSession::_on_server_channel_data(ssh_session session, ssh_channel channel
TS_SSH_CHANNEL_INFO *info = _this->_get_cli_channel(channel); TS_SSH_CHANNEL_INFO *info = _this->_get_cli_channel(channel);
if (NULL == info || NULL == info->channel) { if (NULL == info || NULL == info->channel) {
EXLOGE("[ssh] when receive server channel data, not found client channel.\n"); EXLOGE("[ssh] when receive server channel data, not found client channel.\n");
_this->m_retcode = SESS_STAT_ERR_INTERNAL; _this->m_retcode = TP_SESS_STAT_ERR_INTERNAL;
return SSH_ERROR; return SSH_ERROR;
} }
@ -1110,9 +1111,9 @@ int SshSession::_on_server_channel_data(ssh_session session, ssh_channel channel
char buf[256] = { 0 }; char buf[256] = { 0 };
const char *auth_mode = NULL; const char *auth_mode = NULL;
if (_this->m_auth_mode == TS_AUTH_MODE_PASSWORD) if (_this->m_auth_type == TP_AUTH_TYPE_PASSWORD)
auth_mode = "password"; auth_mode = "password";
else if (_this->m_auth_mode == TS_AUTH_MODE_PRIVATE_KEY) else if (_this->m_auth_type == TP_AUTH_TYPE_PRIVATE_KEY)
auth_mode = "private-key"; auth_mode = "private-key";
else else
auth_mode = "unknown"; auth_mode = "unknown";
@ -1125,8 +1126,8 @@ int SshSession::_on_server_channel_data(ssh_session session, ssh_channel channel
" - authroized by %s\r\n"\ " - authroized by %s\r\n"\
"=============================================\r\n"\ "=============================================\r\n"\
"\r\n", "\r\n",
_this->m_server_ip.c_str(), _this->m_remote_host_ip.c_str(),
_this->m_server_port, auth_mode _this->m_remote_host_port, auth_mode
); );
int buf_len = strlen(buf); int buf_len = strlen(buf);

12
server/tp_core/protocol/ssh/ssh_session.h
View File

@ -55,7 +55,7 @@ public:
protected: protected:
// ¼Ì³Ð×Ô TppSessionBase // ¼Ì³Ð×Ô TppSessionBase
bool _on_session_begin(const TPP_SESSION_INFO* info); bool _on_session_begin(const TPP_CONNECT_INFO* info);
bool _on_session_end(void); bool _on_session_end(void);
@ -102,11 +102,11 @@ private:
ex_u16 m_client_port; ex_u16 m_client_port;
ex_astr m_sid; ex_astr m_sid;
ex_astr m_server_ip; ex_astr m_remote_host_ip;
ex_u16 m_server_port; ex_u16 m_remote_host_port;
ex_astr m_user_name; ex_astr m_account_name;
ex_astr m_user_auth; ex_astr m_account_secret;
int m_auth_mode; int m_auth_type;
bool m_is_first_server_data; bool m_is_first_server_data;
bool m_is_sftp; bool m_is_sftp;

8
server/tp_core/protocol/ssh/tpssh.cpp
View File

@ -1,6 +1,8 @@
#include "ssh_proxy.h" #include "ssh_proxy.h"
#include "tpp_env.h" #include "tpp_env.h"
#include <teleport_const.h>
TPP_API ex_rv tpp_init(TPP_INIT_ARGS* init_args) TPP_API ex_rv tpp_init(TPP_INIT_ARGS* init_args)
{ {
#ifdef EX_OS_UNIX #ifdef EX_OS_UNIX
@ -11,7 +13,7 @@ TPP_API ex_rv tpp_init(TPP_INIT_ARGS* init_args)
#endif #endif
if (!g_ssh_env.init(init_args)) if (!g_ssh_env.init(init_args))
return TSR_FAILED; return TPE_FAILED;
return 0; return 0;
} }
@ -19,9 +21,9 @@ TPP_API ex_rv tpp_init(TPP_INIT_ARGS* init_args)
TPP_API ex_rv tpp_start(void) TPP_API ex_rv tpp_start(void)
{ {
if (!g_ssh_proxy.init()) if (!g_ssh_proxy.init())
return TSR_FAILED; return TPE_FAILED;
if (!g_ssh_proxy.start()) if (!g_ssh_proxy.start())
return TSR_FAILED; return TPE_FAILED;
return 0; return 0;
} }

4
server/tp_core/protocol/ssh/tpssh.vs2015.vcxproj
View File

@ -68,7 +68,7 @@
<WarningLevel>Level3</WarningLevel> <WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization> <Optimization>Disabled</Optimization>
<PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;TPP_EXPORTS;LIBSSH_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions> <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;TPP_EXPORTS;LIBSSH_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>..\..\..\..\common\libex\include;..\..\..\..\external\libssh-win-static\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories> <AdditionalIncludeDirectories>..\..\..\..\common\teleport;..\..\..\..\common\libex\include;..\..\..\..\external\libssh-win-static\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary> <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
</ClCompile> </ClCompile>
<Link> <Link>
@ -86,7 +86,7 @@
<FunctionLevelLinking>true</FunctionLevelLinking> <FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions> <IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;TPP_EXPORTS;LIBSSH_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions> <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;TPP_EXPORTS;LIBSSH_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>..\..\..\..\common\libex\include;..\..\..\..\external\libssh-win-static\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories> <AdditionalIncludeDirectories>..\..\..\..\common\teleport;..\..\..\..\common\libex\include;..\..\..\..\external\libssh-win-static\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary> <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
</ClCompile> </ClCompile>
<Link> <Link>