Internal
Public Access
ksmithandClaude Sonnet 5
776db5ec04
Closes #21. SSH and RDP profiles previously hard-required a username to even save the profile; that validation is dropped, and SessionTab::requestConnectOptions() now prompts for it at connect time when blank, reusing the existing password-prompt bar in unmasked mode -- the same pattern already used for a blank password. VNC's username is trickier: most VNC servers never use one (plain VNC Authentication and no-auth don't), only the two Apple auth schemes (security types 30/33) do, and which auth method gets used isn't known until mid-connection, after the server's security-type list has been negotiated -- too late for the pre-connect prompt SSH/RDP uses. Adds a new async request/response pair to SessionBackend, usernameRequested() signal / provideUsername() slot, mirroring the existing SSH host-key- confirmation pattern. VncSessionBackend pauses its state machine right before computing an Apple-auth response if no username is available -- without consuming the already-buffered prime/host-key bytes, so resuming re-parses them identically -- emits the request, and resumes via provideUsername(). Cancelling (or submitting blank) fails the connection cleanly instead of sending Apple auth an empty username. The username is kept on the tab's in-memory profile copy for its lifetime, not written back to the saved profile, matching how passwords are already handled. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
326 lines
13 KiB
C++
326 lines
13 KiB
C++
#include "profile_dialog.h"
|
|
|
|
#include <QComboBox>
|
|
#include <QDialogButtonBox>
|
|
#include <QFileDialog>
|
|
#include <QFileInfo>
|
|
#include <QFormLayout>
|
|
#include <QHBoxLayout>
|
|
#include <QLabel>
|
|
#include <QLineEdit>
|
|
#include <QMessageBox>
|
|
#include <QPushButton>
|
|
#include <QSignalBlocker>
|
|
#include <QSpinBox>
|
|
#include <QVBoxLayout>
|
|
|
|
namespace {
|
|
int standardPortForProtocol(const QString& protocol)
|
|
{
|
|
if (protocol == QStringLiteral("RDP")) {
|
|
return 3389;
|
|
}
|
|
if (protocol == QStringLiteral("VNC")) {
|
|
return 5900;
|
|
}
|
|
return 22; // SSH default
|
|
}
|
|
|
|
QString normalizedProtocol(const QString& protocol)
|
|
{
|
|
if (protocol.compare(QStringLiteral("RDP"), Qt::CaseInsensitive) == 0) {
|
|
return QStringLiteral("RDP");
|
|
}
|
|
if (protocol.compare(QStringLiteral("VNC"), Qt::CaseInsensitive) == 0) {
|
|
return QStringLiteral("VNC");
|
|
}
|
|
return QStringLiteral("SSH");
|
|
}
|
|
|
|
QString normalizedAuthMode(const QString& protocol, const QString& authMode)
|
|
{
|
|
if (protocol != QStringLiteral("SSH")) {
|
|
return QStringLiteral("Password");
|
|
}
|
|
if (authMode.compare(QStringLiteral("Private Key"), Qt::CaseInsensitive) == 0) {
|
|
return QStringLiteral("Private Key");
|
|
}
|
|
return QStringLiteral("Password");
|
|
}
|
|
}
|
|
|
|
ProfileDialog::ProfileDialog(QWidget* parent)
|
|
: QDialog(parent),
|
|
m_nameInput(new QLineEdit(this)),
|
|
m_hostInput(new QLineEdit(this)),
|
|
m_portInput(new QSpinBox(this)),
|
|
m_usernameInput(new QLineEdit(this)),
|
|
m_domainInput(new QLineEdit(this)),
|
|
m_tagsInput(new QLineEdit(this)),
|
|
m_protocolInput(new QComboBox(this)),
|
|
m_authModeInput(new QComboBox(this)),
|
|
m_privateKeyPathInput(new QLineEdit(this)),
|
|
m_browsePrivateKeyButton(new QPushButton(QStringLiteral("Browse"), this)),
|
|
m_knownHostsPolicyInput(new QComboBox(this)),
|
|
m_rdpSecurityModeInput(new QComboBox(this)),
|
|
m_rdpPerformanceProfileInput(new QComboBox(this)),
|
|
m_protocolHint(new QLabel(this)),
|
|
m_folderHint(new QLabel(this))
|
|
{
|
|
resize(560, 360);
|
|
|
|
auto* layout = new QVBoxLayout(this);
|
|
auto* form = new QFormLayout();
|
|
form->setFieldGrowthPolicy(QFormLayout::ExpandingFieldsGrow);
|
|
form->setFormAlignment(Qt::AlignLeft | Qt::AlignTop);
|
|
form->setLabelAlignment(Qt::AlignRight);
|
|
|
|
m_nameInput->setPlaceholderText(QStringLiteral("Production Bastion"));
|
|
m_hostInput->setPlaceholderText(QStringLiteral("example.internal"));
|
|
m_portInput->setRange(1, 65535);
|
|
m_portInput->setValue(22);
|
|
m_usernameInput->setPlaceholderText(QStringLiteral("deploy"));
|
|
m_domainInput->setPlaceholderText(QStringLiteral("CONTOSO"));
|
|
m_tagsInput->setPlaceholderText(QStringLiteral("prod, linux, db"));
|
|
|
|
m_protocolInput->addItems({QStringLiteral("SSH"), QStringLiteral("RDP"), QStringLiteral("VNC")});
|
|
m_authModeInput->addItems({QStringLiteral("Password"), QStringLiteral("Private Key")});
|
|
m_knownHostsPolicyInput->addItems(
|
|
{QStringLiteral("Ask"), QStringLiteral("Strict"), QStringLiteral("Accept New"), QStringLiteral("Ignore")});
|
|
m_rdpSecurityModeInput->addItems(
|
|
{QStringLiteral("Negotiate"), QStringLiteral("NLA"), QStringLiteral("TLS"), QStringLiteral("RDP")});
|
|
m_rdpPerformanceProfileInput->addItems({QStringLiteral("Balanced"),
|
|
QStringLiteral("Best Quality"),
|
|
QStringLiteral("Best Performance"),
|
|
QStringLiteral("Auto Detect")});
|
|
|
|
m_privateKeyPathInput->setPlaceholderText(QStringLiteral("/home/user/.ssh/id_ed25519"));
|
|
|
|
auto* privateKeyRow = new QWidget(this);
|
|
auto* privateKeyLayout = new QHBoxLayout(privateKeyRow);
|
|
privateKeyLayout->setContentsMargins(0, 0, 0, 0);
|
|
privateKeyLayout->addWidget(m_privateKeyPathInput, 1);
|
|
privateKeyLayout->addWidget(m_browsePrivateKeyButton);
|
|
|
|
connect(m_browsePrivateKeyButton,
|
|
&QPushButton::clicked,
|
|
this,
|
|
[this]() {
|
|
const QString selected = QFileDialog::getOpenFileName(this,
|
|
QStringLiteral("Select Private Key"),
|
|
QString(),
|
|
QStringLiteral("All Files (*)"));
|
|
if (!selected.isEmpty()) {
|
|
m_privateKeyPathInput->setText(selected);
|
|
}
|
|
});
|
|
|
|
connect(m_protocolInput,
|
|
&QComboBox::currentTextChanged,
|
|
this,
|
|
[this](const QString& protocol) {
|
|
m_portInput->setValue(standardPortForProtocol(protocol));
|
|
if (protocol != QStringLiteral("SSH")) {
|
|
const QSignalBlocker blocker(m_authModeInput);
|
|
m_authModeInput->setCurrentText(QStringLiteral("Password"));
|
|
}
|
|
refreshAuthFields();
|
|
});
|
|
|
|
connect(m_authModeInput,
|
|
&QComboBox::currentTextChanged,
|
|
this,
|
|
[this](const QString&) { refreshAuthFields(); });
|
|
|
|
form->addRow(QStringLiteral("Name"), m_nameInput);
|
|
form->addRow(QStringLiteral("Host"), m_hostInput);
|
|
form->addRow(QStringLiteral("Port"), m_portInput);
|
|
form->addRow(QStringLiteral("Username"), m_usernameInput);
|
|
form->addRow(QStringLiteral("Domain"), m_domainInput);
|
|
form->addRow(QStringLiteral("Tags"), m_tagsInput);
|
|
form->addRow(QStringLiteral("Protocol"), m_protocolInput);
|
|
form->addRow(QStringLiteral("Auth Mode"), m_authModeInput);
|
|
form->addRow(QStringLiteral("Private Key"), privateKeyRow);
|
|
form->addRow(QStringLiteral("Known Hosts"), m_knownHostsPolicyInput);
|
|
form->addRow(QStringLiteral("RDP Security"), m_rdpSecurityModeInput);
|
|
form->addRow(QStringLiteral("RDP Performance"), m_rdpPerformanceProfileInput);
|
|
|
|
auto* note = new QLabel(
|
|
QStringLiteral("Passwords are requested at connect time and are not stored."),
|
|
this);
|
|
note->setWordWrap(true);
|
|
m_protocolHint->setWordWrap(true);
|
|
m_folderHint->setWordWrap(true);
|
|
|
|
auto* buttons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
|
|
connect(buttons, &QDialogButtonBox::accepted, this, &QDialog::accept);
|
|
connect(buttons, &QDialogButtonBox::rejected, this, &QDialog::reject);
|
|
|
|
layout->addLayout(form);
|
|
layout->addWidget(m_protocolHint);
|
|
layout->addWidget(m_folderHint);
|
|
layout->addWidget(note);
|
|
layout->addWidget(buttons);
|
|
|
|
refreshAuthFields();
|
|
}
|
|
|
|
void ProfileDialog::setDialogTitle(const QString& title)
|
|
{
|
|
setWindowTitle(title);
|
|
}
|
|
|
|
void ProfileDialog::setDefaultFolderPath(const QString& folderPath)
|
|
{
|
|
m_defaultFolderPath = folderPath.trimmed();
|
|
refreshAuthFields();
|
|
}
|
|
|
|
void ProfileDialog::setProfile(const Profile& profile)
|
|
{
|
|
m_nameInput->setText(profile.name);
|
|
m_hostInput->setText(profile.host);
|
|
m_portInput->setValue(profile.port > 0 ? profile.port : 22);
|
|
m_usernameInput->setText(profile.username);
|
|
m_domainInput->setText(profile.domain);
|
|
m_defaultFolderPath = profile.folderPath.trimmed();
|
|
m_tagsInput->setText(profile.tags);
|
|
m_privateKeyPathInput->setText(profile.privateKeyPath);
|
|
|
|
const int protocolIndex = m_protocolInput->findText(profile.protocol);
|
|
{
|
|
// Keep stored custom port when loading an existing profile.
|
|
const QSignalBlocker blocker(m_protocolInput);
|
|
m_protocolInput->setCurrentIndex(protocolIndex >= 0 ? protocolIndex : 0);
|
|
}
|
|
|
|
const int authModeIndex = m_authModeInput->findText(profile.authMode);
|
|
m_authModeInput->setCurrentIndex(authModeIndex >= 0 ? authModeIndex : 0);
|
|
|
|
const int knownHostsIndex = m_knownHostsPolicyInput->findText(profile.knownHostsPolicy);
|
|
m_knownHostsPolicyInput->setCurrentIndex(knownHostsIndex >= 0 ? knownHostsIndex : 0);
|
|
const int securityModeIndex = m_rdpSecurityModeInput->findText(profile.rdpSecurityMode);
|
|
m_rdpSecurityModeInput->setCurrentIndex(securityModeIndex >= 0 ? securityModeIndex : 0);
|
|
const int performanceProfileIndex =
|
|
m_rdpPerformanceProfileInput->findText(profile.rdpPerformanceProfile);
|
|
m_rdpPerformanceProfileInput->setCurrentIndex(performanceProfileIndex >= 0 ? performanceProfileIndex
|
|
: 0);
|
|
|
|
refreshAuthFields();
|
|
}
|
|
|
|
Profile ProfileDialog::profile() const
|
|
{
|
|
Profile profile;
|
|
const QString protocol = normalizedProtocol(m_protocolInput->currentText());
|
|
const QString authMode = normalizedAuthMode(protocol, m_authModeInput->currentText());
|
|
|
|
profile.id = -1;
|
|
profile.name = m_nameInput->text().trimmed();
|
|
profile.host = m_hostInput->text().trimmed();
|
|
profile.port = m_portInput->value();
|
|
profile.username = m_usernameInput->text().trimmed();
|
|
profile.domain = protocol == QStringLiteral("RDP") ? m_domainInput->text().trimmed() : QString();
|
|
profile.folderPath = m_defaultFolderPath.trimmed();
|
|
profile.tags = m_tagsInput->text().trimmed();
|
|
profile.protocol = protocol;
|
|
profile.authMode = authMode;
|
|
profile.privateKeyPath = (protocol == QStringLiteral("SSH")
|
|
&& authMode == QStringLiteral("Private Key"))
|
|
? m_privateKeyPathInput->text().trimmed()
|
|
: QString();
|
|
profile.knownHostsPolicy = protocol == QStringLiteral("SSH") ? m_knownHostsPolicyInput->currentText()
|
|
: QStringLiteral("Ask");
|
|
profile.rdpSecurityMode = protocol == QStringLiteral("RDP")
|
|
? m_rdpSecurityModeInput->currentText()
|
|
: QStringLiteral("Negotiate");
|
|
profile.rdpPerformanceProfile = protocol == QStringLiteral("RDP")
|
|
? m_rdpPerformanceProfileInput->currentText()
|
|
: QStringLiteral("Balanced");
|
|
return profile;
|
|
}
|
|
|
|
void ProfileDialog::accept()
|
|
{
|
|
if (m_nameInput->text().trimmed().isEmpty()) {
|
|
QMessageBox::warning(this,
|
|
QStringLiteral("Validation Error"),
|
|
QStringLiteral("Profile name is required."));
|
|
return;
|
|
}
|
|
|
|
if (m_hostInput->text().trimmed().isEmpty()) {
|
|
QMessageBox::warning(this,
|
|
QStringLiteral("Validation Error"),
|
|
QStringLiteral("Host is required."));
|
|
return;
|
|
}
|
|
|
|
const QString protocol = m_protocolInput->currentText();
|
|
|
|
if (protocol == QStringLiteral("SSH")
|
|
&& m_authModeInput->currentText() == QStringLiteral("Private Key")) {
|
|
const QString privateKeyPath = m_privateKeyPathInput->text().trimmed();
|
|
if (privateKeyPath.isEmpty()) {
|
|
QMessageBox::warning(this,
|
|
QStringLiteral("Validation Error"),
|
|
QStringLiteral("Private key path is required for SSH private key authentication."));
|
|
return;
|
|
}
|
|
|
|
if (!QFileInfo::exists(privateKeyPath)) {
|
|
QMessageBox::warning(this,
|
|
QStringLiteral("Validation Error"),
|
|
QStringLiteral("Private key file does not exist: %1").arg(privateKeyPath));
|
|
return;
|
|
}
|
|
}
|
|
|
|
QDialog::accept();
|
|
}
|
|
|
|
void ProfileDialog::refreshAuthFields()
|
|
{
|
|
const QString protocol = normalizedProtocol(m_protocolInput->currentText());
|
|
const bool isSsh = protocol == QStringLiteral("SSH");
|
|
const bool isRdp = protocol == QStringLiteral("RDP");
|
|
const bool isVnc = protocol == QStringLiteral("VNC");
|
|
|
|
const QString normalizedMode = normalizedAuthMode(protocol, m_authModeInput->currentText());
|
|
if (normalizedMode != m_authModeInput->currentText()) {
|
|
const QSignalBlocker blocker(m_authModeInput);
|
|
m_authModeInput->setCurrentText(normalizedMode);
|
|
}
|
|
const bool isPrivateKey = normalizedMode == QStringLiteral("Private Key");
|
|
|
|
m_authModeInput->setEnabled(isSsh);
|
|
m_privateKeyPathInput->setEnabled(isSsh && isPrivateKey);
|
|
m_browsePrivateKeyButton->setEnabled(isSsh && isPrivateKey);
|
|
m_knownHostsPolicyInput->setEnabled(isSsh);
|
|
m_domainInput->setEnabled(isRdp);
|
|
m_rdpSecurityModeInput->setEnabled(isRdp);
|
|
m_rdpPerformanceProfileInput->setEnabled(isRdp);
|
|
|
|
if (isSsh) {
|
|
m_usernameInput->setPlaceholderText(QStringLiteral("deploy"));
|
|
m_protocolHint->setText(QStringLiteral(
|
|
"SSH: you'll be asked for a username at connect time if left blank here. "
|
|
"Choose Password or Private Key auth."));
|
|
} else if (isRdp) {
|
|
m_usernameInput->setPlaceholderText(QStringLiteral("Administrator"));
|
|
m_protocolHint->setText(QStringLiteral(
|
|
"RDP: you'll be asked for a username at connect time if left blank here. "
|
|
"Domain is optional."));
|
|
} else if (isVnc) {
|
|
m_usernameInput->setPlaceholderText(QStringLiteral("optional"));
|
|
m_protocolHint->setText(QStringLiteral(
|
|
"VNC: host and port are required. Username is optional and ignored by most "
|
|
"servers, except macOS's built-in Screen Sharing, which requires it. Domain is "
|
|
"unused."));
|
|
}
|
|
|
|
m_folderHint->setText(m_defaultFolderPath.isEmpty()
|
|
? QStringLiteral("Target folder: root")
|
|
: QStringLiteral("Target folder: %1").arg(m_defaultFolderPath));
|
|
}
|