MainDialog.cpp

#include <assert.h>

#include <QApplication>
#include <QAction>
#include <QDateTime>
#include <QGroupBox>
#include <QLabel>
#include <QMenu>
#include <QSpacerItem>
#include <QSplitter>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QDebug>

#include "MainDialog.hpp"

MainDialog::MainDialog(QWidget *parent)
 : QDialog(parent)
 , mHostEdit(new QLineEdit)
 , mPortEdit(new QLineEdit)
 , mUserEdit(new QLineEdit)
 , mPswdEdit(new QLineEdit)
 , mLAddrEdit(new QLineEdit)
 , mLPortEdit(new QLineEdit)
 , mWaitEdit(new QLineEdit)
 , mIndicator(new Indicator)
 , mCtrlBtn(new QPushButton(tr("Start")))
 , mQuitBtn(new QPushButton(tr("Quit")))
 , mLogList(new QListWidget)
 , mInfoIcon(QPixmap(":/icon-info.png"))
 , mWarnIcon(QPixmap(":/icon-warn.png"))
 , mErrorIcon(QPixmap(":/icon-error.png"))
 , mStoppedIcon(QPixmap(":/icon-stopped.png"))
 , mConnectingIcon(QPixmap(":/icon-connecting.png"))
 , mConnectedIcon(QPixmap(":/icon-connected.png"))
 , mSleepingIcon(QPixmap(":/icon-sleeping.png"))
 , mSettings(new QSettings(QSettings::IniFormat, QSettings::UserScope,
 "glacjay", "sshproxy", this))
 , mIsKeepRunning(false)
 , mProcess(new QProcess(this))
 , mRestartTimer(new QTimer(this))
{
 setWindowTitle(tr("SSH Proxy"));
 setWindowIcon(mConnectedIcon);

 mHostEdit->setText(mSettings->value("ssh/host").toString());
 mPortEdit->setText(mSettings->value("ssh/port", "22").toString());
 mUserEdit->setText(mSettings->value("ssh/user").toString());
 mLAddrEdit->setText(mSettings->value("ssh/laddr", "127.0.0.1").toString());
 mLPortEdit->setText(mSettings->value("ssh/lport", "1077").toString());
 mWaitEdit->setText(mSettings->value("ssh/wait", "10").toString());

 mPortEdit->setValidator(new QIntValidator(1, 65535));
 mPswdEdit->setEchoMode(QLineEdit::Password);
 mLPortEdit->setValidator(new QIntValidator(1, 65535));
 mWaitEdit->setValidator(new QIntValidator);
 mLogList->setWordWrap(true);

 mProcess->setProcessChannelMode(QProcess::MergedChannels);

 QLabel *hostLabel = new QLabel(tr("SSH Host:"));
 hostLabel->setBuddy(mHostEdit);
 QLabel *portLabel = new QLabel(tr("SSH Port:"));
 portLabel->setBuddy(mPortEdit);
 QLabel *userLabel = new QLabel(tr("Username:"));
 userLabel->setBuddy(mUserEdit);
 QLabel *pswdLabel = new QLabel(tr("Password:"));
 pswdLabel->setBuddy(mPswdEdit);
 QLabel *lAddrLabel = new QLabel(tr("Listen Addr:"));
 lAddrLabel->setBuddy(mLAddrEdit);
 QLabel *lPortLabel = new QLabel(tr("Listen Port:"));
 lPortLabel->setBuddy(mLPortEdit);
 QLabel *waitLabel = new QLabel(tr("Seconds wait to reconnect:"));
 waitLabel->setBuddy(mWaitEdit);

 mIndicator->setState(Indicator::State::Off);
 QHBoxLayout *ctrlLayout = new QHBoxLayout;
 ctrlLayout->addWidget(mIndicator);
 ctrlLayout->addWidget(mCtrlBtn);

 QVBoxLayout *inputLayout = new QVBoxLayout;
 inputLayout->addWidget(hostLabel);
 inputLayout->addWidget(mHostEdit);
 inputLayout->addWidget(portLabel);
 inputLayout->addWidget(mPortEdit);
 inputLayout->addWidget(userLabel);
 inputLayout->addWidget(mUserEdit);
 inputLayout->addWidget(pswdLabel);
 inputLayout->addWidget(mPswdEdit);
 inputLayout->addWidget(lAddrLabel);
 inputLayout->addWidget(mLAddrEdit);
 inputLayout->addWidget(lPortLabel);
 inputLayout->addWidget(mLPortEdit);
 inputLayout->addWidget(waitLabel);
 inputLayout->addWidget(mWaitEdit);
 inputLayout->insertStretch(-1);
 inputLayout->addLayout(ctrlLayout, -1);
 inputLayout->addWidget(mQuitBtn);

 QGroupBox *inputGroup = new QGroupBox(tr("Settings"));
 inputGroup->setLayout(inputLayout);

 QVBoxLayout *logLayout = new QVBoxLayout;
 logLayout->addWidget(mLogList);

 QGroupBox *logGroup = new QGroupBox(tr("Log"));
 logGroup->setLayout(logLayout);

 QSplitter *splitter = new QSplitter(Qt::Horizontal);
 splitter->addWidget(inputGroup);
 splitter->addWidget(logGroup);
 splitter->setStretchFactor(1, 5);

 QVBoxLayout *mainLayout = new QVBoxLayout;
 mainLayout->addWidget(splitter);

 setLayout(mainLayout);
 resize(1000, 600);

 connect(mCtrlBtn, SIGNAL(clicked(void)), this, SLOT(on_mCtrlBtn_clicked(void)));
 connect(mQuitBtn, SIGNAL(clicked(void)), this, SLOT(onQuit(void)));

 mTray = new QSystemTrayIcon(mStoppedIcon);
 mTray->show();

 setSshStatus(StatStopped);

 connect(mTray, SIGNAL(activated(QSystemTrayIcon::ActivationReason)),
 this, SLOT(on_mTray_activated(QSystemTrayIcon::ActivationReason)));

 QAction *toggleAction = new QAction(tr("Toggle Main Dialog"), this);
 connect(toggleAction, SIGNAL(triggered(void)),
 this, SLOT(on_toggleAction_triggered(void)));

 QAction *quitAction = new QAction(tr("Quit"), this);
 connect(quitAction, SIGNAL(triggered(void)),
 this, SLOT(onQuit(void)));

 QMenu *trayMenu = new QMenu;
 trayMenu->addAction(toggleAction);
 trayMenu->addSeparator();
 trayMenu->addAction(quitAction);

 mTray->setContextMenu(trayMenu);

 connect(qApp, SIGNAL(aboutToQuit(void)), this, SLOT(onQuit(void)));

 connect(mProcess, SIGNAL(started(void)), this, SLOT(on_mProcess_started(void)));
 connect(mProcess, SIGNAL(finished(int, QProcess::ExitStatus)),
 this, SLOT(on_mProcess_finished(int, QProcess::ExitStatus)));
 connect(mProcess, SIGNAL(error(QProcess::ProcessError)),
 this, SLOT(on_mProcess_error(QProcess::ProcessError)));
 connect(mProcess, SIGNAL(readyReadStandardOutput(void)),
 this, SLOT(on_mProcess_readyReadStandardOutput(void)));

 connect(mRestartTimer, SIGNAL(timeout(void)), this, SLOT(startRunning(void)));

 if (mHostEdit->text().isEmpty())
 mHostEdit->setFocus();
 else if (mPortEdit->text().isEmpty())
 mPortEdit->setFocus();
 else if (mUserEdit->text().isEmpty())
 mUserEdit->setFocus();
 else if (mPswdEdit->text().isEmpty())
 mPswdEdit->setFocus();
 else if (mLAddrEdit->text().isEmpty())
 mLAddrEdit->setFocus();
 else if (mLPortEdit->text().isEmpty())
 mLPortEdit->setFocus();
 else if (mWaitEdit->text().isEmpty())
 mWaitEdit->setFocus();
}

