github
/
teleport
1
0
Fork 0
Code Issues Pull Requests 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__
#define __TS_CONST_H__
#define TS_WEB_URL L"http://teleport.eomsoft.net/"
#define TS_BBS_URL L"http://bbs.eomsoft.net/"
#define TS_TRAY_MSG L"Teleport助手正常工作中"
#define TS_HTTP_RPC_PORT 50022
#define TS_HTTP_RPC_HOST "127.0.0.1"
#endif // __TS_CONST_H__
#ifndef __TS_CONST_H__
#define __TS_CONST_H__
#define TS_WEB_URL L"http://teleport.eomsoft.net/"
#define TS_BBS_URL L"http://bbs.eomsoft.net/"
#define TS_TRAY_MSG L"Teleport助手正常工作中"
#define TS_HTTP_RPC_PORT 50022
//#define TS_HTTP_RPC_HOST "127.0.0.1"
#define TS_HTTP_RPC_HOST "localhost"
#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"
TppEnvBase::TppEnvBase()
{}
TppEnvBase::~TppEnvBase()
{}
bool TppEnvBase::init(TPP_INIT_ARGS* args)
{
if (NULL == args)
{
EXLOGE("invalid init args(1).\n");
return false;
}
EXLOG_USE_LOGGER(args->logger);
exec_path = args->exec_path;
etc_path = args->etc_path;
replay_path = args->replay_path;
take_session = args->func_take_session;
free_session = args->func_free_session;
session_begin = args->func_session_begin;
session_end = args->func_session_end;
if (NULL == take_session || NULL == free_session || NULL == session_begin || NULL == session_end)
{
EXLOGE("invalid init args(2).\n");
return false;
}
if (NULL == args->cfg)
{
EXLOGE("invalid init args(3).\n");
return false;
}
if (!_on_init(args))
{
EXLOGE("invalid init args(4).\n");
return false;
}
return true;
}
#include "base_env.h"
TppEnvBase::TppEnvBase()
{}
TppEnvBase::~TppEnvBase()
{}
bool TppEnvBase::init(TPP_INIT_ARGS* args)
{
if (NULL == args)
{
EXLOGE("invalid init args(1).\n");
return false;
}
EXLOG_USE_LOGGER(args->logger);
exec_path = args->exec_path;
etc_path = args->etc_path;
replay_path = args->replay_path;
get_session = args->func_get_connect_info;
free_session = args->func_free_connect_info;
session_begin = args->func_session_begin;
session_end = args->func_session_end;
if (NULL == get_session || NULL == free_session || NULL == session_begin || NULL == session_end)
{
EXLOGE("invalid init args(2).\n");
return false;
}
if (NULL == args->cfg)
{
EXLOGE("invalid init args(3).\n");
return false;
}
if (!_on_init(args))
{
EXLOGE("invalid init args(4).\n");
return false;
}
return true;
}

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

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

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

