PyObject *
PyRun_FileExFlags(FILE *fp, const char *filename_str, int start, PyObject *globals,
PyObject *locals, int closeit, PyCompilerFlags *flags)
{
PyObject *ret = NULL;
mod_ty mod;
PyArena *arena = NULL;
PyObject *filename;
filename = PyUnicode_DecodeFSDefault(filename_str);
if (filename == NULL)
goto exit;
arena = PyArena_New();
if (arena == NULL)
goto exit;
mod = PyParser_ASTFromFileObject(fp, filename, NULL, start, 0, 0,
flags, NULL, arena);
if (closeit)
fclose(fp);
if (mod == NULL) {
goto exit;
}
ret = run_mod(mod, filename, globals, locals, flags, arena);
exit:
Py_XDECREF(filename);
if (arena != NULL)
PyArena_Free(arena);
return ret;
}
PyObject *
PyRun_StringFlags(const char *str, int start, PyObject *globals,
PyObject *locals, PyCompilerFlags *flags)
{
PyObject *ret = NULL;
mod_ty mod;
PyArena *arena = PyArena_New();
if (arena == NULL)
return NULL;
mod = PyParser_ASTFromString(str, "<string>", start, flags, arena);
if (mod != NULL)
ret = run_mod(mod, "<string>", globals, locals, flags, arena);
PyArena_Free(arena);
return ret;
}
PyObject *
PyRun_FileExFlags(FILE *fp, const char *filename, int start, PyObject *globals,
PyObject *locals, int closeit, PyCompilerFlags *flags)
{
PyObject *ret;
mod_ty mod;
PyArena *arena = PyArena_New();
if (arena == NULL)
return NULL;
mod = PyParser_ASTFromFile(fp, filename, start, 0, 0,
flags, NULL, arena);
if (closeit)
fclose(fp);
if (mod == NULL) {
PyArena_Free(arena);
return NULL;
}
ret = run_mod(mod, filename, globals, locals, flags, arena);
PyArena_Free(arena);
return ret;
}
PyObject *
PyRun_StringFlags(const char *str, int start, PyObject *globals,
PyObject *locals, PyCompilerFlags *flags)
{
PyObject *ret = NULL;
mod_ty mod;
PyArena *arena;
PyObject *filename;
filename = _PyUnicode_FromId(&PyId_string); /* borrowed */
if (filename == NULL)
return NULL;
arena = PyArena_New();
if (arena == NULL)
return NULL;
mod = PyParser_ASTFromStringObject(str, filename, start, flags, arena);
if (mod != NULL)
ret = run_mod(mod, filename, globals, locals, flags, arena);
PyArena_Free(arena);
return ret;
}
// This function is expanded out from the Python library function
// PyRun_SimpleStringFlags(). We do this so we can tell the difference,
// and fail in the case of a parse error in the code text. The unit tests
// do contain code which should fail, but never any code that fails because
// it won't parse.
int CyPyRun_SimpleString(const char * command, PyObject * exception)
{
PyCompilerFlags *flags = NULL;
PyObject * m = PyImport_AddModule("__main__");
if (m == NULL)
return -1;
PyObject * d = PyModule_GetDict(m);
// v = PyRun_StringFlags(command, Py_file_input, d, d, flags);
PyArena *arena = PyArena_New();
if (arena == NULL)
return -1;
mod_ty mod = PyParser_ASTFromString(command, "<string>", Py_file_input, flags, arena);
if (mod == NULL) {
PyArena_Free(arena);
PyErr_Print();
return -2;
}
PyObject *ret = run_mod(mod, "<string>", d, d, flags, arena);
PyArena_Free(arena);
if (ret == NULL) {
int errcode = -1;
if (exception != 0) {
if (PyErr_ExceptionMatches(exception)) {
errcode = -3;
}
}
PyErr_Print();
return errcode;
}
Py_DECREF(ret);
if (Py_FlushLine())
PyErr_Clear();
return 0;
}
/* A PyRun_InteractiveOneObject() auxiliary function that does not print the
* error on failure. */
static int
PyRun_InteractiveOneObjectEx(FILE *fp, PyObject *filename,
PyCompilerFlags *flags)
{
PyObject *m, *d, *v, *w, *oenc = NULL, *mod_name;
mod_ty mod;
PyArena *arena;
const char *ps1 = "", *ps2 = "", *enc = NULL;
int errcode = 0;
_Py_IDENTIFIER(encoding);
_Py_IDENTIFIER(__main__);
mod_name = _PyUnicode_FromId(&PyId___main__); /* borrowed */
if (mod_name == NULL) {
return -1;
}
if (fp == stdin) {
/* Fetch encoding from sys.stdin if possible. */
v = _PySys_GetObjectId(&PyId_stdin);
if (v && v != Py_None) {
oenc = _PyObject_GetAttrId(v, &PyId_encoding);
if (oenc)
enc = PyUnicode_AsUTF8(oenc);
if (!enc)
PyErr_Clear();
}
}
v = _PySys_GetObjectId(&PyId_ps1);
if (v != NULL) {
v = PyObject_Str(v);
if (v == NULL)
PyErr_Clear();
else if (PyUnicode_Check(v)) {
ps1 = PyUnicode_AsUTF8(v);
if (ps1 == NULL) {
PyErr_Clear();
ps1 = "";
}
}
}
w = _PySys_GetObjectId(&PyId_ps2);
if (w != NULL) {
w = PyObject_Str(w);
if (w == NULL)
PyErr_Clear();
else if (PyUnicode_Check(w)) {
ps2 = PyUnicode_AsUTF8(w);
if (ps2 == NULL) {
PyErr_Clear();
ps2 = "";
}
}
}
arena = PyArena_New();
if (arena == NULL) {
Py_XDECREF(v);
Py_XDECREF(w);
Py_XDECREF(oenc);
return -1;
}
mod = PyParser_ASTFromFileObject(fp, filename, enc,
Py_single_input, ps1, ps2,
flags, &errcode, arena);
Py_XDECREF(v);
Py_XDECREF(w);
Py_XDECREF(oenc);
if (mod == NULL) {
PyArena_Free(arena);
if (errcode == E_EOF) {
PyErr_Clear();
return E_EOF;
}
return -1;
}
m = PyImport_AddModuleObject(mod_name);
if (m == NULL) {
PyArena_Free(arena);
return -1;
}
d = PyModule_GetDict(m);
v = run_mod(mod, filename, d, d, flags, arena);
PyArena_Free(arena);
if (v == NULL) {
return -1;
}
Py_DECREF(v);
flush_io();
return 0;
}
int
PyRun_InteractiveOneFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
{
PyObject *m, *d, *v, *w;
mod_ty mod;
PyArena *arena;
char *ps1 = "", *ps2 = "";
int errcode = 0;
v = PySys_GetObject("ps1");
if (v != NULL) {
v = PyObject_Str(v);
if (v == NULL)
PyErr_Clear();
else if (PyString_Check(v))
ps1 = PyString_AsString(v);
}
w = PySys_GetObject("ps2");
if (w != NULL) {
w = PyObject_Str(w);
if (w == NULL)
PyErr_Clear();
else if (PyString_Check(w))
ps2 = PyString_AsString(w);
}
arena = PyArena_New();
if (arena == NULL) {
Py_XDECREF(v);
Py_XDECREF(w);
return -1;
}
mod = PyParser_ASTFromFile(fp, filename,
Py_single_input, ps1, ps2,
flags, &errcode, arena);
Py_XDECREF(v);
Py_XDECREF(w);
if (mod == NULL) {
PyArena_Free(arena);
if (errcode == E_EOF) {
PyErr_Clear();
return E_EOF;
}
PyErr_Print();
return -1;
}
m = PyImport_AddModule("__main__");
if (m == NULL) {
PyArena_Free(arena);
return -1;
}
d = PyModule_GetDict(m);
v = run_mod(mod, filename, d, d, flags, arena);
PyArena_Free(arena);
if (v == NULL) {
PyErr_Print();
return -1;
}
Py_DECREF(v);
if (Py_FlushLine())
PyErr_Clear();
return 0;
}
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;
}
