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; }