void new_mod()
{
ModRDPParams mod_rdp_params(
username.c_str(),
password.c_str(),
target_device.c_str(),
"0.0.0.0", // client ip is silenced
/*front.keymap.key_flags*/ 0,
font,
theme,
server_auto_reconnect_packet,
close_box_extra_message,
to_verbose_flags(verbose)
);
mod_rdp_params.device_id = "device_id";
mod_rdp_params.enable_tls = true;
mod_rdp_params.enable_nla = false;
mod_rdp_params.enable_fastpath = true;
mod_rdp_params.enable_mem3blt = true;
mod_rdp_params.enable_new_pointer = true;
mod_rdp_params.enable_glyph_cache = true;
mod_rdp_params.enable_ninegrid_bitmap = true;
std::string allow_channels = "*";
mod_rdp_params.allow_channels = &allow_channels;
mod_rdp_params.deny_channels = nullptr;
mod_rdp_params.enable_rdpdr_data_analysis = false;
mod_rdp_params.server_cert_check = ServerCertCheck::always_succeed;
if (verbose > 128) {
mod_rdp_params.log();
}
this->mod = new_mod_rdp(
browser_trans, session_reactor, front, client_info, redir_info, lcg_gen,
lcg_timeobj, mod_rdp_params, authentifier, report_message, ini, nullptr);
}
int main(int argc, char * argv[]) {
openlog("transparent", LOG_CONS | LOG_PERROR, LOG_USER);
const char * copyright_notice =
"\n"
"ReDemPtion Transparent Proxy " VERSION ".\n"
"Copyright (C) Wallix 2010-2015.\n"
"Christophe Grosjean, Raphael Zhou.\n"
"\n"
;
std::string input_filename;
std::string output_filename;
std::string target_device;
uint32_t target_port;
std::string username;
std::string password;
std::string record_filename;
std::string play_filename;
std::string persistent_key_list_filename;
persistent_key_list_filename = "./PersistentKeyList.bin";
target_port = 3389;
program_options::options_description desc({
{'h', "help", "produce help message"},
{'v', "version", "show software version"},
{'i', "input-file", &input_filename, "input ini file name"},
{'o', "output-file", &output_filename, "output int file name"},
{'t', "target-device", &target_device, "target device[:port]"},
{'u', "username", &username, "username"},
{'p', "password", &password, "password"},
{'k', "key-list-file", &persistent_key_list_filename, "persistent key list file name"},
{'r', "record-file", &record_filename, "record file name"},
{'d', "play-file", &play_filename, "play file name"},
});
auto options = program_options::parse_command_line(argc, argv, desc);
if (options.count("help") > 0) {
std::cout << copyright_notice;
std::cout << "Usage: rdptproxy [options]\n\n";
std::cout << desc << endl;
exit(0);
}
if (options.count("version") > 0) {
std::cout << copyright_notice;
exit(0);
}
if ( target_device.empty()
&& play_filename.empty()) {
std::cerr << "Missing target device or play file name: use -t target or -d filename\n\n";
exit(-1);
}
if ( !target_device.empty()
&& !play_filename.empty()) {
std::cerr << "Use -t target or -d filename\n\n";
exit(-1);
}
if ( !output_filename.empty()
&& !play_filename.empty()) {
std::cerr << "Use -o filename or -d filename\n\n";
exit(-1);
}
if ( !record_filename.empty()
&& !play_filename.empty()) {
std::cerr << "Use -r filename or -d filename\n\n";
exit(-1);
}
if ( !input_filename.empty()
&& !output_filename.empty()) {
std::cerr << "Use -i filename or -o filename\n\n";
exit(-1);
}
if (!target_device.empty()) {
size_t pos = target_device.find(':');
if (pos != string::npos) {
target_port = atoi(target_device.substr(pos + 1).c_str());
target_device.resize(pos);
}
if (username.c_str()[0] == 0) {
std::cerr << "Missing username : use -u username\n\n";
exit(-1);
}
}
if (password.empty()) {
password = "";
}
// This server only support one incoming connection before closing listener
class ServerOnce : public Server {
public:
int sck;
char ip_source[256];
ServerOnce() : sck(0) {
this->ip_source[0] = 0;
}
virtual Server_status start(int incoming_sck) {
union {
struct sockaddr s;
struct sockaddr_storage ss;
struct sockaddr_in s4;
struct sockaddr_in6 s6;
} u;
unsigned int sin_size = sizeof(u);
memset(&u, 0, sin_size);
this->sck = accept(incoming_sck, &u.s, &sin_size);
strcpy(this->ip_source, inet_ntoa(u.s4.sin_addr));
LOG(LOG_INFO, "Incoming socket to %d (ip=%s)\n", this->sck, this->ip_source);
return START_WANT_STOP;
}
} one_shot_server;
Listen listener(one_shot_server, 0, 3389, true, 5); // 25 seconds to connect, or timeout
listener.run();
Inifile ini;
ConfigurationLoader cfg_loader(ini, CFG_PATH "/" RDPPROXY_INI);
int nodelay = 1;
if (-1 == setsockopt( one_shot_server.sck, IPPROTO_TCP, TCP_NODELAY, (char *)&nodelay
, sizeof(nodelay))) {
LOG(LOG_ERR, "Failed to set socket TCP_NODELAY option on client socket");
}
SocketTransport front_trans( "RDP Client", one_shot_server.sck, "0.0.0.0", 0
, ini.debug.front, 0);
wait_obj front_event;
LCGRandom gen(0);
// Remove existing Persistent Key List file.
unlink(persistent_key_list_filename.c_str());
OutFileTransport * persistent_key_list_oft = NULL;
int persistent_key_list_ofd;
persistent_key_list_ofd = open(persistent_key_list_filename.c_str(),
O_CREAT | O_TRUNC | O_WRONLY, S_IRUSR | S_IWUSR | S_IRGRP);
if (persistent_key_list_ofd != -1) {
persistent_key_list_oft = new OutFileTransport(persistent_key_list_ofd);
}
else {
LOG(LOG_ERR, "Failed to open Persistent Key List file to writing: name=\"%s\"",
persistent_key_list_filename.c_str());
}
const bool fastpath_support = true;
const bool mem3blt_support = true;
Front front(front_trans, SHARE_PATH "/" DEFAULT_FONT_NAME, gen, ini,
fastpath_support, mem3blt_support, input_filename.c_str(), persistent_key_list_oft);
null_mod no_mod(front);
while (front.up_and_running == 0) {
front.incoming(no_mod);
}
LOG(LOG_INFO, "hostname=\"%s\"", front.client_info.hostname);
try {
if (target_device.empty()) {
TransparentReplayMod mod(front, play_filename.c_str(),
front.client_info.width, front.client_info.height, NULL, ini.font);
run_mod(mod, front, front_event, nullptr, &front_trans);
}
else {
OutFileTransport * record_oft = NULL;
int record_fd = -1;
if (!record_filename.empty()) {
record_fd = open(record_filename.c_str(), O_CREAT | O_TRUNC | O_WRONLY,
S_IRUSR | S_IWUSR | S_IRGRP);
if (record_fd != -1) {
record_oft = new OutFileTransport(record_fd);
}
else {
LOG(LOG_ERR, "Failed to open record file to writing: name=\"%s\"",
record_filename.c_str());
}
}
InFileTransport * persistent_key_list_ift = NULL;
int persistent_key_list_ifd;
persistent_key_list_ifd = open(persistent_key_list_filename.c_str(), O_RDONLY);
if (persistent_key_list_ifd != -1) {
persistent_key_list_ift = new InFileTransport(persistent_key_list_ifd);
}
else {
LOG(LOG_ERR, "Failed to open Persistent Key List file to reading: name=\"%s\"",
persistent_key_list_filename.c_str());
}
int client_sck = ip_connect(target_device.c_str(), target_port, 3, 1000, ini.debug.mod_rdp);
SocketTransport mod_trans( "RDP Server", client_sck, target_device.c_str(), target_port
, ini.debug.mod_rdp, &ini.context.auth_error_message);
ClientInfo client_info = front.client_info;
ModRDPParams mod_rdp_params( username.c_str()
, password.c_str()
, target_device.c_str()
, "0.0.0.0" // client ip is silenced
, front.keymap.key_flags
, ini.debug.mod_rdp
);
//mod_rdp_params.enable_tls = true;
mod_rdp_params.enable_nla = ini.mod_rdp.enable_nla;
mod_rdp_params.enable_krb = ini.mod_rdp.enable_kerberos;
//mod_rdp_params.enable_fastpath = true;
//mod_rdp_params.enable_mem3blt = true;
mod_rdp_params.enable_bitmap_update = ini.globals.enable_bitmap_update;
//mod_rdp_params.enable_new_pointer = true;
mod_rdp_params.enable_transparent_mode = true;
mod_rdp_params.output_filename = (output_filename.empty() ? "" : output_filename.c_str());
mod_rdp_params.persistent_key_list_transport = persistent_key_list_ift;
mod_rdp_params.transparent_recorder_transport = record_oft;
mod_rdp_params.auth_channel = ini.globals.auth_channel;
mod_rdp_params.alternate_shell = ini.globals.alternate_shell.get_cstr();
mod_rdp_params.shell_working_directory = ini.globals.shell_working_directory.get_cstr();
mod_rdp_params.rdp_compression = ini.mod_rdp.rdp_compression;
mod_rdp_params.disconnect_on_logon_user_change = ini.mod_rdp.disconnect_on_logon_user_change;
mod_rdp_params.open_session_timeout = ini.mod_rdp.open_session_timeout;
mod_rdp_params.certificate_change_action = ini.mod_rdp.certificate_change_action;
mod_rdp_params.extra_orders = ini.mod_rdp.extra_orders.c_str();
mod_rdp_params.enable_persistent_disk_bitmap_cache = ini.mod_rdp.persistent_disk_bitmap_cache;
mod_rdp_params.enable_cache_waiting_list = ini.mod_rdp.cache_waiting_list;
mod_rdp_params.password_printing_mode = ini.debug.password;
mod_rdp_params.cache_verbose = ini.debug.cache;
mod_rdp_params.allow_channels = &(ini.mod_rdp.allow_channels);
mod_rdp_params.deny_channels = &(ini.mod_rdp.deny_channels);
mod_rdp mod(mod_trans, front, client_info, ini.mod_rdp.redir_info,
gen, mod_rdp_params);
run_mod(mod, front, front_event, &mod_trans, &front_trans);
if (client_sck != -1) {
shutdown(client_sck, 2);
close(client_sck);
}
if (persistent_key_list_ifd != -1) {
delete persistent_key_list_ift;
close(persistent_key_list_ifd);
}
if (record_fd != -1) {
delete record_oft;
close(record_fd);
}
}
} // try
catch (Error & e) {
LOG(LOG_ERR, "errid = %d", e.id);
}
front.disconnect();
if (persistent_key_list_ofd != -1) {
delete persistent_key_list_oft;
close(persistent_key_list_ofd);
}
shutdown(one_shot_server.sck, 2);
close(one_shot_server.sck);
LOG(LOG_INFO, "Listener closed\n");
LOG(LOG_INFO, "Incoming socket %d (ip=%s)\n", one_shot_server.sck, one_shot_server.ip_source);
return 0;
}
