NX/opennx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
opennx/MySession.cpp
geos_one 5e5aafa7b7 New upstream version 1.0.5
2025-08-08 20:34:09 +02:00

2397 lines
87 KiB
C++
Raw Blame History

// $Id: MySession.cpp 705 2012-03-16 13:01:13Z felfert $
//
// Copyright (C) 2006 The OpenNX Team
// Author: Fritz Elfert
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Library General Public
// License along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma implementation "SessionList.h"
#endif
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
#include "CardWaiterDialog.h"
#include "ConnectDialog.h"
#include "MySession.h"
#include "MyXmlConfig.h"
#include "MyIPC.h"
#include "ResumeDialog.h"
#include "WinShare.h"
#include "opennxApp.h"
#include "osdep.h"
#include "pwcrypt.h"
#include "ProxyPasswordDialog.h"
#include "SimpleXauth.h"
#include "Icon.h"
#include "SupressibleMessageDialog.h"
#include "PulseAudio.h"
#include <wx/filename.h>
#include <wx/regex.h>
#include <wx/wfstream.h>
#include <wx/txtstrm.h>
#include <wx/socket.h>
#include <wx/config.h>
#include <wx/utils.h>
#include <wx/tokenzr.h>
#include <wx/regex.h>
#include <wx/protocol/http.h>
#include <wx/sckstrm.h>
#include <wx/dir.h>
#include <wx/process.h>
#include <wx/textfile.h>
#ifdef __VISUALC__
# include <fstream.h>
#else
# include <fstream>
#endif
#ifndef __WXMSW__
# include <grp.h>
#endif
#ifdef __UNIX__
# include <X11/Xauth.h>
#endif
#include "trace.h"
ENABLE_TRACE;
static const int CUPS_PORT_OFFSET = 2000;
static const int SMB_PORT_OFFSET = 3000;
static const int PROXY_PORT_OFFSET = 4000;
static const int X_PORT_OFFSET = 6000;
static const int SOUND_PORT_OFFSET = 7000;
static const int KBD_PORT_OFFSET = 8000;
static const int HTTP_PORT_OFFSET = 9000;
static const int USBIP_PORT_OFFSET = 40000;
#define X11ARCH_NONE 0
#define X11ARCH_CYGWIN 1
#define X11ARCH_MINGW 2
#ifdef __WXMSW__
wxString cygPath(const wxString &dir, const wxString &file = wxEmptyString)
{
wxFileName fn(dir);
wxString ret = wxT("/cygdrive/");
ret += fn.GetVolume().Lower();
ret += fn.GetShortPath().AfterFirst(wxT(':'));
if (!file.IsEmpty())
ret << wxT("\\") << file;
ret.Replace(wxT("\\"), wxT("/"));
return ret;
}
class FontpathTraverser : public wxDirTraverser
{
public:
wxString GetFontPath(MySession::tXarch x11arch)
{
switch (x11arch) {
case MySession::XARCH_CYGWIN:
return m_sFontPathCygwin;
break;
case MySession::XARCH_XMING:
return m_sFontPath;
break;
default:
wxLogError(_("Invalid X11 server platform"));
break;
}
return wxEmptyString;
}
virtual wxDirTraverseResult OnFile(const wxString& WXUNUSED(filename))
{
return wxDIR_CONTINUE;
}
virtual wxDirTraverseResult OnDir(const wxString& dirname)
{
if (!m_sFontPath.IsEmpty())
m_sFontPath += wxT(",");
m_sFontPath += dirname;
if (!m_sFontPathCygwin.IsEmpty())
m_sFontPathCygwin += wxT(",");
m_sFontPathCygwin += cygPath(dirname);
return wxDIR_IGNORE;
}
private:
wxString m_sFontPath;
wxString m_sFontPathCygwin;
};
#else
wxString cygPath(const wxString &path)
{
return wxFileName(path).GetFullPath();
}
wxString cygPath(const wxString &dir, const wxString &file)
{
return wxFileName(dir, file).GetFullPath();
}
#endif
class RunLog : public wxLogChain
{
public:
RunLog(wxLog *logger) :wxLogChain(logger) { SetVerbose(true); }
void DoLogRecord(wxLogLevel level, const wxString & szString, const wxLogRecordInfo & info)
{
PassMessages(level <= minlevel);
wxLogChain::DoLogRecord((level > minlevel) ? minlevel : level, szString, info);
}
private:
static const wxLogLevel minlevel = wxLOG_Message;
};
class SessionCleaner : public wxDirTraverser
{
public:
SessionCleaner(const wxString &toplevel)
{
m_sTopLevel = toplevel;
wxString s = wxFileName::GetPathSeparator();
if (!toplevel.EndsWith(s))
m_sTopLevel += s;
wxString r = m_sTopLevel + wxT("temp") + s + wxT("([0-9]+)");
r.Replace(wxT("\\"), wxT("\\\\"));
m_cRegex.Compile(r, wxRE_ADVANCED);
wxASSERT(m_cRegex.IsValid());
}
~SessionCleaner()
{
wxLogNull nolog;
int n = m_aFiles.GetCount() - 1;
while (n >= 0)
::wxRemoveFile(m_aFiles[n--]);
n = m_aDirs.GetCount() - 1;
while (n >= 0)
::wxRmdir(m_aDirs[n--]);
}
virtual wxDirTraverseResult OnFile(const wxString &name)
{
for (size_t i = 0; i < m_aDirs.GetCount(); i++) {
if (name.StartsWith(m_aDirs[i])) {
myLogTrace(MYTRACETAG, wxT("adding file '%s'"), VMB(name));
m_aFiles.Add(name);
return wxDIR_CONTINUE;
}
}
return wxDIR_CONTINUE;
}
virtual wxDirTraverseResult OnDir(const wxString &name)
{
if (name.StartsWith(m_sTopLevel + wxT("S-"))) {
myLogTrace(MYTRACETAG, wxT("Session dir: '%s'"), VMB(name));
wxTextFile tf(name + wxFileName::GetPathSeparator() + wxT("session"));
if (tf.Exists()) {
wxString line;
if (tf.Open()) {
for (line = tf.GetFirstLine(); !tf.Eof(); line = tf.GetNextLine()) {
if (line.Contains(wxT("mode with pid"))) {
long pid;
line.AfterFirst(wxT('\'')).BeforeLast(wxT('\'')).ToLong(&pid);
myLogTrace(MYTRACETAG, wxT("Proxy-PID: %d"), (int)pid);
if (!wxProcess::Exists(pid)) {
myLogTrace(MYTRACETAG, wxT("PID does not exist, adding '%s'"),
VMB(name));
m_aDirs.Add(name);
return wxDIR_CONTINUE;
}
}
}
}
}
myLogTrace(MYTRACETAG, wxT("Keeping '%s'"), VMB(name));
}
if (name.StartsWith(m_sTopLevel + wxT("D-"))) {
myLogTrace(MYTRACETAG, wxT("Service dir: '%s'"), VMB(name));
wxTextFile tf(name + wxFileName::GetPathSeparator() + wxT("pid"));
if (tf.Exists()) {
long pid;
if (tf.Open()) {
tf.GetFirstLine().ToLong(&pid);
myLogTrace(MYTRACETAG, wxT("Service-PID: %d"), (int)pid);
if (!wxProcess::Exists(pid)) {
myLogTrace(MYTRACETAG, wxT("PID does not exist, adding '%s'"), VMB(name));
m_aDirs.Add(name);
return wxDIR_CONTINUE;
}
}
}
myLogTrace(MYTRACETAG, wxT("Keeping '%s'"), VMB(name));
}
if (name.StartsWith(m_sTopLevel + wxT("F-"))) {
myLogTrace(MYTRACETAG, wxT("Failed session dir: '%s'"), VMB(name));
m_aDirs.Add(name);
return wxDIR_CONTINUE;
}
if (m_cRegex.Matches(name)) {
myLogTrace(MYTRACETAG, wxT("Temp dir: '%s'"), VMB(name));
long mpid = 0;
long spid = 0;
m_cRegex.GetMatch(name, 1).ToLong(&mpid);
myLogTrace(MYTRACETAG, wxT("Main PID: %d"), (int)mpid);
wxTextFile tf(name + wxFileName::GetPathSeparator() + wxT("sshlog"));
if (tf.Exists()) {
if (tf.Open()) {
wxString line = tf.GetFirstLine();
line.AfterLast(wxT(':')).Strip(wxString::both).ToLong(&spid);
myLogTrace(MYTRACETAG, wxT("Ssh-PID: %d"), (int)spid);
}
}
if (mpid && (!wxProcess::Exists(mpid)) && ((!spid) || (!wxProcess::Exists(spid)))) {
myLogTrace(MYTRACETAG, wxT("PIDs do not exist, adding '%s'"), VMB(name));
m_aDirs.Add(name);
return wxDIR_CONTINUE;
}
myLogTrace(MYTRACETAG, wxT("Keeping '%s'"), VMB(name));
return wxDIR_IGNORE;
}
if (name.StartsWith(m_sTopLevel + wxT("temp")))
return wxDIR_CONTINUE;
return wxDIR_IGNORE;
}
private:
wxArrayString m_aDirs;
wxArrayString m_aFiles;
wxString m_sTopLevel;
wxRegEx m_cRegex;
};
DECLARE_EVENT_TYPE(wxEVT_SESSION, -6);
DEFINE_EVENT_TYPE(wxEVT_SESSION);
/**
* This class is a helper for watching a file until a specific
* string has appeared in it. When found, it triggers an event.
*/
class SessionWatch : public wxThreadHelper
{
public:
SessionWatch(wxEvtHandler *handler, const wxString &logfile, const wxString &search)
: wxThreadHelper()
{
m_pHandler = handler;
m_sLog = logfile;
m_sSearch = search;
if (CreateThread() == wxTHREAD_NO_ERROR)
GetThread()->Run();
}
private:
virtual wxThread::ExitCode Entry() {
wxStopWatch sw;
wxTextFile tf(m_sLog);
long timeout = 5000;
bool bFound = false;
while ((!bFound) && (sw.Time() < timeout)) {
if (tf.Exists()) {
if (timeout == 5000)
timeout = sw.Time() + 10000;
if (!tf.Open())
break;
wxString line;
for (line = tf.GetFirstLine(); !tf.Eof(); line = tf.GetNextLine()) {
if (line.Contains(m_sSearch)) {
bFound = true;
break;
}
}
tf.Close();
}
wxThread::Sleep(500);
}
if (m_pHandler) {
wxCommandEvent upevent(wxEVT_SESSION, wxID_ANY);
upevent.SetInt(bFound ? 1 : 0);
m_pHandler->AddPendingEvent(upevent);
}
return 0;
}
wxEvtHandler *m_pHandler;
wxString m_sLog;
wxString m_sSearch;
};
/**
* Our specialization of wxHTTP. Needed, because wxHTTP stops
* parsing headers when recognizing an error status header (4xx, 5xx ...)
* but we want it to continue parsing in order to get the Server: header.
*/
class MyHTTP : public wxHTTP {
public:
MyHTTP() : wxHTTP() {}
wxInputStream *GetInputStream(const wxString& path)
{
wxSocketInputStream *inp_stream;
wxString new_path;
m_lastError = wxPROTO_CONNERR;
if (!m_addr)
return NULL;
// We set m_connected back to false so wxSocketBase will know what to do.
#ifdef __WXMAC__
wxSocketClient::Connect(*m_addr , false );
wxSocketClient::WaitOnConnect(10);
if (!wxSocketClient::IsConnected())
return NULL;
#else
if (!wxProtocol::Connect(*m_addr))
return NULL;
#endif
if (!BuildRequest(path, m_postBuffer.IsEmpty() ? wxT("GET") : wxT("POST")))
return NULL;
inp_stream = new wxSocketInputStream(*this);
Notify(false);
SetFlags(wxSOCKET_BLOCK | wxSOCKET_WAITALL);
return inp_stream;
}
protected:
bool BuildRequest(const wxString& path, const wxString& method)
{
bool ret = wxHTTP::BuildRequest(path, method);
myLogTrace(MYTRACETAG, wxT("calling ParseHeaders()"));
ParseHeaders();
return ret;
}
};
IMPLEMENT_DYNAMIC_CLASS(MySession, wxEvtHandler);
BEGIN_EVENT_TABLE(MySession, wxEvtHandler)
EVT_COMMAND(wxID_ANY, wxEVT_NXSSH, MySession::OnSshEvent)
EVT_COMMAND(wxID_ANY, wxEVT_SESSION, MySession::OnSessionEvent)
END_EVENT_TABLE();
MySession::MySession(wxString dir, wxString status, wxString stype, wxString host, int port, wxString md5)
: wxEvtHandler()
, m_pSshLog(NULL)
, m_pNxSsh(NULL)
, m_pCfg(NULL)
, m_pDlg(NULL)
, m_pParent(NULL)
, m_pSessionWatch(NULL)
, m_bTouched(true)
, m_iPort(port)
, m_lPid(0)
, m_eSessionType(None)
, m_eSessionStatus(Unknown)
, m_sHost(host)
, m_sMd5(md5)
, m_sDir(dir)
{
m_bValid = false;
if (stype == wxT("C"))
m_eSessionType = Server;
if (stype == wxT("S"))
m_eSessionType = Client;
if (status == wxT("T"))
m_eSessionStatus = Terminated;
if (status == wxT("F"))
m_eSessionStatus = Failed;
m_rePID.Compile(wxT("([[:digit:]]+)"));
initversion();
CheckState();
}
MySession::MySession(const MySession &src)
: wxEvtHandler()
, m_pSshLog(NULL)
, m_pNxSsh(NULL)
, m_pCfg(NULL)
, m_pDlg(NULL)
, m_pParent(NULL)
, m_pSessionWatch(NULL)
{
m_sHost = src.m_sHost;
m_iPort = src.m_iPort;
m_lPid = src.m_lPid;
m_sMd5 = src.m_sMd5;
m_eSessionType = src.m_eSessionType;
m_eSessionStatus = src.m_eSessionStatus;
m_sDir = src.m_sDir;
m_bTouched = src.m_bTouched;
m_rePID.Compile(wxT("([[:digit:]]+)"));
m_iReader = src.m_iReader;
m_lProtocolVersion = src.m_lProtocolVersion;
m_lSrvProtocolVersion = src.m_lSrvProtocolVersion;
m_sProtocolVersion = src.m_sProtocolVersion;
}
MySession::MySession()
: wxEvtHandler()
, m_pSshLog(NULL)
, m_pNxSsh(NULL)
, m_pCfg(NULL)
, m_pDlg(NULL)
, m_pParent(NULL)
, m_pSessionWatch(NULL)
{
m_iReader = -1;
initversion();
}
MySession & MySession::operator =(const MySession &src)
{
m_pSshLog = NULL;
m_pCfg = NULL;
m_pDlg = NULL;
m_pNxSsh = NULL;
m_pParent = NULL;
m_pSessionWatch = NULL;
m_sHost = src.m_sHost;
m_iPort = src.m_iPort;
m_lPid = src.m_lPid;
m_iReader = src.m_iReader;
m_sMd5 = src.m_sMd5;
m_eSessionType = src.m_eSessionType;
m_eSessionStatus = src.m_eSessionStatus;
m_sDir = src.m_sDir;
m_bTouched = src.m_bTouched;
m_rePID.Compile(wxT("([[:digit:]]+)"));
m_lProtocolVersion = src.m_lProtocolVersion;
m_lSrvProtocolVersion = src.m_lSrvProtocolVersion;
m_sProtocolVersion = src.m_sProtocolVersion;
return *this;
}
MySession::~MySession()
{
myLogTrace(MYTRACETAG, wxT("~MySession"));
if (m_pSshLog) {
m_pSshLog->Flush();
delete m_pSshLog;
}
m_pSshLog = NULL;
if (m_pSessionWatch) {
delete m_pSessionWatch;
m_pSessionWatch = NULL;
}
wxLog *l = wxLog::SetActiveTarget(NULL);
if (l)
delete l;
}
wxString
MySession::sGetCreationTime()
{
wxString ret(_("unknown"));
if (m_bValid) {
wxLogNull l;
wxDateTime ctime;
wxFileName fn(m_sDir, wxT("session"));
if (fn.GetTimes(NULL, NULL, &ctime)) {
ret = ctime.Format();
}
}
return ret;
}
wxString
MySession::sGetSessionStatus()
{
switch (m_eSessionStatus) {
case Terminated:
return _("terminated");
break;
case Failed:
return _("failed");
break;
case Running:
return _("running");
break;
case Unknown:
return _("unknown");
break;
}
return _("unknown");
}
wxString
MySession::sGetSessionType()
{
switch (m_eSessionType) {
case Server:
return _("Server");
break;
case Client:
return _("Client");
break;
case None:
return _("Unknown");
break;
}
return _("Unknown");
}
bool
MySession::bGetPidFromFile()
{
m_lPid = 0;
if (!m_bValid)
return false;
wxFileInputStream input(m_sDir + wxFileName::GetPathSeparator() + wxT("session"));
wxTextInputStream text(input);
int cnt = 0;
while ((!input.Eof()) && (cnt < 100)) {
wxString line = text.ReadLine();
int idx = line.Find(wxT("pid"));
if (idx != wxNOT_FOUND &&
(!(line.Contains(wxT("NXAGENT")) || line.Contains(wxT("Agent")))))
{
line = line.Mid(idx + 4);
if (m_rePID.Matches(line))
m_rePID.GetMatch(line, 1).ToLong(&m_lPid);
}
cnt++;
}
return (m_lPid > 0);
}
void
MySession::CheckState()
{
wxString logfilename = m_sDir + wxFileName::GetPathSeparator() + wxT("session");
m_eSessionStatus = Unknown;
if (!wxFile::Exists(logfilename))
return;
if ((m_eSessionStatus == Terminated) || (m_eSessionStatus == Failed))
return;
wxFile fi(logfilename);
if (!fi.IsOpened())
return;
m_bValid = true;
wxFileInputStream input(fi);
wxTextInputStream text(input);
while (!input.Eof()) {
wxString line = text.ReadLine();
if (line.StartsWith(wxT("Session: Session terminated"))) {
m_eSessionStatus = Terminated;
break;
}
}
if (bGetPidFromFile()) {
if (wxProcess::Exists(m_lPid))
m_eSessionStatus = Running;
}
}
unsigned short
MySession::getFirstFreePort(unsigned short startPort)
{
#ifdef __WXMAC__
// wxSocketServer appears to be broken on wxMac,
// so we use plain unix code, implemented in osdep.c ...
return macFirstFreePort(startPort);
#else
unsigned short port = startPort;
wxIPV4address a;
a.LocalHost();
while (port < 65535) {
a.Service(port);
wxSocketServer ss(a);
if (ss.Ok())
return port;
port++;
}
#endif
return 0;
}
wxString
MySession::getXauthCookie(int display /* = 0 */, wxString proto)
{
#ifdef __UNIX__
wxString dpy;
wxString ret;
if (wxGetEnv(wxT("DISPLAY"), &dpy) && (!dpy.IsEmpty())) {
wxString dpyNr = dpy.AfterFirst(wxT(':'));
const char *fn = XauFileName();
FILE *f = fopen(fn, "r");
if (f) {
Xauth *auth = NULL;
// Fetch the first entry of FamilyLocal and a matching display number
while (ret.IsEmpty() && (NULL != (auth = XauReadAuth(f)))) {
if (FamilyLocal == auth->family) {
wxString edpy((const char *)auth->number, *wxConvCurrent, auth->number_length);
if (edpy.IsSameAs(dpyNr)) {
int i;
for (i = 0; i < auth->data_length; ++i) {
ret.Append(wxString::Format(wxT("%02x"), auth->data[i] & 0xff));
}
}
}
XauDisposeAuth(auth);
}
}
fclose(f);
}
return ret;
#endif
#ifdef __WXMSW__
// On windows we *create* the cookie instead
SimpleXauth xa(getXauthPath());
xa.AddDisplay(display);
return xa.GetCookie();
#else
wxUnusedVar(display);
wxUnusedVar(proto);
#endif
return wxEmptyString;
}
wxString
MySession::getXauthPath(tXarch xarch)
{
#ifdef __UNIX__
wxUnusedVar(xarch);
const char *xafn = XauFileName(); // static in libXau, DO NOT free() !!
return wxString(xafn, *wxConvCurrent);
#endif
#ifdef __WXMSW__
wxFileName fn;
switch (xarch) {
case XARCH_CYGWIN:
return cygPath(m_sUserDir, wxT(".Xauthority"));
case XARCH_XMING:
fn.Assign(m_sUserDir, wxT(".Xauthority"));
return fn.GetFullPath();
default:
wxLogError(_("Invalid X11 server platform"));
return wxEmptyString;
}
#endif
return wxEmptyString;
}
wxString
MySession::formatOptFilename()
{
#ifdef __WXMSW__
return cygPath(m_sOptFilename);
#else
return m_sOptFilename;
#endif
}
void
MySession::OnSessionEvent(wxCommandEvent &event)
{
if (event.GetInt())
m_bSessionEstablished = true;
else
m_bGotError = true;
}
void
MySession::SshLog(const wxChar *fmt, ...)
{
if (m_pSshLog) {
va_list args;
va_start(args, fmt);
wxLog *oldLog = wxLog::SetActiveTarget(m_pSshLog);
::wxVLogMessage(fmt, args);
wxLog::SetActiveTarget(oldLog);
va_end(args);
}
}
void
MySession::OnSshEvent(wxCommandEvent &event)
{
MyIPC::tSessionEvents e = wx_static_cast(MyIPC::tSessionEvents, event.GetInt());
wxString msg(event.GetString());
wxString scmd;
switch (e) {
case MyIPC::ActionNone:
case MyIPC::ActionStdout:
case MyIPC::ActionStderr:
break;
case MyIPC::ActionStatus:
m_pDlg->SetStatusText(msg);
break;
case MyIPC::ActionHello:
initversion(msg);
m_eConnectState = STATE_HELLO;
break;
case MyIPC::ActionLog:
m_pDlg->SetProgress(m_iProgress++);
if (m_bCollectSessions || m_bCollectResources)
m_aParseBuffer.Add(msg);
if (m_bCollectConfig) {
m_sConfigBuffer << msg << wxT("\n");
if (m_sConfigBuffer.Length() >= m_nSessionPushLength) {
wxLogInfo(wxT("session override finished"));
m_bCollectConfig = false;
m_pCfg->LoadFromString(m_sConfigBuffer, true);
if (m_pCfg->IsWritable())
m_pCfg->SaveToFile();
}
}
SshLog(msg);
break;
case MyIPC::ActionWarning:
{
wxString cfgid(wxT("sshwarn."));
SupressibleMessageDialog d(m_pParent, msg,
_("Warning - OpenNX"), wxOK|wxICON_EXCLAMATION);
d.ShowConditional(cfgid.Append(msg.Left(15)), wxID_OK);
}
break;
case MyIPC::ActionError:
wxLogError(msg);
m_bGotError = true;
break;
case MyIPC::ActionPromptYesNo:
{
wxString cfgid(wxT("sshyesno."));
SupressibleMessageDialog d(m_pParent, msg,
_("Warning - OpenNX"), wxYES_NO|wxICON_EXCLAMATION);
if (d.ShowConditional(cfgid.Append(msg.Left(15)), wxID_YES) == wxID_YES)
printSsh(wxT("yes"));
else {
printSsh(wxT("no"));
m_bGotError = true;
}
}
break;
case MyIPC::ActionKeyChangedYesNo:
{
wxString cfgid(wxT("sshkeychanged."));
msg << _("\nDo you want to delete the key and retry ?");
SupressibleMessageDialog d(m_pParent, msg,
_("Warning - OpenNX"), wxYES_NO|wxICON_EXCLAMATION);
if (d.ShowConditional(cfgid.Append(msg.Left(15)), wxID_YES) == wxID_YES)
m_bRemoveKey = true;
m_bGotError = true;
}
break;
case MyIPC::ActionOffendingKey:
m_sOffendingKey = msg;
break;
case MyIPC::ActionSendUsername:
{
// At this point key-based auth is finished and
// thus the key-file isn't needed anymore
wxLogNull logdummy;
wxFileName fn;
fn.Assign(m_sTempDir, wxT("keylog"));
if (fn.IsFileWritable())
::wxRemoveFile(fn.GetFullPath());
}
m_pDlg->SetStatusText(_("Sending username"));
//printSsh(m_pCfg->sGetSessionUser());
break;
case MyIPC::ActionSendPassword:
m_pDlg->SetStatusText(_("Authenticating"));
if (m_pCfg->bGetRememberPassword())
printSsh(m_pCfg->sGetSessionPassword(), false);
else
printSsh(m_sClearPassword, false);
break;
case MyIPC::ActionWelcome:
m_pDlg->SetStatusText(_("Authentication successful"));
m_eConnectState = (m_lProtocolVersion >= 0x00040000)
? STATE_LIST_RESOURCES : STATE_LIST_SESSIONS;
break;
case MyIPC::ActionSessionPushLength:
// Session file length: 213
msg.Mid(21).ToULong(&m_nSessionPushLength);
break;
case MyIPC::ActionSessionPushStart:
m_sConfigBuffer.Empty();
m_bCollectConfig = true;
wxLogInfo(wxT("receiving %d bytes of session override"),
(int)m_nSessionPushLength);
break;
case MyIPC::ActionNextCommand:
m_iProgress += 4;
m_pDlg->SetProgress(m_iProgress);
switch (m_eConnectState) {
case STATE_WAIT:
m_pDlg->SetStatusText(_("Waiting user prompt"));
break;
case STATE_INIT:
case STATE_ABORT:
break;
case STATE_HELLO:
m_pDlg->SetStatusText(_("Authenticating"));
printSsh(wxT("hello NXCLIENT - Version ") + m_sProtocolVersion);
m_eConnectState = STATE_SHELLMODE;
break;
case STATE_SHELLMODE:
scmd = wxT("SET SHELL_MODE SHELL\n");
scmd << wxT("SET AUTH_MODE PASSWORD\n");
scmd << wxT("login\n");
scmd << m_pCfg->sGetSessionUser();
printSsh(scmd);
m_eConnectState = STATE_LOGIN;
break;
// Do not delete it!
// Sending multiple messages at the same time does not
// correspond to the exchange protocol, but these messages
// are always sent in that order.
// FreeNX understands and correctly processes this.
// This does not give much startup acceleration, but still
// gives.
/*
printSsh(wxT("SET SHELL_MODE SHELL"));
m_eConnectState = STATE_AUTHMODE;
break;
case STATE_AUTHMODE:
printSsh(wxT("SET AUTH_MODE PASSWORD"));
m_eConnectState = STATE_LOGIN;
break;
case STATE_LOGIN:
printSsh(wxT("login"));
break;
*/
case STATE_LIST_RESOURCES:
m_pDlg->SetStatusText(_("Query server-side features"));
printSsh(wxT("resourcelist"));
m_eConnectState = STATE_PARSE_RESOURCES;
m_bNextCmd = false;
break;
case STATE_PARSE_RESOURCES:
// Server has sent list of attachable sessions
m_bCollectResources = false;
wxLogInfo(wxT("received end of feature list"));
parseResources();
// intentionally fall thru
case STATE_LIST_SESSIONS:
m_pDlg->SetStatusText(_("Query server-side sessions"));
scmd = wxT("listsession") + m_pCfg->sGetListParams(m_lProtocolVersion);
m_bInParseSessions = false;
printSsh(scmd);
m_eConnectState = STATE_PARSE_SESSIONS;
m_bNextCmd = false;
break;
case STATE_PARSE_SESSIONS:
m_bNextCmd = true;
if (m_bIsShadow) {
// Server has sent list of attachable sessions
m_bCollectSessions = false;
wxLogInfo(wxT("received end of attachable session list"));
parseSessions(false);
}
break;
case STATE_START_SESSION:
m_pDlg->SetStatusText(_("Starting session"));
scmd = wxT("startsession");
scmd << m_pCfg->sGetSessionParams(m_lProtocolVersion, true, m_sClearPassword);
printSsh(scmd);
m_eConnectState = STATE_FINISH;
break;
case STATE_ATTACH_VIEW_SESSION:
case STATE_ATTACH_SESSION:
m_pDlg->SetStatusText(_("Attaching to session"));
scmd = wxT("attachsession");
scmd << m_pCfg->sGetSessionParams(m_lProtocolVersion, false, m_sClearPassword)
<< wxT(" --display=\"") << m_sResumePort
<< wxT("\" --id=\"") << m_sResumeId << wxT("\"")
// TODO: Check, since which version this is supported
<< wxT(" --resize=\"1\"");
if (m_eConnectState == STATE_ATTACH_VIEW_SESSION)
scmd << wxT(" --shadowviewonly=\"1\"");
printSsh(scmd);
m_eConnectState = STATE_FINISH;
break;
case STATE_RESUME_SESSION:
m_pDlg->SetStatusText(_("Resuming session"));
scmd = wxT("restoresession");
scmd << m_pCfg->sGetSessionParams(m_lProtocolVersion, true, m_sClearPassword)
<< wxT(" --session=\"") << m_sResumeName
<< wxT("\" --type=\"") << m_sResumeType
<< wxT("\" --id=\"") << m_sResumeId << wxT("\"");
printSsh(scmd);
m_eConnectState = STATE_FINISH;
break;
case STATE_KILL_SESSION:
m_pDlg->SetStatusText(_("Terminate session"));
scmd = wxT("terminate --sessionid=\"");
scmd << m_sKillId << wxT("\"");
printSsh(scmd);
m_eConnectState = STATE_LIST_SESSIONS;
break;
case STATE_FINISH:
if (m_bGotError) {
m_eConnectState = STATE_ABORT;
printSsh(wxT("quit"), true, wxT("Mainloop: Got error, "));
}
break;
}
break;
case MyIPC::ActionPinDialog:
printSsh(wxGetPasswordFromUser(
_("Enter PIN for Smart Card access."), _("Smart Card PIN"),
wxEmptyString, m_pParent), false);
break;
case MyIPC::ActionPassphraseDialog:
scmd = ::wxGetPasswordFromUser(::wxGetTranslation(msg),
_("Enter passphrase"), wxEmptyString, m_pParent);
if (scmd.IsEmpty()) {
msg = _("Empty passphrase");
m_bGotError = true;
}
printSsh(scmd, false);
break;
case MyIPC::ActionSetShadowGeometry:
m_pDlg->SetStatusText(_("Negotiating session parameter"));
m_sShadowGeometry = msg;
break;
case MyIPC::ActionSetSessionID:
m_pDlg->SetStatusText(_("Negotiating session parameter"));
m_sSessionID = msg;
break;
case MyIPC::ActionSetProxyCookie:
m_pDlg->SetStatusText(_("Negotiating session parameter"));
m_sProxyCookie = msg;
break;
case MyIPC::ActionSetProxyIP:
m_pDlg->SetStatusText(_("Negotiating session parameter"));
m_sProxyIP = msg;
break;
case MyIPC::ActionSetSessionType:
m_pDlg->SetStatusText(_("Negotiating session parameter"));
m_sSessionType = msg;
break;
case MyIPC::ActionSetSessionCache:
m_pDlg->SetStatusText(_("Negotiating session parameter"));
m_sSessionCache = msg;
break;
case MyIPC::ActionSetSessionDisplay:
m_pDlg->SetStatusText(_("Negotiating session parameter"));
m_sSessionDisplay = msg;
break;
case MyIPC::ActionSetAgentCookie:
m_pDlg->SetStatusText(_("Negotiating session parameter"));
m_sAgentCookie = msg;
break;
case MyIPC::ActionSetSslTunneling:
m_pDlg->SetStatusText(_("Negotiating session parameter"));
m_bSslTunneling = (msg == wxT("1"));
break;
case MyIPC::ActionSetSubscription:
m_pDlg->SetStatusText(_("Negotiating session parameter"));
m_sSubscription = msg;
break;
case MyIPC::ActionSetSmbPort:
m_pDlg->SetStatusText(_("Negotiating session parameter"));
m_sSmbPort = msg;
break;
case MyIPC::ActionExit:
if (m_eConnectState == STATE_ABORT) {
m_bAbort = true;
} else {
if (m_eConnectState == STATE_FINISH) {
m_pDlg->SetStatusText(_("Starting session"));
msg = wxT("NX> 299 Switch connection to: ");
if (m_lProtocolVersion > 0x00020000) {
msg << wxT("NX mode: ")
<< (m_bSslTunneling ? wxT("encrypted") : wxT("unencrypted"))
<< wxT(" options: nx,options=")
<< formatOptFilename() << wxT(":") << m_sSessionDisplay;
} else {
msg << m_sProxyIP << wxT(":") << m_sProxyPort
<< wxT(" cookie: ") << m_sProxyCookie;
}
m_bSessionRunning = true;
wxString slog = m_sSessionDir;
slog << wxFileName::GetPathSeparator() << wxT("session");
m_pSessionWatch = new SessionWatch(this, slog,
wxT("Session: Session started at"));
printSsh(msg);
} else {
m_bSessionRunning = true;
}
}
break;
case MyIPC::ActionTerminated:
if ((m_eConnectState <= STATE_PARSE_SESSIONS) && (!m_bGotError) && (!m_bRemoveKey) && (m_sOffendingKey.IsEmpty())) {
msg = _("Unexpected termination of nxssh");
wxLogError(msg);
m_bGotError = true;
}
break;
case MyIPC::ActionStartProxy:
if (m_eConnectState == STATE_FINISH) {
m_pDlg->SetStatusText(_("Starting session"));
startSharing();
startProxy();
}
break;
case MyIPC::ActionSessionRunning:
m_bSessionRunning = true;
{
wxString slog = m_sSessionDir;
slog << wxFileName::GetPathSeparator() << wxT("session");
m_pSessionWatch = new SessionWatch(this, slog,
wxT("Session: Session started at"));
}
break;
case MyIPC::ActionSessionListStart:
// Server starts sending session list
wxLogInfo(wxT("receiving session list .."));
m_aParseBuffer.Empty();
m_bCollectSessions = true;
break;
case MyIPC::ActionSessionListEnd:
// Server has sent list of running & suspended sessions
m_bCollectSessions = false;
wxLogInfo(wxT("received end of session list"));
parseSessions((event.GetExtraLong() == 148) && (!m_bIsShadow));
break;
case MyIPC::ActionResList:
// NX4: Server starts sending resource info
wxLogInfo(wxT("receiving resource info .."));
m_aParseBuffer.Empty();
m_bCollectResources = true;
break;
}
}
void
MySession::initversion(const wxString &s /* = wxEmptyString */)
{
wxString s02; wxString s1 = s.BeforeFirst(wxT('-'), &s02);
m_lProtocolVersion = 0;
if (!::wxGetEnv(wxT("NX_PROTOCOL_VERSION"), &m_sProtocolVersion))
m_sProtocolVersion = wxT(NX_PROTOCOL_VERSION);
if (!s1.IsEmpty())
m_sProtocolVersion = s1;
wxStringTokenizer t(m_sProtocolVersion, wxT("."));
int digits = 0;
while (t.HasMoreTokens()) {
long n;
t.GetNextToken().ToLong(&n);
m_lProtocolVersion = (m_lProtocolVersion << 8) + n;
if (++digits > 3)
break;
}
while (digits++ < 3)
m_lProtocolVersion = (m_lProtocolVersion << 8);
myLogTrace(MYTRACETAG, wxT("protocol version: %08x"), (int)m_lProtocolVersion);
wxString s3; wxString s2 = s02.BeforeFirst(wxT('-'), &s3);
m_lSrvProtocolVersion = 0;
if (s3 != wxT("CE"))
return;
digits = 0; t.SetString(s2, wxT("."));
while (t.HasMoreTokens()) {
long n;
t.GetNextToken().ToLong(&n);
m_lSrvProtocolVersion = (m_lSrvProtocolVersion << 8) + n;
if (++digits > 3)
break;
}
myLogTrace(MYTRACETAG, wxT("server protocol version: %08x"), (int)m_lSrvProtocolVersion);
}
void
MySession::printSsh(const wxString &s, bool doLog /* = true */, const wxString &reason /* = wxT("") */)
{
if (m_pNxSsh) {
myLogTrace(MYTRACETAG, wxT("%ssending '%s'"), VMB(reason),
#ifdef __WXMSW__
(doLog ? VMB(s) : wxT("********")));
#else
(doLog ? VMB(s) : "********"));
#endif
m_pNxSsh->Print(s, doLog);
}
}
void
MySession::parseResources()
{
size_t n = m_aParseBuffer.GetCount();
myLogTrace(MYTRACETAG, wxT("parseResources: Got %d lines to parse"), (int)n);
wxRegEx re(wxT("^((?:session)|(?:service)|(?:feature))\\s+([^\\s]+)(?:\\s+([^\\s]+))?$"), wxRE_ADVANCED);
wxASSERT(re.IsValid());
for (size_t i = 0; i < n; i++) {
wxString line(m_aParseBuffer[i].Strip(wxString::both));
if (re.Matches(line) && (4 == re.GetMatchCount())) {
if (re.GetMatchCount() == 4) {
wxString sClass(re.GetMatch(line, 1));
wxString sType(re.GetMatch(line, 2));
wxString sValue(re.GetMatch(line, 3));
myLogTrace(MYTRACETAG, wxT("parseResources: match c='%s' t='%s', v='%s'"),
VMB(sClass), VMB(sType), VMB(sValue));
if (sClass.IsSameAs(wxT("session"))) {
// Not yet clear what to do with that data.
}
if (sClass.IsSameAs(wxT("service"))) {
// Not yet clear what to do with that data.
}
if (sClass.IsSameAs(wxT("feature"))) {
// Not yet clear what to do with that data.
}
}
} else
myLogTrace(MYTRACETAG, wxT("parseResources: NO match line='%s'"), VMB(line));
}
}
void
MySession::parseSessions(bool moreAllowed)
{
if (m_bInParseSessions)
return;
m_bInParseSessions = true;
size_t n = m_aParseBuffer.GetCount();
myLogTrace(MYTRACETAG, wxT("parseSessions: Got %d lines to parse"), (int)n);
wxRegEx re(
wxT("^(\\d+)\\s+([\\w-]+)\\s+([0-9A-F]{32})\\s+([A-Z-]{8})\\s+(\\d+)\\s+(\\d+x\\d+)\\s+(\\w+)\\s+([^\\s].*)$"),
wxRE_ADVANCED);
wxASSERT(re.IsValid());
wxRegEx re2(
wxT("^(\\d+)\\s+([\\w-]+)\\s+([0-9A-F]{32})\\s+([A-Z-]{8})\\s+(N/A)\\s+(N/A)\\s+(\\w+)\\s+([^\\s].*)$"),
wxRE_ADVANCED);
wxASSERT(re2.IsValid());
wxRegEx re3(
wxT("^(\\d+)\\s+(shadow)\\s+([0-9A-F]{32})\\s+([A-Z-]{8})\\s+(\\w+)\\s+([^\\s].*)$"),
wxRE_ADVANCED);
wxASSERT(re3.IsValid());
ResumeDialog d(NULL);
bool bFound = false;
int iSessionCount = 0;
wxString sName;
wxString sUser(m_pCfg->sGetSessionUser());
if (m_bIsShadow) {
d.SetAttachMode(true);
} else {
d.SetPreferredSession(m_pCfg->sGetName());
}
for (size_t i = 0; i < n; i++) {
wxString line = m_aParseBuffer[i].Trim();
myLogTrace(MYTRACETAG, wxT("parseSessions: line='%s'"), VMB(line));
if (re.Matches(line)) {
myLogTrace(MYTRACETAG, wxT("parseSessions: re match"));
wxString sPort(re.GetMatch(line, 1));
wxString sType(re.GetMatch(line, 2));
wxString sId(re.GetMatch(line, 3));
wxString sOpts(re.GetMatch(line, 4));
wxString sColors(re.GetMatch(line, 5));
wxString sSize(re.GetMatch(line, 6));
wxString sState(re.GetMatch(line, 7));
sName = re.GetMatch(line, 8);
if (m_bIsShadow) {
// In shadow session mode, a username follows the session name.
// Our RE matches both in sName, so we have to split off the usernam.
sUser = sName.AfterLast(wxT(' '));
sName = sName.BeforeLast(wxT(' ')).Trim();
}
d.AddSession(sName, sState, sType, sSize, sColors, sPort, sOpts, sId, sUser);
bFound = true;
iSessionCount++;
continue;
}
if (re2.Matches(line)) {
myLogTrace(MYTRACETAG, wxT("parseSessions: re2 match"));
wxString sPort(re2.GetMatch(line, 1));
wxString sType(re2.GetMatch(line, 2));
wxString sId(re2.GetMatch(line, 3));
wxString sOpts(re2.GetMatch(line, 4));
wxString sColors(re2.GetMatch(line, 5));
wxString sSize(re2.GetMatch(line, 6));
wxString sState(re2.GetMatch(line, 7));
sName = re2.GetMatch(line, 8);
if (m_bIsShadow) {
// In shadow session mode, a username follows the session name.
// Our RE matches both in sName, so we have to split off the usernam.
sUser = sName.AfterLast(wxT(' '));
sName = sName.BeforeLast(wxT(' ')).Trim();
}
d.AddSession(sName, sState, sType, sSize, sColors, sPort, sOpts, sId, sUser);
bFound = true;
iSessionCount++;
continue;
}
if (m_bIsShadow && re3.Matches(line)) {
myLogTrace(MYTRACETAG, wxT("parseSessions: re3 match"));
wxString sPort(re3.GetMatch(line, 1));
wxString sType(re3.GetMatch(line, 2));
wxString sId(re3.GetMatch(line, 3));
wxString sOpts(re3.GetMatch(line, 4));
wxString sColors;
wxString sSize;
wxString sState(re3.GetMatch(line, 5));
sName = re3.GetMatch(line, 6);
sUser = wxT("");
d.AddSession(sName, sState, sType, sSize, sColors, sPort, sOpts, sId, sUser);
bFound = true;
iSessionCount++;
continue;
}
myLogTrace(MYTRACETAG, wxT("parseSessions: NO match"));
}
if (bFound) {
d.EnableNew(moreAllowed);
if ((!m_bIsShadow) && wxGetApp().AutoResume() && (iSessionCount == 1) && (sName.IsSameAs(m_pCfg->sGetName()))) {
wxLogInfo(wxT("RESUME"));
m_sResumeName = sName;
m_sResumeType = d.GetSelectedType();
m_sResumeId = d.GetSelectedId();
m_eConnectState = STATE_RESUME_SESSION;
} else {
m_eConnectState = STATE_WAIT;
switch (d.ShowModal()) {
case wxID_OK:
myLogTrace(MYTRACETAG, wxT("ResumeDialog returned OK"));
switch (d.GetMode()) {
case ResumeDialog::Refresh:
wxLogInfo(wxT("REFRESH"));
m_eConnectState = STATE_LIST_SESSIONS;
printSsh(wxEmptyString);
break;
case ResumeDialog::Terminate:
wxLogInfo(wxT("TERMINATE"));
m_sKillId = d.GetSelectedId();
m_eConnectState = STATE_KILL_SESSION;
printSsh(wxEmptyString);
break;
case ResumeDialog::Resume:
wxLogInfo(wxT("RESUME"));
m_sResumeName = d.GetSelectedName();
m_sResumeType = d.GetSelectedType();
m_sResumeId = d.GetSelectedId();
m_sResumePort = d.GetSelectedPort();
m_eConnectState = m_bIsShadow ? STATE_ATTACH_SESSION : STATE_RESUME_SESSION;
printSsh(wxEmptyString);
break;
case ResumeDialog::Takeover:
wxLogInfo(wxT("TAKEOVER"));
m_sResumeName = d.GetSelectedName();
m_sResumeType = d.GetSelectedType();
m_sResumeId = d.GetSelectedId();
if (m_bIsShadow)
m_sResumePort = d.GetSelectedPort();
m_eConnectState = m_bIsShadow ? STATE_ATTACH_VIEW_SESSION : STATE_RESUME_SESSION;
printSsh(wxEmptyString);
break;
case ResumeDialog::New:
m_eConnectState = STATE_START_SESSION;
printSsh(wxEmptyString);
break;
}
if (m_bNextCmd) {
wxCommandEvent upevent(wxEVT_NXSSH, wxID_ANY);
upevent.SetInt(MyIPC::ActionNextCommand);
AddPendingEvent(upevent);
}
break;
case wxID_CANCEL:
printSsh(wxT("quit"), true, wxT("ResumeDialog returned CANCEL, "));
m_eConnectState = STATE_ABORT;
break;
}
}
} else {
if (m_bIsShadow) {
m_eConnectState = STATE_ABORT;
m_bGotError = true;
m_bAbort = true;
printSsh(wxT("quit"), true, wxT("No sessions to attach, "));
wxMessageDialog d(m_pParent,
_("There are no sessions which can be attached to."),
_("Error - OpenNX"), wxOK);
d.SetIcon(CreateIconFromFile(wxT("res/nx.png")));
d.ShowModal();
} else {
if (moreAllowed)
m_eConnectState = STATE_START_SESSION;
else {
printSsh(wxT("quit"), true, wxT("No more sessions allowed, "));
wxMessageDialog d(m_pParent,
_("You have reached your session limit. No more sessions allowed"),
_("Error - OpenNX"), wxOK);
d.SetIcon(CreateIconFromFile(wxT("res/nx.png")));
d.ShowModal();
m_bGotError = true;
}
}
}
}
void
MySession::startSharing()
{
if (!m_pCfg->bGetUseCups() && !m_pCfg->bGetEnableSmbSharing())
return;
ArrayOfShareGroups sg = m_pCfg->aGetShareGroups();
wxArrayString used = m_pCfg->aGetUsedShareGroups();
CupsClient cc;
SmbClient sc;
ArrayOfShares sa;
if (m_pCfg->bGetUseCups() && cc.IsAvailable())
sa = cc.GetShares();
if (m_pCfg->bGetEnableSmbSharing() && sc.IsAvailable())
WX_APPEND_ARRAY(sa, sc.GetShares());
long cupsport;
long smbport;
m_sSessionDisplay.ToLong(&cupsport);
m_sSessionDisplay.ToLong(&smbport);
cupsport += CUPS_PORT_OFFSET;
smbport += SMB_PORT_OFFSET;
for (size_t i = 0; i < sg.GetCount(); i++) {
if (used.Index(sg[i].m_sGroupName) == wxNOT_FOUND)
continue;
bool bAvailable = false;
wxString sn = sg[i].m_sShareName;
myLogTrace(MYTRACETAG, wxT("startSharing: considering share '%s'"), VMB(sn));
for (size_t j = 0; j < sa.GetCount(); j++) {
if ((sa[j].sharetype == sg[i].m_eType) && (sa[j].name == sn)) {
bAvailable = true;
break;
}
}
myLogTrace(MYTRACETAG, wxT("'%s' is %savailable"), VMB(sn),
(bAvailable ? "" : "not "));
if (!bAvailable)
continue;
wxString shcmd;
switch (sg[i].m_eType) {
case SharedResource::SHARE_UNKNOWN:
break;
case SharedResource::SHARE_SMB_DISK:
shcmd = wxT("addmount");
shcmd
<< wxT(" --port=\"") << smbport << wxT("\"")
<< wxT(" --username=\"")
<< MyXmlConfig::UrlEsc(sg[i].m_sUsername) << wxT("\"")
<< wxT(" --password=\"")
<< MyXmlConfig::UrlEsc(sg[i].m_sPassword) << wxT("\"")
<< wxT(" --share=\"") << MyXmlConfig::UrlEsc(sn) << wxT("\"")
<< wxT(" --computername=\"")
<< MyXmlConfig::UrlEsc(::wxGetFullHostName()) << wxT("\"")
<< wxT(" --session_id=\"") << m_sSessionID.Right(32) << wxT("\"")
<< wxT(" --dir=\"")
<< MyXmlConfig::UrlEsc(sg[i].m_sAlias) << wxT("\"");
printSsh(shcmd);
break;
case SharedResource::SHARE_SMB_PRINTER:
shcmd = wxT("addprinter");
shcmd << wxT(" --type=\"smb\"")
<< wxT(" --username=\"")
<< MyXmlConfig::UrlEsc(sg[i].m_sUsername) << wxT("\"")
<< wxT(" --password=\"")
<< MyXmlConfig::UrlEsc(sg[i].m_sPassword) << wxT("\"")
<< wxT(" --port=\"") << (int)smbport << wxT("\"")
<< wxT(" --share=\"") << MyXmlConfig::UrlEsc(sn) << wxT("\"")
<< wxT(" --computername=\"")
<< MyXmlConfig::UrlEsc(::wxGetHostName()) << wxT("\"")
<< wxT(" --session_id=\"") << m_sSessionID.Right(32) << wxT("\"")
<< wxT(" --model=\"") << sg[i].m_sDriver << wxT("\"");
if (sg[i].m_bDefault)
shcmd << wxT(" --defaultprinter=\"1\"");
if (sg[i].m_bPublic)
shcmd << wxT(" --public=\"1\"");
printSsh(shcmd);
break;
case SharedResource::SHARE_CUPS_PRINTER:
shcmd = wxT("addprinter");
shcmd << wxT(" --type=\"ipp\"")
<< wxT(" --username=\"") << MyXmlConfig::UrlEsc(sg[i].m_sUsername) << wxT("\"")
<< wxT(" --port=\"") << cupsport << wxT("\"")
<< wxT(" --session_id=\"") << m_sSessionID.Right(32) << wxT("\"")
<< wxT(" --printer=\"") << MyXmlConfig::UrlEsc(sn) << wxT("\"")
<< wxT(" --password=\"")
<< MyXmlConfig::UrlEsc(sg[i].m_sPassword) << wxT("\"")
<< wxT(" --model=\"cups%20printer\"");
if (sg[i].m_bDefault)
shcmd << wxT(" --defaultprinter=\"1\"");
if (sg[i].m_bPublic)
shcmd << wxT(" --public=\"1\"");
printSsh(shcmd);
break;
}
}
}
void
MySession::checkXarch()
{
m_eXarch = XARCH_NONE;
#ifdef __WXMSW__
wxFileName fn(m_sSysDir, wxT("nxwin.exe"));
fn.AppendDir(wxT("bin"));
if (fn.IsFileExecutable()) {
m_eXarch = XARCH_CYGWIN;
return;
}
fn.SetFullName(wxT("XMing.exe"));
if (fn.IsFileExecutable())
m_eXarch = XARCH_XMING;
#endif
}
#ifdef __WXMSW__
wxString
MySession::getXfontPath(tXarch Xarch)
{
wxLogNull l;
wxFileName fn(m_sSysDir, wxEmptyString);
fn.AppendDir(wxT("share"));
fn.AppendDir(wxT("fonts"));
wxDir d(fn.GetShortPath());
FontpathTraverser t;
d.Traverse(t);
wxString ret = t.GetFontPath(Xarch);
if (!ret.IsEmpty())
ret.Prepend(wxT(" -fp "));
return ret;
}
void
MySession::unhideNXWin()
{
if (XARCH_CYGWIN == m_eXarch) {
// Required only for NXWin - Xming shows up by itself
DWORD stored_nxserver_version = ::RegisterWindowMessage(wxT("STORED_NXSERVER_VERSION"));
HWND h = ::GetTopWindow(0);
while (h) {
wxString wclass;
int r = GetClassName(h, wxStringBuffer(wclass,40), 38);
if ((r > 0) && wclass.Contains(wxT("cygwin/xfree86"))) {
DWORD pid;
GetWindowThreadProcessId(h, &pid);
if ((int)pid == m_iXserverPID) {
// Trigger unhiding of fullscreen NXWin
SendMessage(h, WM_USER + 1, 0, 0);
// Trigger for worked close button NXWin
::SendMessage(h, stored_nxserver_version, 1, 1);
SetForegroundWindow(h);
break;
}
}
h = ::GetNextWindow(h , GW_HWNDNEXT);
}
}
}
void
MySession::terminateXserver()
{
// nxwin and nonencrypted: keep running (here we need it?)
if ((XARCH_CYGWIN == m_eXarch) && (!m_bSslTunneling))
return;
// Xming non-fullscreen: keep running
if ((XARCH_CYGWIN == m_eXarch) ||
(MyXmlConfig::DPTYPE_FULLSCREEN == m_pCfg->eGetDisplayType())) {
if ((0 != m_iXserverPID) && wxProcess::Exists(m_iXserverPID))
wxProcess::Kill(m_iXserverPID, wxSIGKILL, wxKILL_NOCHILDREN);
}
}
bool
MySession::startXserver()
{
int display = getFirstFreePort(X_PORT_OFFSET);
myLogTrace(MYTRACETAG, wxT("startXServer first free port is %d"), display);
if (0 == display)
return false;
display -= X_PORT_OFFSET;
wxString dpyStr = wxT(":");
dpyStr << display;
wxString wxWinCmd;
wxFileName fn(m_sSysDir, wxT("nxwin.exe"));
fn.AppendDir(wxT("bin"));
switch (m_eXarch) {
case XARCH_CYGWIN:
m_sXauthCookie = getXauthCookie(display, wxT("/unix"));
if (m_sXauthCookie.IsEmpty()) {
wxLogError(_("Could not create X11 authentication cookie"));
return false;
}
wxWinCmd = fn.GetShortPath();
wxWinCmd << wxT(" -nowinkill");
wxWinCmd << wxT(" -clipboard");
wxWinCmd << wxT(" -noloadxkb");
wxWinCmd << wxT(" -agent");
wxWinCmd << wxT(" -hide");
wxWinCmd << wxT(" -noreset");
wxWinCmd << wxT(" -auth ") << getXauthPath(XARCH_CYGWIN);
wxWinCmd << wxT(" -nolisten tcp");
wxWinCmd << getXfontPath(m_eXarch);
wxWinCmd << m_pCfg->sGetXserverParams(true);
if ( ( (m_pCfg->eGetDesktopType() == MyXmlConfig::DTYPE_CUSTOM) &&
(!m_pCfg->bGetVirtualDesktop())
) ||
( (m_pCfg->eGetSessionType() == MyXmlConfig::STYPE_WINDOWS) &&
(m_pCfg->bGetRdpRootless())
) ||
( (m_pCfg->eGetSessionType() == MyXmlConfig::STYPE_VNC) &&
(m_pCfg->bGetVncRootless())
)
)
wxWinCmd << wxT(" -multiwindow ");
else if (m_pCfg->eGetDisplayType()==MyXmlConfig::DPTYPE_NODECORATION)
wxWinCmd << wxT(" -nodecoration");
{
wxString title = m_pCfg->sGetUsername();
if (m_pCfg->bGetGuestMode()) {
title = m_pCfg->sGetGuestUser();
if (title.IsEmpty())
title << wxT("guest");
}
wxWinCmd << wxT(" -name ") << title << wxT("@") << m_pCfg->sGetName();
}
/* Warning from Djelf: format of cmd string at its end
always MUST BE "-name <name@addr> :<display>" */
wxWinCmd << wxT(" ") << dpyStr;
break;
case XARCH_XMING:
if (m_pCfg->eGetDisplayType() != MyXmlConfig::DPTYPE_FULLSCREEN) {
// If not fullscreen, we use a single instance of Xming, running in
// multiwindow mode. In this case, we check for a running Xming, by
// using a win32 named mutex.
int xdpy = getXmingPort(display + X_PORT_OFFSET);
if (0 != xdpy) {
dpyStr = wxT("127.0.0.1:");
dpyStr << xdpy - X_PORT_OFFSET;
::wxSetEnv(wxT("DISPLAY"), dpyStr);
wxLogInfo(wxT("env: DISPLAY='%s'"), VMB(dpyStr));
// Xauth cookie and X<dpy>.hosts are still existing
// from initial startup
return true;
}
}
fn.SetFullName(wxT("Xming.exe"));
m_sXauthCookie = getXauthCookie(display, wxEmptyString);
if (m_sXauthCookie.IsEmpty()) {
wxLogError(_("Could not create X11 authentication cookie"));
return false;
}
wxWinCmd = fn.GetShortPath();
wxWinCmd << wxT(" ") << dpyStr;
fn.Assign(m_sUserDir, wxString::Format(wxT("X%d.log"), (int)display));
wxWinCmd << wxT(" -logfile \"") << fn.GetFullPath() << wxT("\"");
wxWinCmd << wxT(" -br");
wxWinCmd << wxT(" -nowinkill");
wxWinCmd << wxT(" -clipboard ");
switch (m_pCfg->iGetClipFilter()) {
case 0:
wxWinCmd << wxT("primary");
break;
case 1:
wxWinCmd << wxT("clipboard");
break;
case 2:
wxWinCmd << wxT("both");
break;
}
wxWinCmd << wxT(" -notrayicon");
wxWinCmd << getXfontPath(m_eXarch);
wxWinCmd << wxT(" -silent-dup-error");
if (::checkMultiMonitors() > 1)
wxWinCmd << wxT(" -multimonitors");
wxWinCmd << m_pCfg->sGetXserverParams(false);
fn.Assign(m_sSysDir, wxEmptyString);
fn.AppendDir(wxT("share"));
fn.AppendDir(wxT("Xming"));
fn.MakeAbsolute();
::wxSetEnv(wxT("XMING_BASEDIR"), fn.GetPath());
wxLogInfo(wxT("env: XMING_BASEDIR='%s'"), VMB(fn.GetPath()));
dpyStr.Prepend(wxT("127.0.0.1"));
break;
default:
wxLogError(_("No X server found."));
return false;
break;
}
wxLogInfo(wxT("Executing %s"), VMB(wxWinCmd));
int r = CreateDetachedProcess(wxWinCmd.ToUTF8());
if (r != 0) {
wxLogError(_("Could not execute %s: %s\n"), VMB(wxWinCmd), wxSysErrorMsg(r));
return false;
}
m_iXserverPID = GetDetachedPID();
AllowSetForegroundWindow(m_iXserverPID);
::wxSetEnv(wxT("DISPLAY"), dpyStr);
wxLogInfo(wxT("env: DISPLAY='%s'"), VMB(dpyStr));
return true;
}
#endif
void
MySession::startProxy()
{
myLogTrace(MYTRACETAG, wxT("MySession::startProxy() called"));
long cupsport = m_pCfg->iGetCupsPort();
wxString popts;
if (m_lProtocolVersion >= 0x00030000)
popts << wxT("nx/");
popts << wxT("nx,cookie=") << m_sProxyCookie;
if (m_lProtocolVersion < 0x00030000)
popts << wxT(",root=") << cygPath(m_sUserDir);
popts << m_pCfg->sGetProxyParams(m_lProtocolVersion);
if (!m_sSubscription.IsEmpty())
popts << wxT(",product=") << m_sSubscription;
if (m_pCfg->bGetEnableSmbSharing()) {
SmbClient sc;
if (sc.IsAvailable()) {
if (m_sSmbPort.IsEmpty()) {
popts << wxT(",samba=") << m_pCfg->iGetSmbPort();
} else {
popts << wxT(",samba=") << m_sSmbPort;
}
}
}
if ((getActiveCupsPrinters().GetCount() > 0) && (isCupsRunning()))
popts << wxT(",cups=") << cupsport;
#ifdef SUPPORT_USBIP
if (m_pCfg->bGetEnableUSBIP())
popts << wxT(",http=") << wxConfigBase::Get()->Read(wxT("Config/UsbipPort"), 3420);
#endif
if ((m_bEsdRunning || m_bNativePARunning) && (0 < m_lEsdPort))
popts << wxT(",media=") << m_lEsdPort;
popts
<< wxT(",encryption=") << (m_bSslTunneling ? 1 : 0)
<< wxT(",session=session");
popts << wxT(",id=") << m_sSessionID;
if (m_bSslTunneling) {
if (m_lProtocolVersion <= 0x00020000) {
m_sProxyIP = wxT("127.0.0.1");
m_sProxyPort = wxString::Format(wxT("%d"), (int)getFirstFreePort(PROXY_PORT_OFFSET));
popts << wxT(",listen=") << m_sProxyPort;
}
} else
popts << wxT(",connect=") << m_sProxyIP;
// Undocumented feature of the original:
// If a file ~/.nx/options exists, it's content is
// appended to the regular options.
wxFileName mergeOpts(m_sUserDir, wxT("options"));
if (mergeOpts.FileExists()) {
wxLogNull dummy;
wxTextFile f(mergeOpts.GetFullPath());
if (f.Open()) {
wxString mopts = f.GetFirstLine().Strip(wxString::both);
if (!mopts.IsEmpty()) {
if ((!popts.IsEmpty()) && (!mopts.StartsWith(wxT(","))))
popts << wxT(",");
popts << mopts;
}
f.Close();
}
}
popts << wxT(":") << m_sSessionDisplay;
/* but in nxclient now is:
popts << wxT(",display=:0:") << m_sSessionDisplay;
*/
m_sSessionDir = m_sUserDir;
m_sSessionDir << wxFileName::GetPathSeparator()
<< wxT("S-") << m_sSessionID;
{
if (!wxFileName::Mkdir(m_sSessionDir, 0700, wxPATH_MKDIR_FULL)) {
wxLogSysError(_("Could not create session directory\n%s\n"),
VMB(m_sSessionDir));
m_bGotError = true;
}
m_sOptFilename = m_sSessionDir;
m_sOptFilename << wxFileName::GetPathSeparator() << wxT("options");
wxFile f;
if (f.Open(m_sOptFilename, wxFile::write, wxS_IRUSR|wxS_IWUSR)) {
f.Write(popts + wxT("\n"));
f.Close();
wxLogInfo(wxT("Option file='%s'\n"), VMB(m_sOptFilename));
wxLogInfo(wxT("Session options='%s'\n"), VMB(popts));
wxString pcmd;
wxConfigBase::Get()->Read(wxT("Config/SystemNxDir"), &pcmd);
pcmd << wxFileName::GetPathSeparator() << wxT("bin")
<< wxFileName::GetPathSeparator() << wxT("nxproxy -S nx,options=")
<< cygPath(m_sOptFilename) << wxT(":") << m_sSessionDisplay;
printSsh(wxT("bye"), true, wxT("Options file written, "));
if (m_lProtocolVersion <= 0x00020000) {
wxLogInfo(wxT("Executing %s"), VMB(pcmd));
#ifdef __WXMSW__
if (m_eXarch == XARCH_XMING)
CreateDetachedProcess(pcmd.ToUTF8());
if (m_iXserverPID)
AllowSetForegroundWindow(m_iXserverPID);
#else
setTurboPath(true);
::wxExecute(pcmd, wxEXEC_ASYNC);
setTurboPath(false);
#endif
}
} else {
wxLogSysError(_("Could not write session options\n%s\n"),
VMB(m_sOptFilename));
m_bGotError = true;
}
}
}
ArrayOfShareGroups
MySession::getActiveCupsPrinters()
{
ArrayOfShareGroups ret;
if (!m_pCfg->bGetUseCups())
return ret;
CupsClient cc;
if (cc.IsAvailable()) {
ArrayOfShares sa = cc.GetShares();
ret = m_pCfg->aGetShareGroups();
wxArrayString used = m_pCfg->aGetUsedShareGroups();
for (size_t i = ret.GetCount(); i > 0; i--) {
size_t idx = i - 1;
if (used.Index(ret[idx].m_sGroupName) == wxNOT_FOUND) {
myLogTrace(MYTRACETAG, wxT("removing[%d] '%s'"),
(int)idx, VMB(ret[idx].m_sShareName));
ret.RemoveAt(idx);
continue;
}
if (ret[idx].m_eType != SharedResource::SHARE_CUPS_PRINTER) {
myLogTrace(MYTRACETAG, wxT("removing[%d] '%s'"),
(int)idx, VMB(ret[idx].m_sShareName));
ret.RemoveAt(idx);
continue;
}
bool bAvailable = false;
myLogTrace(MYTRACETAG, wxT("Considering CUPS printer '%s' %d"),
VMB(ret[idx].m_sShareName), (int)idx);
for (size_t j = 0; j < sa.GetCount(); j++) {
if (sa[j].name == ret[idx].m_sShareName) {
bAvailable = true;
break;
}
}
myLogTrace(MYTRACETAG, wxT("'%s' is %savailable"),
VMB(ret[idx].m_sShareName),
(bAvailable ? "" : "not "));
if (!bAvailable) {
myLogTrace(MYTRACETAG, wxT("removing[%d] '%s'"),
(int)idx, VMB(ret[idx].m_sShareName));
ret.RemoveAt(idx);
}
}
}
myLogTrace(MYTRACETAG, wxT("# of active printers: %d"), (int)ret.GetCount());
return ret;
}
bool
MySession::isCupsRunning()
{
bool ret = m_bCupsRunning;
if (!ret) {
CupsClient cc;
ret = cc.IsAvailable();
m_bCupsRunning = ret;
}
myLogTrace(MYTRACETAG, wxT("isCupsRunning returning %s"), (ret ? "true" : "false"));
return ret;
}
void
MySession::setTurboPath(bool enable)
{
#ifdef __WXMAC__
return;
wxString ldpath;
bool isset = ::wxGetEnv(wxT("DYLD_LIBRARY_PATH"), &ldpath);
bool contains = isset && ldpath.Contains(wxT("libjpeg-turbo"));
if (enable) {
if (!contains) {
# if defined(__x86_64) || defined(__IA64__)
wxString archlib = wxT("lib64");
# else
wxString archlib = wxT("lib");
# endif
wxString turbopath;
wxFileName tjpeg;
tjpeg.AssignDir(wxT("/usr"));
tjpeg.AppendDir(archlib);
tjpeg.AppendDir(wxT("libjpeg-turbo"));
if (tjpeg.DirExists()) {
turbopath = tjpeg.GetPath();
ldpath.Prepend(tjpeg.GetPath().Append(wxT(":")));
} else {
tjpeg.AssignDir(wxT("/opt/libjpeg-turbo"));
tjpeg.AppendDir(archlib);
if (tjpeg.DirExists()) {
turbopath = tjpeg.GetPath();
ldpath.Prepend(tjpeg.GetPath().Append(wxT(":")));
}
}
if (!turbopath.IsEmpty()) {
if (!ldpath.IsEmpty())
ldpath.Prepend(wxT(":"));
ldpath.Prepend(turbopath);
}
::myLogDebug(wxT("DYLD_LIBRARY_PATH='%s'"), VMB(ldpath));
if (!::wxSetEnv(wxT("DYLD_LIBRARY_PATH"), ldpath)) {
wxLogSysError(wxT("Cannot set DYLD_LIBRARY_PATH"));
}
}
} else {
if (contains) {
wxString newpath;
wxStringTokenizer t(ldpath, wxT(":"));
while (t.HasMoreTokens()) {
wxString fragment = t.GetNextToken();
if ((!fragment.IsEmpty()) && (!fragment.Contains(wxT("libjpeg-turbo")))) {
if (!newpath.IsEmpty())
newpath.Append(wxT(":"));
newpath.Append(fragment);
}
}
if (newpath.IsEmpty()) {
::wxUnsetEnv(wxT("DYLD_LIBRARY_PATH"));
} else {
::myLogDebug(wxT("DYLD_LIBRARY_PATH='%s'"), VMB(newpath));
if (!::wxSetEnv(wxT("DYLD_LIBRARY_PATH"), newpath)) {
wxLogSysError(wxT("Cannot set DYLD_LIBRARY_PATH"));
}
}
}
}
#else
wxUnusedVar(enable);
#endif
}
void
MySession::cleanupOldSessions()
{
wxDir ud;
myLogTrace(MYTRACETAG, wxT("Cleaning up old session datav in %s"), VMB(m_sUserDir));
if (ud.Open(m_sUserDir)) {
SessionCleaner sc(m_sUserDir);
ud.Traverse(sc);
}
}
void
MySession::clearSshKeys(const wxString &keyloc)
{
myLogTrace(MYTRACETAG, wxT("Clearing keys for %s at %s"),
VMB(m_pCfg->sGetServerHost()), VMB(keyloc));
wxString keyfile = keyloc.BeforeLast(wxT(':'));
#ifdef __WXMSW__
if (keyfile.StartsWith(wxT("/cygdrive/"), &keyfile)) {
keyfile = keyfile.BeforeFirst(wxT('/')).Upper().Append(wxT(":/")).Append(keyfile.AfterFirst(wxT('/')));
keyfile.Replace(wxT("/"), wxT("\\"));
myLogTrace(MYTRACETAG, wxT("Keyfile: %s"), VMB(keyfile));
}
#endif
long n;
if (keyloc.AfterLast(wxT(':')).ToLong(&n)) {
n--;
wxTextFile tf(keyfile);
if (tf.Exists()) {
if (tf.Open()) {
myLogTrace(MYTRACETAG, wxT("Removing '%s'"), VMB(tf[n]));
tf.RemoveLine(n);
wxIPV4address ip;
if (ip.Hostname(m_pCfg->sGetServerHost())) {
wxString ipnum = ip.IPAddress();
wxString line;
for (line = tf.GetFirstLine(); !tf.Eof(); line = tf.GetNextLine()) {
if (line.Contains(ipnum)) {
myLogTrace(MYTRACETAG, wxT("Removing '%s'"), VMB(line));
tf.RemoveLine(tf.GetCurrentLine());
}
}
}
tf.Write();
}
}
}
}
bool
MySession::Create(MyXmlConfig &cfgpar, const wxString password, wxWindow *parent)
{
m_sClearPassword = password;
m_bSessionRunning = false;
m_bCupsRunning = false;
m_bEsdRunning = false;
m_bNativePARunning = false;
m_lEsdPort = 0;
m_bAbort = false;
m_bSessionEstablished = false;
m_bCollectSessions = false;
m_bCollectConfig = false;
m_bCollectResources = false;
m_bIsShadow = false;
m_bNextCmd = false;
m_sSessionID = wxEmptyString;
m_pParent = parent;
MyXmlConfig cfg(cfgpar.sGetFileName());
m_pCfg = &cfg;
if (cfg.IsValid()) {
// Copy misc values from login dialog
m_pCfg->bSetUseSmartCard(cfgpar.bGetUseSmartCard());
m_pCfg->bSetEnableSSL(cfgpar.bGetEnableSSL());
m_pCfg->bSetGuestMode(cfgpar.bGetGuestMode());
if (!cfgpar.bGetGuestMode()) {
m_pCfg->sSetUsername(cfgpar.sGetUsername());
m_pCfg->sSetPassword(password);
}
wxConfigBase::Get()->Read(wxT("Config/SystemNxDir"), &m_sSysDir);
wxConfigBase::Get()->Read(wxT("Config/UserNxDir"), &m_sUserDir);
checkXarch();
wxFileName fn(m_sSysDir, wxEmptyString);
fn.AppendDir(wxT("bin"));
#ifdef __WXMSW__
fn.SetName(wxT("nxssh.exe"));
#else
fn.SetName(wxT("nxssh"));
#endif
wxString nxsshcmd = fn.GetShortPath();
nxsshcmd << wxT(" -nx -x -2 -4")
<< wxT(" -p ") << m_pCfg->iGetServerPort()
<< wxT(" -o 'RhostsAuthentication no'")
<< wxT(" -o 'PasswordAuthentication no'")
<< wxT(" -o 'RSAAuthentication no'")
<< wxT(" -o 'RhostsRSAAuthentication no'")
<< wxT(" -o 'PubkeyAuthentication yes'");
m_sTempDir = m_sUserDir;
m_sTempDir << wxFileName::GetPathSeparator() << wxT("temp")
<< wxFileName::GetPathSeparator() << ::wxGetProcessId();
wxFileName::Mkdir(m_sTempDir, 0700, wxPATH_MKDIR_FULL);
wxString logfn = m_sTempDir +
wxFileName::GetPathSeparator() + wxT("runlog");
#ifdef __VISUALC__
ofstream *log = new ofstream();
#else
std::ofstream *log = new std::ofstream();
#endif
log->open(logfn.ToUTF8());
new RunLog(new wxLogStream(log));
logfn = m_sTempDir +
wxFileName::GetPathSeparator() + wxT("sshlog");
#ifdef __VISUALC__
log = new ofstream();
#else
log = new std::ofstream();
#endif
log->open(logfn.ToUTF8());
m_pSshLog = new wxLogStream(log);
wxLog::SetLogLevel(wxLOG_Max);
m_bIsShadow = (m_pCfg->eGetSessionType() == MyXmlConfig::STYPE_SHADOW);
if (m_pCfg->bGetRemoveOldSessionFiles())
cleanupOldSessions();
if (m_pCfg->bGetUseSmartCard()) {
myLogTrace(MYTRACETAG, wxT("Checking for SmartCard"));
CardWaiterDialog wd;
m_iReader = wd.WaitForCard(parent);
if (m_iReader == -1)
return false;
nxsshcmd << wxT(" -I ") << m_iReader;
} else {
if (m_pCfg->sGetSshKey().IsEmpty()) {
fn.Assign(m_sSysDir, wxT("server.id_dsa.key"));
fn.AppendDir(wxT("share"));
fn.AppendDir(wxT("keys"));
} else {
fn.Assign(m_sTempDir, wxT("keylog"));
wxFile f;
if (fn.FileExists())
::wxRemoveFile(fn.GetFullPath());
if (f.Open(fn.GetFullPath(), wxFile::write_excl, wxS_IRUSR|wxS_IWUSR)) {
f.Write(m_pCfg->sGetSshKey());
f.Close();
} else {
wxLogSysError(_("Could not write %s"), VMB(fn.GetFullPath()));
return false;
}
}
nxsshcmd << wxT(" -i ") << fn.GetShortPath();
}
if (m_pCfg->bGetUseProxy()) {
if (m_pCfg->bGetExternalProxy()) {
if (!m_pCfg->sGetProxyCommand().IsEmpty())
nxsshcmd << wxT(" -o 'ProxyCommand ") << m_pCfg->sGetProxyCommand() << wxT("'");
} else {
if (!m_pCfg->sGetProxyHost().IsEmpty()) {
// Internal (NoMachine) proxy
if (m_pCfg->sGetProxyUser().IsEmpty())
nxsshcmd << wxT(" -P ") << m_pCfg->sGetProxyHost() << wxT(":") << m_pCfg->iGetProxyPort();
else {
wxString proxyPass = m_pCfg->sGetProxyPass();
if (!m_pCfg->bGetProxyPassRemember()) {
ProxyPasswordDialog dlg(m_pParent);
if (dlg.ShowModal() == wxID_OK)
proxyPass = dlg.GetPassword();
else
return false;
}
nxsshcmd << wxT(" -P ") << m_pCfg->sGetProxyUser() << wxT(":") << proxyPass << wxT("@")
<< m_pCfg->sGetProxyHost() << wxT(":") << m_pCfg->iGetProxyPort();
}
}
}
}
nxsshcmd << wxT(" -4 -B -E") << wxT(" nx@") << m_pCfg->sGetServerHost();
m_sHost = m_pCfg->sGetServerHost();
wxString stmp;
::wxGetEnv(wxT("PATH"), &stmp);
// Prepend our system directory, so that pconnect can be found by nxssh (if necessary)
fn.Assign(m_sSysDir, wxT("bin"));
if (!stmp.Contains(fn.GetShortPath())) {
#ifdef __WXMSW__
stmp.Prepend(wxT(";")).Prepend(fn.GetShortPath());
#else
stmp.Prepend(wxT(":")).Prepend(fn.GetShortPath());
#endif
#ifdef __WXMAC__
stmp.Append(wxT(":/usr/X11R6/bin:/usr/X11/bin"));
#endif
::wxSetEnv(wxT("PATH"), stmp);
}
wxLogInfo(wxT("env: PATH='%s'"), VMB(stmp));
fn.Assign(wxFileName::GetHomeDir());
::wxSetEnv(wxT("NX_HOME"), fn.GetShortPath());
wxLogInfo(wxT("env: NX_HOME='%s'"), VMB(fn.GetShortPath()));
::wxSetEnv(wxT("HOME"), fn.GetShortPath());
wxLogInfo(wxT("env: HOME='%s'"), VMB(fn.GetShortPath()));
fn.Assign(m_sUserDir);
::wxSetEnv(wxT("NX_ROOT"), fn.GetShortPath());
wxLogInfo(wxT("env: NX_ROOT='%s'"), VMB(fn.GetShortPath()));
fn.Assign(m_sSysDir);
::wxSetEnv(wxT("NX_SYSTEM"), fn.GetShortPath());
wxLogInfo(wxT("env: NX_SYSTEM='%s'"), VMB(fn.GetShortPath()));
fn.Assign(::wxGetApp().GetSelfPath());
::wxSetEnv(wxT("NX_CLIENT"), fn.GetShortPath());
wxLogInfo(wxT("env: NX_CLIENT='%s'"), VMB(fn.GetShortPath()));
::wxSetEnv(wxT("NX_VERSION"), m_sProtocolVersion);
wxLogInfo(wxT("env: NX_VERSION='%s'"), VMB(m_sProtocolVersion));
if (m_pCfg->eGetDisplayType() == MyXmlConfig::DPTYPE_FULLSCREEN) {
bool bVal = false;
wxConfigBase::Get()->Read(wxT("Config/DisableMagicPixel"), &bVal, false);
if (bVal) {
int dspw, dsph;
::wxDisplaySize(&dspw, &dsph);
wxString w = wxString::Format(wxT("%d"), (int)dspw);
::wxSetEnv(wxT("NX_KIOSK_X"), w);
wxLogInfo(wxT("env: NX_KIOSK_X='%s'"), VMB(w));
}
}
::wxSetEnv(wxT("XAUTHORITY"), getXauthPath(m_eXarch));
wxLogInfo(wxT("env: XAUTHORITY='%s'"), VMB(getXauthPath(m_eXarch)));
#ifdef __UNIX__
// NX needs TEMP or NX_TEMP to be set to the same dir
// where .X11-unix resides (typically /tmp)
stmp = wxConvLocal.cMB2WX(x11_socket_path);
if (!stmp.IsEmpty()) {
fn.Assign(stmp);
fn.RemoveLastDir();
fn.SetName(wxEmptyString);
::wxSetEnv(wxT("NX_TEMP"), cygPath(fn.GetFullPath()));
wxLogInfo(wxT("env: NX_TEMP='%s'"), VMB(cygPath(fn.GetShortPath())));
} else {
::wxSetEnv(wxT("NX_TEMP"), wxT("/tmp"));
wxLogInfo(wxT("env: NX_TEMP='/tmp'"));
}
#else
::wxSetEnv(wxT("NX_TEMP"), cygPath(m_sTempDir));
wxLogInfo(wxT("env: NX_TEMP='%s'"), VMB(cygPath(m_sTempDir)));
#endif
#ifdef __WXMSW__
if (m_eXarch == XARCH_CYGWIN) {
wxString srvstr = wxT("server");
::wxSetEnv(wxT("CYGWIN"), srvstr);
wxLogInfo(wxT("env: CYGWIN='%s'"), VMB(srvstr));
}
if (!startXserver()) {
wxLogError(_("Could not start local X server"));
return false;
}
if (XARCH_XMING == m_eXarch) {
// Now, that the X server has been started, // set XAUTHORITY
// again, but this time in cygwin notation (for nxssh).
::wxSetEnv(wxT("XAUTHORITY"), getXauthPath(XARCH_CYGWIN));
wxLogInfo(wxT("env: XAUTHORITY='%s'"), VMB(getXauthPath(XARCH_CYGWIN)));
// Configure XMing's special clipboard filter
HWND clpWnd = FindWindow(NULL ,wxT("OpenNXWinClip"));
if (NULL != clpWnd) {
PostMessage(clpWnd, WM_USER + 1004, m_pCfg->iGetClipFilter() + 1, 0);
}
}
#endif
fn.Assign(m_sSysDir, wxT("bin"));
m_iProgress = 0;
ConnectDialog dlg(m_pParent);
m_pDlg = &dlg;
dlg.Show(true);
dlg.SetStatusText(wxString::Format(_("Connecting to %s ..."),
VMB(m_pCfg->sGetServerHost())));
if (m_pCfg->bGetEnableMultimedia()) {
m_bEsdRunning = false; m_bNativePARunning = false;
dlg.SetStatusText(_("Preparing multimedia service ..."));
PulseAudio pa;
if (pa.IsAvailable()) {
wxLogInfo(wxT("using existing pulseaudio"));
m_lEsdPort = wxConfigBase::Get()->Read(wxT("State/nxesdPort"), -1);
if (m_lEsdPort < 0)
m_lEsdPort = getFirstFreePort(6000);
if (0 < m_lEsdPort) {
bool pa_started = false;
if (m_pCfg->bGetEnableNativePA()) {
wxLogInfo(wxT("Activating Native Module in pulseaudio on port %ld"), m_lEsdPort);
int pa_rate = 0;
switch (m_pCfg->eGetRatePA()) {
case MyXmlConfig::RATEPA_NORESAMPLE:
pa_rate = 0; break;
case MyXmlConfig::RATEPA_48000:
pa_rate = 48000; break;
case MyXmlConfig::RATEPA_44100:
pa_rate = 44100; break;
case MyXmlConfig::RATEPA_32000:
pa_rate = 32000; break;
case MyXmlConfig::RATEPA_16000:
pa_rate = 16000; break;
case MyXmlConfig::RATEPA_8000:
pa_rate = 8000; break;
}
bool pa_mono = pa_rate > 0 ? m_pCfg->bGetEnableMonoPA() : false;
pa_started = m_bNativePARunning = pa.ActivateNative(m_lEsdPort, pa_rate, pa_mono);
} else {
wxLogInfo(wxT("Activating ESD Module in pulseaudio on port %ld"), m_lEsdPort);
pa_started = m_bEsdRunning = pa.ActivateEsound(m_lEsdPort);
}
if (pa_started) {
wxConfigBase::Get()->Write(wxT("State/nxesdPort"), m_lEsdPort);
wxConfigBase::Get()->Write(wxT("State/nxesdPID"), -1);
} else {
wxLogWarning(_("Could not start multimedia support"));
}
} else
wxLogWarning(_("Could not assign a free port for multimedia support"));
}
#ifndef __WXMSW__
if (!m_bEsdRunning && !m_bNativePARunning) {
// Fallback: original old nxesd
long esdpid = wxConfigBase::Get()->Read(wxT("State/nxesdPID"), -1);
m_lEsdPort = wxConfigBase::Get()->Read(wxT("State/nxesdPort"), -1);
if ((-1 != esdpid) && (0 < m_lEsdPort))
m_bEsdRunning = wxProcess::Exists(esdpid);
if ((!dlg.bGetAbort()) && (!m_bEsdRunning)) {
wxFileName fn(m_sSysDir, wxEmptyString);
fn.AppendDir(wxT("bin"));
fn.SetName(wxT("nxesd"));
if (fn.FileExists()) {
wxString esdcmd = fn.GetFullPath();
m_lEsdPort = getFirstFreePort(6000);
if (0 < m_lEsdPort) {
esdcmd << wxT(" -tcp -nobeeps -bind 127.0.0.1 -spawnfd 1 -port ") << m_lEsdPort;
wxLogInfo(wxT("starting in background: %s"), VMB(esdcmd));
wxProcess *nxesd = wxProcess::Open(esdcmd,
wxEXEC_ASYNC|wxEXEC_MAKE_GROUP_LEADER);
if (nxesd) {
nxesd->CloseOutput();
wxStopWatch sw;
while (!(dlg.bGetAbort() || nxesd->IsInputAvailable())) {
::wxGetApp().Yield(true);
wxLog::FlushActive();
// Timeout after 10 sec
if (sw.Time() > 10000)
break;
}
char msg = '\0';
if (nxesd->IsInputAvailable())
nxesd->GetInputStream()->Read(&msg, 1);
long esdpid = nxesd->GetPid();
nxesd->Detach();
if (msg) {
m_bEsdRunning = true;
wxConfigBase::Get()->Write(wxT("State/nxesdPID"), esdpid);
wxConfigBase::Get()->Write(wxT("State/nxesdPort"), m_lEsdPort);
}
}
if (!m_bEsdRunning)
wxLogWarning(_("Could not start multimedia support"));
} else
wxLogWarning(_("Could not assign a free port for multimedia support"));
} else
wxLogWarning(_("Could not start multimedia support"));
}
}
#endif
dlg.SetStatusText(wxString::Format(_("Connecting to %s ..."),
VMB(m_pCfg->sGetServerHost())));
}
if (dlg.bGetAbort()) {
#ifdef __WXMSW__
terminateXserver();
#endif
return false;
}
if (getActiveCupsPrinters().GetCount() > 0) {
dlg.SetStatusText(_("Preparing CUPS service ..."));
dlg.SetStatusText(wxString::Format(_("Connecting to %s ..."),
VMB(m_pCfg->sGetServerHost())));
}
MyIPC nxssh;
m_pNxSsh = &nxssh;
wxLogInfo(wxT("Starting %s"), VMB(nxsshcmd));
do {
m_bRemoveKey = false;
m_sOffendingKey = wxEmptyString;
setTurboPath(true);
if (nxssh.SshProcess(nxsshcmd, fn.GetShortPath(), this)) {
setTurboPath(false);
m_bGotError = false;
m_eConnectState = STATE_INIT;
while (!(dlg.bGetAbort() || m_bGotError || m_bAbort ||
(m_bSessionRunning && m_bSessionEstablished))) {
wxLog::FlushActive();
::wxGetApp().Yield(true);
#ifdef __WXMSW__
if (m_iXserverPID)
AllowSetForegroundWindow(m_iXserverPID);
#endif
}
if (dlg.bGetAbort() || m_bGotError || m_bAbort) {
if (m_bRemoveKey) {
while (m_sOffendingKey.IsEmpty()) {
wxLog::FlushActive();
::wxGetApp().Yield(true);
}
} else {
#ifndef __WXMSW__
nxssh.Kill();
#endif
#ifdef __WXMSW__
terminateXserver();
#endif
return false;
}
}
/*
// but original nxclient stay leave nxssh in case of unencrypted conn
else {
if (m_bSessionEstablished && (!m_bSslTunneling)) {
// Unecrypted session (handled by nxproxy), get rid of nxssh
nxssh.Kill();
}
}
*/
wxThread::Sleep(500);
#ifdef __WXMSW__
if (m_iXserverPID)
AllowSetForegroundWindow(m_iXserverPID);
#endif
} else {
setTurboPath(false);
wxLogError(_("Called command was: ") + nxsshcmd);
wxLogError(_("Could not start nxssh."));
#ifdef __WXMSW__
terminateXserver();
#endif
return false;
}
if (m_bRemoveKey)
clearSshKeys(m_sOffendingKey);
} while (m_bRemoveKey);
nxssh.Detach();
#ifdef __WXMSW__
if (m_iXserverPID)
AllowSetForegroundWindow(m_iXserverPID);
#endif
if (m_pCfg->bGetEnableUSBIP()) {
myLogTrace(MYTRACETAG, wxT("Enabling UsbIp"));
::wxGetApp().SetNxSshPID(nxssh.GetPID());
::wxGetApp().SetSessionCfg(*m_pCfg);
::wxGetApp().SetSessionID(m_sSessionID.Right(32));
::wxGetApp().SetRequireStartUsbIp(true);
} else {
if (m_pCfg->bGetUseSmartCard()) {
myLogTrace(MYTRACETAG, wxT("Enabling WatchReader %d"), (int)m_iReader);
::wxGetApp().SetNxSshPID(nxssh.GetPID());
::wxGetApp().SetReader(m_iReader);
::wxGetApp().SetRequireWatchReader(true);
}
}
#ifdef __WXMSW__
unhideNXWin();
#endif
return true;
}
return false;
}
Reference in New Issue View Git Blame Copy Permalink