MainDialog::~MainDialog(void)
{
 stopRunning();
}

void MainDialog::closeEvent(QCloseEvent *event)
{
 this->setVisible(false);
 event->ignore();
}

void MainDialog::on_mCtrlBtn_clicked(void)
{
 if (mIndicator->state() == Indicator::State::Off)
 {
 startRunning();
 }
 else if (mIndicator->state() == Indicator::State::On)
 {
 stopRunning();
 }
 else // busy
 {
 assert(!mCtrlBtn->isEnabled());
 }
}

void MainDialog::onQuit(void)
{
 saveSettings();
 qApp->exit(0);
}

void MainDialog::on_mTray_activated(QSystemTrayIcon::ActivationReason reason)
{
 switch (reason)
 {
 case QSystemTrayIcon::DoubleClick:
 this->setVisible(!this->isVisible());
 break;
 case QSystemTrayIcon::Unknown:
 case QSystemTrayIcon::Context:
 case QSystemTrayIcon::Trigger:
 case QSystemTrayIcon::MiddleClick:
 break;
 }
}

void MainDialog::on_toggleAction_triggered(void)
{
 this->setVisible(!this->isVisible());
}

void MainDialog::on_mProcess_started(void)
{
 addLogMsg(LogInfo, "connecting to the SSH server...");
 setSshStatus(StatConnecting);
}

void MainDialog::on_mProcess_finished(int exitCode, QProcess::ExitStatus exitStatus)
{
 addLogMsg(LogInfo, QString("process finished with code %1 and status %2")
 .arg(exitCode)
 .arg(exitStatus == QProcess::NormalExit ? "NormalExit" : "CrashExit"));
 setSshStatus(StatSleeping);

 mRestartTimer->start(1000 * mWaitEdit->text().toInt());
}

void MainDialog::on_mProcess_error(QProcess::ProcessError error)
{
 addLogMsg(LogWarn, QString("process error %1").arg(error));
 setSshStatus(StatSleeping);
 mProcess->kill();

 mRestartTimer->start(1000 * mWaitEdit->text().toInt());
}

