void SshConnectionPrivate::connectToHost()
{
QSSH_ASSERT_AND_RETURN(m_state == SocketUnconnected);
m_incomingData.clear();
m_incomingPacket.reset();
m_sendFacility.reset();
m_error = SshNoError;
m_ignoreNextPacket = false;
m_errorString.clear();
m_serverId.clear();
m_serverHasSentDataBeforeId = false;
try {
if (m_connParams.authenticationType == SshConnectionParameters::AuthenticationTypePublicKey)
createPrivateKey();
} catch (const SshClientException &ex) {
m_error = ex.error;
m_errorString = ex.errorString;
emit error(m_error);
return;
}
connect(m_socket, SIGNAL(connected()), this, SLOT(handleSocketConnected()));
connect(m_socket, SIGNAL(readyRead()), this, SLOT(handleIncomingData()));
connect(m_socket, SIGNAL(error(QAbstractSocket::SocketError)), this,
SLOT(handleSocketError()));
connect(m_socket, SIGNAL(disconnected()), this,
SLOT(handleSocketDisconnected()));
connect(&m_timeoutTimer, SIGNAL(timeout()), this, SLOT(handleTimeout()));
m_state = SocketConnecting;
m_keyExchangeState = NoKeyExchange;
m_timeoutTimer.start();
m_socket->connectToHost(m_connParams.host, m_connParams.port);
}
void SshRemoteProcessRunner::handleProcessStarted()
{
QSSH_ASSERT_AND_RETURN(d->m_state == Connected);
setState(ProcessRunning);
emit processStarted();
}
void SshForwardedTcpIpTunnelPrivate::handleOpenSuccessInternal()
{
QSSH_ASSERT_AND_RETURN(channelState() == AbstractSshChannel::SessionEstablished);
try {
m_sendFacility.sendChannelOpenConfirmationPacket(remoteChannel(), localChannelId(),
initialWindowSize(), maxPacketSize());
} catch (const std::exception &e) { // Won't happen, but let's play it safe.
qCWarning(sshLog, "Botan error: %s", e.what());
closeChannel();
}
}
void SshRemoteProcessRunner::handleProcessFinished(int exitStatus)
{
d->m_exitStatus = static_cast<SshRemoteProcess::ExitStatus>(exitStatus);
switch (d->m_exitStatus) {
case SshRemoteProcess::FailedToStart:
QSSH_ASSERT_AND_RETURN(d->m_state == Connected);
break;
case SshRemoteProcess::CrashExit:
QSSH_ASSERT_AND_RETURN(d->m_state == ProcessRunning);
d->m_exitSignal = d->m_process->exitSignal();
break;
case SshRemoteProcess::NormalExit:
QSSH_ASSERT_AND_RETURN(d->m_state == ProcessRunning);
d->m_exitCode = d->m_process->exitCode();
break;
default:
Q_ASSERT_X(false, Q_FUNC_INFO, "Impossible exit status.");
}
d->m_processErrorString = d->m_process->errorString();
setState(Inactive);
emit processClosed(exitStatus);
}
void SshRemoteProcessRunner::handleConnected()
{
QSSH_ASSERT_AND_RETURN(d->m_state == Connecting);
setState(Connected);
d->m_process = d->m_connection->createRemoteProcess(d->m_command);
connect(d->m_process.data(), SIGNAL(started()), SLOT(handleProcessStarted()));
connect(d->m_process.data(), SIGNAL(closed(int)), SLOT(handleProcessFinished(int)));
connect(d->m_process.data(), SIGNAL(readyReadStandardOutput()), SLOT(handleStdout()));
connect(d->m_process.data(), SIGNAL(readyReadStandardError()), SLOT(handleStderr()));
if (d->m_runInTerminal)
d->m_process->requestTerminal(d->m_terminal);
d->m_process->start();
}
void SshRemoteProcess::sendSignal(Signal signal)
{
try {
if (isRunning()) {
const char *signalString = 0;
for (size_t i = 0; i < sizeof signalMap/sizeof *signalMap && !signalString; ++i) {
if (signalMap[i].signalEnum == signal)
signalString = signalMap[i].signalString;
}
QSSH_ASSERT_AND_RETURN(signalString);
d->m_sendFacility.sendChannelSignalPacket(d->remoteChannel(), signalString);
}
} catch (Botan::Exception &e) {
setErrorString(QString::fromLatin1(e.what()));
d->closeChannel();
}
}
void SshRemoteProcessRunner::handleDisconnected()
{
QSSH_ASSERT_AND_RETURN(d->m_state == Connecting || d->m_state == Connected
|| d->m_state == ProcessRunning);
setState(Inactive);
}
void SshRemoteProcess::requestTerminal(const SshPseudoTerminal &terminal)
{
QSSH_ASSERT_AND_RETURN(d->channelState() == Internal::SshRemoteProcessPrivate::Inactive);
d->m_useTerminal = true;
d->m_terminal = terminal;
}
