SSH: Use enum for signals API.

There is no reason to bother the user with the protocol-internal
strings.

Change-Id: I7ebec9147b2d00cfdc779920d9ceb18e26c59755
Reviewed-by: hjk <qthjk@ovi.com>

src/libs/utils/ssh/sshremoteprocess.cpp

@@ -43,6 +43,7 @@
 #include <QtCore/QTimer>
 
 #include <cstring>
+#include <cstdlib>
 
 /*!
     \class Utils::SshRemoteProcess
@@ -59,19 +60,18 @@
 
 namespace Utils {
 
-const QByteArray SshRemoteProcess::AbrtSignal("ABRT");
-const QByteArray SshRemoteProcess::AlrmSignal("ALRM");
-const QByteArray SshRemoteProcess::FpeSignal("FPE");
-const QByteArray SshRemoteProcess::HupSignal("HUP");
-const QByteArray SshRemoteProcess::IllSignal("ILL");
-const QByteArray SshRemoteProcess::IntSignal("INT");
-const QByteArray SshRemoteProcess::KillSignal("KILL");
-const QByteArray SshRemoteProcess::PipeSignal("PIPE");
-const QByteArray SshRemoteProcess::QuitSignal("QUIT");
-const QByteArray SshRemoteProcess::SegvSignal("SEGV");
-const QByteArray SshRemoteProcess::TermSignal("TERM");
-const QByteArray SshRemoteProcess::Usr1Signal("USR1");
-const QByteArray SshRemoteProcess::Usr2Signal("USR2");
+const struct {
+    SshRemoteProcess::Signal signalEnum;
+    const char * const signalString;
+} signalMap[] = {
+    { SshRemoteProcess::AbrtSignal, "ABRT" }, { SshRemoteProcess::AlrmSignal, "ALRM" },
+    { SshRemoteProcess::FpeSignal, "FPE" }, { SshRemoteProcess::HupSignal, "HUP" },
+    { SshRemoteProcess::IllSignal, "ILL" }, { SshRemoteProcess::IntSignal, "INT" },
+    { SshRemoteProcess::KillSignal, "KILL" }, { SshRemoteProcess::PipeSignal, "PIPE" },
+    { SshRemoteProcess::QuitSignal, "QUIT" }, { SshRemoteProcess::SegvSignal, "SEGV" },
+    { SshRemoteProcess::TermSignal, "TERM" }, { SshRemoteProcess::Usr1Signal, "USR1" },
+    { SshRemoteProcess::Usr2Signal, "USR2" }
+};
 
 SshRemoteProcess::SshRemoteProcess(const QByteArray &command, quint32 channelId,
     Internal::SshSendFacility &sendFacility)
@@ -197,12 +197,18 @@ void SshRemoteProcess::start()
     }
 }
 
-void SshRemoteProcess::sendSignal(const QByteArray &signal)
+void SshRemoteProcess::sendSignal(Signal signal)
 {
     try {
-        if (isRunning())
-            d->m_sendFacility.sendChannelSignalPacket(d->remoteChannel(),
-                signal);
+        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;
+            }
+            QTC_ASSERT(signalString, return);
+            d->m_sendFacility.sendChannelSignalPacket(d->remoteChannel(), signalString);
+        }
     }  catch (Botan::Exception &e) {
         setErrorString(QString::fromAscii(e.what()));
         d->closeChannel();
@@ -215,7 +221,11 @@ bool SshRemoteProcess::isRunning() const
 }
 
 int SshRemoteProcess::exitCode() const { return d->m_exitCode; }
-QByteArray SshRemoteProcess::exitSignal() const { return d->m_signal; }
+
+SshRemoteProcess::Signal SshRemoteProcess::exitSignal() const
+{
+    return static_cast<SshRemoteProcess::Signal>(d->m_signal);
+}
 
 namespace Internal {
 
@@ -246,6 +256,7 @@ void SshRemoteProcessPrivate::init()
     m_wasRunning = false;
     m_exitCode = 0;
     m_readChannel = QProcess::StandardOutput;
+    m_signal = SshRemoteProcess::NoSignal;
 }
 
 void SshRemoteProcessPrivate::setProcState(ProcessState newState)
@@ -270,7 +281,7 @@ QByteArray &SshRemoteProcessPrivate::data()
 void SshRemoteProcessPrivate::closeHook()
 {
     if (m_wasRunning) {
-        if (!m_signal.isEmpty())
+        if (m_signal != SshRemoteProcess::NoSignal)
             emit closed(SshRemoteProcess::KilledBySignal);
         else
             emit closed(SshRemoteProcess::ExitedNormally);
@@ -357,9 +368,18 @@ void SshRemoteProcessPrivate::handleExitSignal(const SshChannelExitSignal &signa
 #ifdef CREATOR_SSH_DEBUG
     qDebug("Exit due to signal %s", signal.signal.data());
 #endif
-    m_signal = signal.signal;
+
+    for (size_t i = 0; i < sizeof signalMap/sizeof *signalMap; ++i) {
+        if (signalMap[i].signalString == signal.signal) {
+            m_signal = signalMap[i].signalEnum;
             m_procState = Exited;
             m_proc->setErrorString(tr("Process killed by signal"));
+            return;
+        }
+    }
+
+    throw SshServerException(SSH_DISCONNECT_PROTOCOL_ERROR, "Invalid signal",
+        tr("Server sent invalid signal '%1'").arg(QString::fromUtf8(signal.signal)));
 }
 
 } // namespace Internal

src/libs/utils/ssh/sshremoteprocess.h

@@ -61,20 +61,10 @@ class QTCREATOR_UTILS_EXPORT SshRemoteProcess : public QIODevice
 public:
     typedef QSharedPointer<SshRemoteProcess> Ptr;
     enum ExitStatus { FailedToStart, KilledBySignal, ExitedNormally };
-
-    static const QByteArray AbrtSignal;
-    static const QByteArray AlrmSignal;
-    static const QByteArray FpeSignal;
-    static const QByteArray HupSignal;
-    static const QByteArray IllSignal;
-    static const QByteArray IntSignal;
-    static const QByteArray KillSignal;
-    static const QByteArray PipeSignal;
-    static const QByteArray QuitSignal;
-    static const QByteArray SegvSignal;
-    static const QByteArray TermSignal;
-    static const QByteArray Usr1Signal;
-    static const QByteArray Usr2Signal;
+    enum Signal {
+        AbrtSignal, AlrmSignal, FpeSignal, HupSignal, IllSignal, IntSignal, KillSignal, PipeSignal,
+        QuitSignal, SegvSignal, TermSignal, Usr1Signal, Usr2Signal, NoSignal
+    };
 
     ~SshRemoteProcess();
 
@@ -99,13 +89,13 @@ public:
 
     bool isRunning() const;
     int exitCode() const;
-    QByteArray exitSignal() const;
+    Signal exitSignal() const;
 
     QByteArray readAllStandardOutput();
     QByteArray readAllStandardError();
 
     // Note: This is ignored by the OpenSSH server.
-    void sendSignal(const QByteArray &signal);
+    void sendSignal(Signal signal);
     void kill() { sendSignal(KillSignal); }
 
 signals:

src/libs/utils/ssh/sshremoteprocess_p.h

@@ -91,7 +91,7 @@ private:
 
     ProcessState m_procState;
     bool m_wasRunning;
-    QByteArray m_signal;
+    int m_signal;
     int m_exitCode;
 
     const QByteArray m_command;

src/libs/utils/ssh/sshremoteprocessrunner.cpp

@@ -63,7 +63,7 @@ public:
     Utils::SshError m_lastConnectionError;
     QString m_lastConnectionErrorString;
     SshRemoteProcess::ExitStatus m_exitStatus;
-    QByteArray m_exitSignal;
+    SshRemoteProcess::Signal m_exitSignal;
     int m_exitCode;
     QString m_processErrorString;
     State m_state;
@@ -110,7 +110,7 @@ void SshRemoteProcessRunner::runInternal(const QByteArray &command,
     d->m_lastConnectionError = SshNoError;
     d->m_lastConnectionErrorString.clear();
     d->m_processErrorString.clear();
-    d->m_exitSignal.clear();
+    d->m_exitSignal = SshRemoteProcess::NoSignal;
     d->m_exitCode = -1;
     d->m_command = command;
     d->m_connection = SshConnectionManager::instance().acquireConnection(sshParams);
@@ -234,7 +234,7 @@ SshRemoteProcess::ExitStatus SshRemoteProcessRunner::processExitStatus() const
     return d->m_exitStatus;
 }
 
-QByteArray SshRemoteProcessRunner::processExitSignal() const
+SshRemoteProcess::Signal SshRemoteProcessRunner::processExitSignal() const
 {
     QTC_CHECK(processExitStatus() == SshRemoteProcess::KilledBySignal);
     return d->m_exitSignal;
@@ -257,7 +257,7 @@ void SshRemoteProcessRunner::writeDataToProcess(const QByteArray &data)
     d->m_process->write(data);
 }
 
-void SshRemoteProcessRunner::sendSignalToProcess(const QByteArray &signal)
+void SshRemoteProcessRunner::sendSignalToProcess(SshRemoteProcess::Signal signal)
 {
     QTC_ASSERT(isProcessRunning(), return);
     d->m_process->sendSignal(signal);

src/libs/utils/ssh/sshremoteprocessrunner.h

@@ -59,10 +59,10 @@ public:
 
     bool isProcessRunning() const;
     void writeDataToProcess(const QByteArray &data);
-    void sendSignalToProcess(const QByteArray &signal); // No effect with OpenSSH server.
+    void sendSignalToProcess(SshRemoteProcess::Signal signal); // No effect with OpenSSH server.
     void cancel(); // Does not stop remote process, just frees SSH-related process resources.
     SshRemoteProcess::ExitStatus processExitStatus() const;
-    QByteArray processExitSignal() const;
+    SshRemoteProcess::Signal processExitSignal() const;
     int processExitCode() const;
     QString processErrorString() const;