void MainDialog::on_mProcess_readyReadStandardOutput(void)
{
 char line[1024];
 while (mProcess->readLine(line, sizeof(line)) > 0)
 {
 QString msg(line);
 addLogMsg(LogInfo, msg.remove('\n'));

 if (msg.contains("Entering interactive "))
 setSshStatus(StatConnected);
 }
}

void MainDialog::setSshStatus(SshStatus status)
{
 switch (status)
 {
 case StatStopped:
 qApp->setWindowIcon(mStoppedIcon);
 mTray->setIcon(mStoppedIcon);
 break;
 case StatConnecting:
 qApp->setWindowIcon(mConnectingIcon);
 mTray->setIcon(mConnectingIcon);
 break;
 case StatConnected:
 qApp->setWindowIcon(mConnectedIcon);
 mTray->setIcon(mConnectedIcon);
 break;
 case StatSleeping:
 qApp->setWindowIcon(mSleepingIcon);
 mTray->setIcon(mSleepingIcon);
 break;
 default:
 assert(false);
 }
}

void MainDialog::addLogMsg(LogLevel level, const QString &msg)
{
 QIcon icon;
 switch (level)
 {
 case LogDebug:
 /* No icon for debugging msg */
 break;
 case LogInfo:
 icon = mInfoIcon;
 break;
 case LogWarn:
 icon = mWarnIcon;
 break;
 case LogError:
 icon = mErrorIcon;
 break;
 default:
 assert(false);
 }

 while (mLogList->count() >= MaxTotalLog)
 mLogList->removeItemWidget(mLogList->item(0));

 QString time = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss");
 mLogList->addItem(new QListWidgetItem(icon, QString("%1 %2").arg(time).arg(msg)));
 mLogList->scrollToBottom();
}

void MainDialog::saveSettings(void)
{
 mSettings->setValue("ssh/host", mHostEdit->text());
 mSettings->setValue("ssh/port", mPortEdit->text());
 mSettings->setValue("ssh/user", mUserEdit->text());
 mSettings->setValue("ssh/laddr", mLAddrEdit->text());
 mSettings->setValue("ssh/lport", mLPortEdit->text());
 mSettings->setValue("ssh/wait", mWaitEdit->text());
}

void MainDialog::startRunning(void)
{
 mIsKeepRunning = true;
 mCtrlBtn->setText(tr("..."));
 mCtrlBtn->setEnabled(false);
 mIndicator->setState(Indicator::State::Busy);

 if (mHostEdit->text().isEmpty())
 {
 addLogMsg(LogError, "SSH server's host name may not be empty!");
 mHostEdit->setFocus();
 return;
 }

 if (mPortEdit->text().toInt() == 0)
 {
 addLogMsg(LogWarn, "SSH server's port may not be empty. I assume you mean 22");
 mPortEdit->setText("22");
 }

 if (mUserEdit->text().isEmpty())
 {
 addLogMsg(LogError, "Username may not be empty!");
 mUserEdit->setFocus();
 return;
 }

 if (mPswdEdit->text().isEmpty())
 {
 addLogMsg(LogWarn, "Password should not be empty in general.");
 mPswdEdit->setFocus();
 }

 if (mLAddrEdit->text().isEmpty())
 {
 addLogMsg(LogWarn, "Local listen address is empty. I assume you mean 127.0.0.1");
 mLAddrEdit->setText("127.0.0.1");
 }

 if (mLPortEdit->text().toInt() == 0)
 {
 addLogMsg(LogError, "Local listen port may not be empty!");
 mLPortEdit->setText("1077");
 mLPortEdit->setFocus();
 return;
 }

 QStringList arguments;
 arguments << "-p" << mPortEdit->text();
 arguments << "-vN";
 arguments << "-D" << QString("%1:%2").arg(mLAddrEdit->text()).arg(mLPortEdit->text());
 arguments << "-o" << "StrictHostKeyChecking=no";
 arguments << "-o" << "PreferredAuthentications=password";
 arguments << "-o" << "ServerAliveInterval=20";
 arguments << "-l" << mUserEdit->text();
 arguments << mHostEdit->text();

 QStringList env;
 env << "DISPLAY=:1";
 env << QString("SSH_ASKPASS=%1").arg(QCoreApplication::applicationFilePath());
 env << QString("GLACJAY_SSHPROXY_PASSWORD=%1").arg(mPswdEdit->text());
 mProcess->setEnvironment(env);

 mProcess->start("/usr/bin/ssh", arguments);

 mIndicator->setState(Indicator::State::On);
 mCtrlBtn->setText(tr("Stop"));
 mCtrlBtn->setEnabled(true);
}

void MainDialog::stopRunning(void)
{
 mIsKeepRunning = false;
 mCtrlBtn->setText(tr("..."));
 mCtrlBtn->setEnabled(false);
 mIndicator->setState(Indicator::State::Busy);

 if (mProcess->state() != QProcess::NotRunning)
 {
 mProcess->kill();
 }

 mIndicator->setState(Indicator::State::Off);
 mCtrlBtn->setText(tr("Start"));
 mCtrlBtn->setEnabled(true);
}