@ -1,76 +1,97 @@
#ifndef __TS_BASE_RECORD_H__
#define __TS_BASE_RECORD_H__
#include "base_env.h"
#include "ts_membuf.h"
#include "protocol_interface.h"
#include <ex.h>
#define MAX_SIZE_PER_FILE 4194304 // 4M = 1024*1024*4
#pragma pack(push,1)
// 录像文件头
typedef struct TS_RECORD_HEADER
{
ex_u32 magic; // "TPPR" 标志 TelePort Protocol Record
ex_u16 ver; // 录像文件版本，目前为2
ex_u16 protocol; // 协议：1=RDP, 2=SSH, 3=Telnet
ex_u64 timestamp; // 本次录像的起始时间（UTC时间戳）
ex_u32 packages; // 总包数
ex_u32 time_ms; // 总耗时（毫秒）
ex_u16 width; // 初始屏幕尺寸：宽
ex_u16 height; // 初始屏幕尺寸：高
ex_u16 file_count; // 数据文件总数
ex_u32 file_size; // 所有数据文件的总大小（不包括每个数据文件的头，即4字节的每文件大小）
char account[16]; // teleport账号
char username[16]; // 远程主机用户名
char ip[18];
ex_u16 port;
// RDP专有
ex_u8 rdp_security; // 0 = RDP, 1 = TLS
ex_u8 reserve[128 - 4 - 2 - 2 - 8 - 4 - 4 - 2 - 2 - 2 - 4 - 16 - 16 - 18 - 2 - 1]; // 保留
}TS_RECORD_HEADER;
// 一个数据包的头
typedef struct TS_RECORD_PKG
{
ex_u8 type; // 包的数据类型
ex_u32 size; // 这个包的总大小（不含包头）
ex_u32 time_ms; // 这个包距起始时间的时间差（毫秒，意味着一个连接不能持续超过49天）
ex_u8 reserve[3]; // 保留
}TS_RECORD_PKG;
#pragma pack(pop)
class TppRecBase
{
public:
TppRecBase();
virtual ~TppRecBase();
void begin(const wchar_t* base_path, const wchar_t* base_fname, int record_id, const TPP_SESSION_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_SESSION_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__
#ifndef __TS_BASE_RECORD_H__
#define __TS_BASE_RECORD_H__
#include "base_env.h"
#include "ts_membuf.h"
#include "protocol_interface.h"
#include <ex.h>
#define MAX_SIZE_PER_FILE 4194304 // 4M = 1024*1024*4
#pragma pack(push,1)
// 录像文件头(随着录像数据写入，会改变的部分)
typedef struct TS_RECORD_HEADER_INFO
{
ex_u32 packages; // 总包数
ex_u32 time_ms; // 总耗时（毫秒）
ex_u32 file_size; // 数据总大小（不包括文件头）
}TS_RECORD_HEADER_INFO;
// 录像文件头(固定不变部分)
typedef struct TS_RECORD_HEADER_BASIC
{
ex_u32 magic; // "TPPR" 标志 TelePort Protocol Record
ex_u16 ver; // 录像文件版本，目前为3
ex_u16 protocol_type; // 协议：1=RDP, 2=SSH, 3=Telnet
ex_u16 protocol_sub_type; // 子协议：100=RDP, 200=SSH, 201=SFTP, 300=Telnet
ex_u64 timestamp; // 本次录像的起始时间（UTC时间戳）
ex_u16 width; // 初始屏幕尺寸：宽
ex_u16 height; // 初始屏幕尺寸：高
char user_name[32]; // teleport账号
char account_name[32]; // 远程主机用户名
char real_remote_host_ip[40]; // 远程主机IP
char remote_host_ip[40]; // 远程主机IP
ex_u16 remote_host_port; // 远程主机端口
char client_ip[40]; // 客户端IP
// RDP专有
ex_u8 rdp_security; // 0 = RDP, 1 = TLS
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;
#define ts_record_header_basic_size sizeof(TS_RECORD_HEADER_BASIC)
typedef struct TS_RECORD_HEADER
{
TS_RECORD_HEADER_INFO info;
TS_RECORD_HEADER_BASIC basic;
}TS_RECORD_HEADER;
// header部分（header-info + header-basic） = 256B
#define ts_record_header_size sizeof(TS_RECORD_HEADER)
// 一个数据包的头
typedef struct TS_RECORD_PKG
{
ex_u8 type; // 包的数据类型
ex_u32 size; // 这个包的总大小（不含包头）
ex_u32 time_ms; // 这个包距起始时间的时间差（毫秒，意味着一个连接不能持续超过49天）
ex_u8 reserve[3]; // 保留
}TS_RECORD_PKG;
#pragma pack(pop)
class TppRecBase
{
public:
TppRecBase();
virtual ~TppRecBase();
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__
#define __TP_PROTOCOL_INTERFACE_H__
#include "ts_const.h"
#include <ex.h>
#ifdef EX_OS_WIN32
# ifdef TPP_EXPORTS
# define TPP_API __declspec(dllexport)
# else
# define TPP_API __declspec(dllimport)
# endif
#else
# define TPP_API
#endif
typedef struct TPP_SESSION_INFO
{
char* sid;
char* account_name; // 申请本次连接的用户名
char* host_ip;
char* user_name;
char* user_auth;
char* user_param;
int host_port;
int protocol;
int auth_id;
int auth_mode;
int sys_type;
int ref_count; // 这个session可以被take_session()多少次
ex_u64 ticket_start;
}TPP_SESSION_INFO;
typedef TPP_SESSION_INFO* (*TPP_TAKE_SESSION_FUNC)(const char* sid);
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 bool(*TPP_SESSION_END_FUNC)(int db_id, int ret);
typedef struct TPP_INIT_ARGS
{
ExLogger* logger;
ex_wstr exec_path;
ex_wstr etc_path;
ex_wstr replay_path;
ExIniFile* cfg;
TPP_TAKE_SESSION_FUNC func_take_session;
TPP_FREE_SESSION_FUNC func_free_session;
TPP_SESSION_BEGIN_FUNC func_session_begin;
TPP_SESSION_END_FUNC func_session_end;
}TPP_INIT_ARGS;
#ifdef __cplusplus
extern "C"
{
#endif
TPP_API ex_rv tpp_init(TPP_INIT_ARGS* init_args);
TPP_API ex_rv tpp_start(void);
TPP_API ex_rv tpp_stop(void);
#ifdef __cplusplus
}
#endif
typedef ex_rv (*TPP_INIT_FUNC)(TPP_INIT_ARGS* init_args);
typedef ex_rv (*TPP_START_FUNC)(void);
typedef ex_rv (*TPP_STOP_FUNC)(void);
#endif // __TP_PROTOCOL_INTERFACE_H__
#ifndef __TP_PROTOCOL_INTERFACE_H__
#define __TP_PROTOCOL_INTERFACE_H__
#include "ts_const.h"
#include <ex.h>
#ifdef EX_OS_WIN32
# ifdef TPP_EXPORTS
# define TPP_API __declspec(dllexport)
# else
# define TPP_API __declspec(dllimport)
# endif
#else
# define TPP_API
#endif
typedef struct TPP_CONNECT_INFO
{
char* sid;
char* user_name; // 申请本次连接的用户名
char* real_remote_host_ip; // 真正的远程主机IP（如果是直接连接模式，则与remote_host_ip相同）
char* remote_host_ip; // 要连接的远程主机的IP（如果是端口映射模式，则为路由主机的IP）
char* account_name; // 远程主机的账号
char* account_secret; // 远程主机账号的密码（或者私钥）
char* user_param;
int remote_host_port; // 要连接的远程主机的端口（如果是端口映射模式，则为路由主机的端口）
int protocol_type;
int protocol_sub_type;
//int auth_id;
int auth_type;
int sys_type;
int ref_count; // 这个连接信息的引用计数，如果创建的连接信息从来未被使用，则超过60秒后自动销毁
ex_u64 ticket_start; // 此连接信息的创建时间（用于超时未使用就销毁的功能）
}TPP_CONNECT_INFO;
typedef TPP_CONNECT_INFO* (*TPP_GET_CONNNECT_INFO_FUNC)(const char* sid);
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;
ex_wstr exec_path;
ex_wstr etc_path;
ex_wstr replay_path;
ExIniFile* cfg;
TPP_GET_CONNNECT_INFO_FUNC func_get_connect_info;
TPP_FREE_CONNECT_INFO_FUNC func_free_connect_info;
TPP_SESSION_BEGIN_FUNC func_session_begin;
TPP_SESSION_END_FUNC func_session_end;
}TPP_INIT_ARGS;
#ifdef __cplusplus
extern "C"
{
#endif
TPP_API ex_rv tpp_init(TPP_INIT_ARGS* init_args);
TPP_API ex_rv tpp_start(void);
TPP_API ex_rv tpp_stop(void);
#ifdef __cplusplus
}
#endif
typedef ex_rv (*TPP_INIT_FUNC)(TPP_INIT_ARGS* init_args);
typedef ex_rv (*TPP_START_FUNC)(void);
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"
// #define TS_RDP_PROXY_PORT 3389
// #define TS_RDP_PROXY_HOST "0.0.0.0"
//
// #define TS_SSH_PROXY_PORT 22
// #define TS_SSH_PROXY_HOST "0.0.0.0"
//
// #define TS_TELNET_PROXY_PORT 23
// #define TS_TELNET_PROXY_HOST "0.0.0.0"
#define TS_RDP_PROXY_PORT 52089
#define TS_RDP_PROXY_HOST "0.0.0.0"
#define TS_SSH_PROXY_PORT 52189
#define TS_SSH_PROXY_HOST "0.0.0.0"
#define TS_TELNET_PROXY_PORT 52389
#define TS_TELNET_PROXY_HOST "0.0.0.0"
#define TS_HTTP_RPC_PORT 52080
#define TS_HTTP_RPC_HOST "127.0.0.1"
//#define TS_HTTP_RPC_HOST "0.0.0.0"
//#define TS_HTTP_RPC_HOST "127.0.0.1"
#define TS_HTTP_RPC_HOST "localhost"
#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
{
ex_wstr2astr(tmp, rpc_bind_ip);
if (rpc_bind_ip == "localhost")
rpc_bind_ip = "127.0.0.1";
//if (rpc_bind_ip == "localhost")
// rpc_bind_ip = "127.0.0.1";
}
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;
_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;
TPP_SESSION_INFO* tpp_take_session(const char* sid)
TPP_CONNECT_INFO* tpp_get_session(const char* sid)
{
TS_SESSION_INFO sinfo;
bool ret = g_session_mgr.take_session(sid, sinfo);
if (!ret)
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);
ex_strcpy(info->sid, sinfo.sid.length() + 1, sinfo.sid.c_str());
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());
info->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());
info->real_remote_host_ip = (char*)calloc(1, sinfo.host_ip.length() + 1);
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);
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);
ex_strcpy(info->user_auth, sinfo.user_auth.length() + 1, sinfo.user_auth.c_str());
info->account_secret = (char*)calloc(1, sinfo.user_auth.length() + 1);
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);
ex_strcpy(info->user_param, sinfo.user_param.length() + 1, sinfo.user_param.c_str());
info->auth_id = sinfo.auth_id;
info->host_port = sinfo.host_port;
info->protocol = sinfo.protocol;
info->auth_mode = sinfo.auth_mode;
//info->auth_id = sinfo.auth_id;
info->remote_host_port = sinfo.host_port;
info->protocol_type = sinfo.protocol;
info->auth_type= sinfo.auth_mode;
info->sys_type = sinfo.sys_type;
info->ref_count = sinfo.ref_count;
info->ticket_start = sinfo.ticket_start;
@ -42,21 +44,22 @@ TPP_SESSION_INFO* tpp_take_session(const char* sid)
return info;
}
void tpp_free_session(TPP_SESSION_INFO* info)
void tpp_free_session(TPP_CONNECT_INFO* info)
{
if (NULL == info)
return;
free(info->sid);
free(info->account_name);
free(info->host_ip);
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);
}
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)
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);
}
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

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

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

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

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

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

@ -1,4 +1,5 @@
#include "ssh_recorder.h"
#include <teleport_const.h>
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);
memset(&m_head, 0, sizeof(TS_RECORD_HEADER));
memcpy((ex_u8*)(&m_head.magic), TPP_RECORD_MAGIC, sizeof(ex_u32));
m_head.ver = 0x02;
m_head.protocol = TS_PROXY_PROTOCOL_SSH;
memcpy((ex_u8*)(&m_head.basic.magic), TPP_RECORD_MAGIC, sizeof(ex_u32));
m_head.basic.ver = 0x02;
}
TppSshRec::~TppSshRec()
@ -17,19 +17,22 @@ TppSshRec::~TppSshRec()
end();
}
void TppSshRec::_on_begin(const TPP_SESSION_INFO* info)
void TppSshRec::_on_begin(const TPP_CONNECT_INFO* info)
{
if (NULL == info)
return;
m_head.timestamp = time(NULL);
m_head.port = info->host_port;
m_head.basic.timestamp = time(NULL);
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.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.account, info->account_name, strlen(info->account_name) > 15 ? 15 : strlen(info->account_name));
memcpy(m_head.username, info->user_name, strlen(info->user_name) > 15 ? 15 : 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.account_name, info->account_name, strlen(info->account_name) >= 31 ? 31 : strlen(info->account_name));
memcpy(m_head.basic.user_name, info->user_name, strlen(info->user_name) >= 31 ? 31 : strlen(info->user_name));
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)
@ -42,7 +45,7 @@ void TppSshRec::_on_end(void)
// ¸üÐÂÍ·ÐÅÏ¢
//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_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)
return;
m_head.packages++;
m_head.info.packages++;
if (sizeof(TS_RECORD_PKG) + size + m_cache.size() > m_cache.buffer_size())
_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)
{
m_head.width = width;
m_head.height = height;
m_head.basic.width = width;
m_head.basic.height = 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)
{
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_path_join(fname, false, m_base_fname.c_str(), NULL);
@ -148,8 +151,8 @@ bool TppSshRec::_save_to_data_file(void)
fflush(f);
fclose(f);
m_head.file_count++;
m_head.file_size += m_cache.size();
//m_head.file_count++;
//m_head.file_size += m_cache.size();
m_cache.empty();
return true;

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

@ -1,72 +1,72 @@
#ifndef __TPP_SSH_RECORDER_H__
#define __TPP_SSH_RECORDER_H__
#include "../../common/base_record.h"
#define TS_RECORD_TYPE_SSH_TERM_SIZE 0x01 // 终端大小（行数与列数）
#define TS_RECORD_TYPE_SSH_DATA 0x02 // 用于展示的数据内容
#pragma pack(push,1)
// 录像文件头
// typedef struct TS_RECORD_HEADER
// {
// ex_u32 magic; // "TPPR" 标志 TelePort Protocol Record
// ex_u64 timestamp; // 本次录像的起始时间（UTC时间戳）
// ex_u32 packages; // 总包数
// ex_u32 time_ms; // 总耗时（毫秒）
// ex_u16 width; // 初始屏幕尺寸：宽
// ex_u16 height; // 初始屏幕尺寸：高
// ex_u16 file_count; // 数据文件总数
// ex_u32 file_size; // 所有数据文件的总大小（不包括每个数据文件的头，即4字节的每文件大小）
// char account[16]; // teleport账号
// char username[16]; // 远程主机用户名
// char ip[18];
// ex_u16 port;
//
// ex_u8 reserve[128 - 4 - 8 - 4 - 4 - 2 - 2 - 2 - 4 - 16 - 16 - 18 - 2]; // 保留
// }TS_RECORD_HEADER;
//
// // 一个数据包的头
// typedef struct TS_RECORD_PKG
// {
// ex_u8 type; // 包的数据类型
// ex_u32 size; // 这个包的总大小（不含包头）
// ex_u32 time_ms; // 这个包距起始时间的时间差（毫秒，意味着一个连接不能持续超过49天）
// ex_u8 reserve[3]; // 保留
// }TS_RECORD_PKG;
// 记录窗口大小改变的数据包
typedef struct TS_RECORD_WIN_SIZE
{
ex_u16 width;
ex_u16 height;
}TS_RECORD_WIN_SIZE;
#pragma pack(pop)
class TppSshRec : public TppRecBase
{
public:
TppSshRec();
virtual ~TppSshRec();
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_change(int width, int height);
void record_command(const ex_astr cmd);
protected:
void _on_begin(const TPP_SESSION_INFO* info);
void _on_end(void);
bool _save_to_data_file(void);
bool _save_to_cmd_file(void);
protected:
TS_RECORD_HEADER m_head;
MemBuffer m_cmd_cache;
};
#endif // __TPP_SSH_RECORDER_H__
#ifndef __TPP_SSH_RECORDER_H__
#define __TPP_SSH_RECORDER_H__
#include "../../common/base_record.h"
#define TS_RECORD_TYPE_SSH_TERM_SIZE 0x01 // 终端大小（行数与列数）
#define TS_RECORD_TYPE_SSH_DATA 0x02 // 用于展示的数据内容
#pragma pack(push,1)
// 录像文件头
// typedef struct TS_RECORD_HEADER
// {
// ex_u32 magic; // "TPPR" 标志 TelePort Protocol Record
// ex_u64 timestamp; // 本次录像的起始时间（UTC时间戳）
// ex_u32 packages; // 总包数
// ex_u32 time_ms; // 总耗时（毫秒）
// ex_u16 width; // 初始屏幕尺寸：宽
// ex_u16 height; // 初始屏幕尺寸：高
// ex_u16 file_count; // 数据文件总数
// ex_u32 file_size; // 所有数据文件的总大小（不包括每个数据文件的头，即4字节的每文件大小）
// char account[16]; // teleport账号
// char username[16]; // 远程主机用户名
// char ip[18];
// ex_u16 port;
//
// ex_u8 reserve[128 - 4 - 8 - 4 - 4 - 2 - 2 - 2 - 4 - 16 - 16 - 18 - 2]; // 保留
// }TS_RECORD_HEADER;
//
// // 一个数据包的头
// typedef struct TS_RECORD_PKG
// {
// ex_u8 type; // 包的数据类型
// ex_u32 size; // 这个包的总大小（不含包头）
// ex_u32 time_ms; // 这个包距起始时间的时间差（毫秒，意味着一个连接不能持续超过49天）
// ex_u8 reserve[3]; // 保留
// }TS_RECORD_PKG;
// 记录窗口大小改变的数据包
typedef struct TS_RECORD_WIN_SIZE
{
ex_u16 width;
ex_u16 height;
}TS_RECORD_WIN_SIZE;
#pragma pack(pop)
class TppSshRec : public TppRecBase
{
public:
TppSshRec();
virtual ~TppSshRec();
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_change(int width, int height);
void record_command(const ex_astr cmd);
protected:
void _on_begin(const TPP_CONNECT_INFO* info);
void _on_end(void);
bool _save_to_data_file(void);
bool _save_to_cmd_file(void);
protected:
TS_RECORD_HEADER m_head;
MemBuffer m_cmd_cache;
};
#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 <algorithm>
#include <teleport_const.h>
SshSession::SshSession(SshProxy *proxy, ssh_session sess_client) :
ExThreadBase("ssh-session-thread"),
@ -10,10 +11,10 @@ SshSession::SshSession(SshProxy *proxy, ssh_session sess_client) :
m_cli_session(sess_client),
m_srv_session(NULL)
{
m_retcode = SESS_STAT_RUNNING;
m_retcode = TP_SESS_STAT_RUNNING;
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_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))
{
@ -91,10 +92,10 @@ bool SshSession::_on_session_end(void)
EXLOGD("[ssh] session ret-code: %d\n", m_retcode);
// 如果会话过程中没有发生错误，则将其状态改为结束，否则记录下错误值
if (m_retcode == SESS_STAT_RUNNING)
m_retcode = SESS_STAT_END;
if (m_retcode == TP_SESS_STAT_RUNNING)
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;
@ -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());
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) {
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会话，内部会将连接信息记录下来备用）
TS_SFTP_SESSION_INFO sftp_info;
if (!_this->m_proxy->get_sftp_session_info(_this->m_sid, sftp_info)) {
// TS_SFTP_SESSION_INFO 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());
_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;
}
_this->m_server_ip = sftp_info.host_ip;
_this->m_server_port = sftp_info.host_port;
_this->m_auth_mode = sftp_info.auth_mode;
_this->m_user_name = sftp_info.user_name;
_this->m_user_auth = sftp_info.user_auth;
protocol = TS_PROXY_PROTOCOL_SSH;
// 因为是从sftp会话得来的登录数据，因此限制本会话只能用于sftp，不允许再使用shell了。
_this->_enter_sftp_mode();
// }
//
// _this->m_remote_host_ip = sftp_info.host_ip;
// _this->m_remote_host_port = sftp_info.host_port;
// _this->m_auth_type = sftp_info.auth_mode;
// _this->m_account_name = sftp_info.user_name;
// _this->m_account_secret = sftp_info.user_auth;
// protocol = TP_PROTOCOL_TYPE_SSH;
//
// // 因为是从sftp会话得来的登录数据，因此限制本会话只能用于sftp，不允许再使用shell了。
// _this->_enter_sftp_mode();
}
else {
_this->m_server_ip = sess_info->host_ip;
_this->m_server_port = sess_info->host_port;
_this->m_auth_mode = sess_info->auth_mode;
_this->m_user_name = sess_info->user_name;
_this->m_user_auth = sess_info->user_auth;
protocol = sess_info->protocol;
_this->m_remote_host_ip = sess_info->remote_host_ip;
_this->m_remote_host_port = sess_info->remote_host_port;
_this->m_auth_type = sess_info->auth_type;
_this->m_account_name = sess_info->account_name;
_this->m_account_secret = sess_info->account_secret;
protocol = sess_info->protocol_type;
}
if (protocol != TS_PROXY_PROTOCOL_SSH) {
if (protocol != TP_PROTOCOL_TYPE_SSH) {
g_ssh_env.free_session(sess_info);
EXLOGE("[ssh] session '%s' is not for SSH.\n", _this->m_sid.c_str());
_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;
}
@ -271,7 +272,7 @@ int SshSession::_on_auth_password_request(ssh_session session, const char *user,
{
g_ssh_env.free_session(sess_info);
_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;
}
@ -279,18 +280,18 @@ int SshSession::_on_auth_password_request(ssh_session session, const char *user,
sess_info = NULL;
// 现在尝试根据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();
ssh_options_set(_this->m_srv_session, SSH_OPTIONS_HOST, _this->m_server_ip.c_str());
int port = (int)_this->m_server_port;
ssh_options_set(_this->m_srv_session, SSH_OPTIONS_HOST, _this->m_remote_host_ip.c_str());
int port = (int)_this->m_remote_host_port;
ssh_options_set(_this->m_srv_session, SSH_OPTIONS_PORT, &port);
#ifdef EX_DEBUG
// int flag = SSH_LOG_FUNCTIONS;
// ssh_options_set(_this->m_srv_session, SSH_OPTIONS_LOG_VERBOSITY, &flag);
#endif
if (_this->m_auth_mode != TS_AUTH_MODE_NONE)
ssh_options_set(_this->m_srv_session, SSH_OPTIONS_USER, _this->m_user_name.c_str());
if (_this->m_auth_type != TP_AUTH_TYPE_NONE)
ssh_options_set(_this->m_srv_session, SSH_OPTIONS_USER, _this->m_account_name.c_str());
//#ifdef EX_DEBUG
// // 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;
rc = ssh_connect(_this->m_srv_session);
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_retcode = SESS_STAT_ERR_CONNECT;
_this->m_retcode = TP_SESS_STAT_ERR_CONNECT;
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推荐）
int retry_count = 0;
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);
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) {
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_retcode = SESS_STAT_ERR_AUTH_DENIED;
_this->m_retcode = TP_SESS_STAT_ERR_AUTH_DENIED;
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) {
EXLOGW("[ssh] logon with password mode.\n");
_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);
}
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_retcode = SESS_STAT_ERR_AUTH_DENIED;
_this->m_retcode = TP_SESS_STAT_ERR_AUTH_DENIED;
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;
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");
_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;
}
@ -406,19 +407,19 @@ int SshSession::_on_auth_password_request(ssh_session session, const char *user,
return SSH_AUTH_SUCCESS;
}
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_retcode = SESS_STAT_ERR_AUTH_DENIED;
_this->m_retcode = TP_SESS_STAT_ERR_AUTH_DENIED;
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;
}
else {
EXLOGE("[ssh] invalid auth mode.\n");
_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;
}
}
@ -1017,7 +1018,7 @@ int SshSession::_on_client_channel_subsystem_request(ssh_session session, ssh_ch
// 目前只支持SFTP子系统
if (strcmp(subsystem, "sftp") != 0) {
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;
}
@ -1044,7 +1045,7 @@ int SshSession::_on_client_channel_subsystem_request(ssh_session session, ssh_ch
void SshSession::_enter_sftp_mode(void) {
if (!m_is_sftp) {
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);
if (NULL == info || NULL == info->channel) {
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;
}
@ -1110,9 +1111,9 @@ int SshSession::_on_server_channel_data(ssh_session session, ssh_channel channel
char buf[256] = { 0 };
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";
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";
else
auth_mode = "unknown";
@ -1125,8 +1126,8 @@ int SshSession::_on_server_channel_data(ssh_session session, ssh_channel channel
" - authroized by %s\r\n"\
"=============================================\r\n"\
"\r\n",
_this->m_server_ip.c_str(),
_this->m_server_port, auth_mode
_this->m_remote_host_ip.c_str(),
_this->m_remote_host_port, auth_mode
);
int buf_len = strlen(buf);

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

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

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

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

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

@ -68,7 +68,7 @@
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<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>
</ClCompile>
<Link>
@ -86,7 +86,7 @@
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<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>
</ClCompile>
<Link>