MochiuWiki : SUSE, EC, PCB

「Qtの基礎 - SSH」の版間の差分

📢 Webサイト閉鎖と移転のお知らせ
このWebサイトは2026年9月に閉鎖いたします。
新しい記事は移転先で追加しております。（旧サイトでは記事を追加しておりません）

← 古い編集
ビジュアルウィキテキスト
細 文字列「__FORCETOC__」を「{{#seo: |title={{PAGENAME}} : Exploring Electronics and SUSE Linux | MochiuWiki |keywords=MochiuWiki,Mochiu,Wiki,Mochiu Wiki,Electric Circuit,Electric,pcb,Mathematics,AVR,TI,STMicro,AVR,ATmega,MSP430,STM,Arduino,Xilinx,FPGA,Verilog,HDL,PinePhone,Pine Phone,Raspberry,Raspberry Pi,C,C++,C#,Qt,Qml,MFC,Shell,Bash,Zsh,Fish,SUSE,SLE,Suse Enterprise,Suse Linux,openSUSE,open SUSE,Leap,Linux,uCLnux,Podman,電気回路,電子回路,基板,プリント基板 |description={{PAGENAME}} - 電子回路とSUSE Linuxに関する情報 | This pag…
 
(同じ利用者による、間の29版が非表示)
2行目: 2行目:
Qtにおいて、簡潔にSSH接続を確立する手順を記載する。<br>
Qtにおいて、簡潔にSSH接続を確立する手順を記載する。<br>
<br>
<br>
* libsshまたはlibssh2を使用する。
* libSSHライブラリ (LGPLライセンス) を使用する。
* QProcessクラスを使用して、外部のSSHプロセスを呼び出して接続を確立する。
* libSSH2ライブラリ (3条項BSDライセンス) を使用する。
* 他のSSHライブラリを購入する。<br>http://netsieben.com/products/ssh
* <code>QProcess</code>クラスを使用して、外部のSSHプロセスをフォークして接続を確立する。
* wolfSSH
*: wolfSSHライブラリは、wolfSSLと連携して使用する。
*: 無償版は、<u>GPL v2ライセンス</u>である。
*: 有償版は、独自ライセンスである。
*: https://wolfssl.jp/products/wolfssh/
*: Github : https://github.com/wolfSSL/wolfssh
*: wolfSSLのGithub : https://github.com/wolfSSL/wolfssl
*: <br>
*: また、wolfSSLは、IoTデバイス、組み込み向け小型デバイスにも対応した軽量のSSL/TLSライブラリである。
* QSshライブラリを使用する。
*: QSshは、QtアプリケーションにSSHとSFTPのサポートを提供する。
*: QSshプロジェクトは、過去のQt CreatorのSSHプラグインに基づいており、全てのクレジットはQt Creatorチームに帰属する。
*: ただし、現在では、Qt CreatorはOpenSSHを使用している。
*: <br>
*: https://github.com/sandsmark/QSsh
<br><br>
<br><br>


192行目: 207行目:
  #include <libssh/libssh.h>
  #include <libssh/libssh.h>
   
   
  int VerifyKnownsHost(ssh_session session, QString &strErrMsg);
  int VerifyKnownsHost(ssh_session my_ssh_session, QString &strErrMsg);
   
   
  int main(int argc, char *argv[])
  int main(int argc, char *argv[])
199行目: 214行目:
   
   
     // SSHセッションの作成
     // SSHセッションの作成
     ssh_session ssh_session = ssh_new();
     ssh_session my_ssh_session = ssh_new();
     if (my_ssh_session == NULL) {
     if (my_ssh_session == NULL) {
       // 作成に失敗した場合
       // 作成に失敗した場合
210行目: 225行目:
     QString port = "<SSHポート番号  例: 22>";
     QString port = "<SSHポート番号  例: 22>";


     ssh_options_set(ssh_session, SSH_OPTIONS_HOST, host.toUtf8().data());
     ssh_options_set(my_ssh_session, SSH_OPTIONS_HOST, host.toUtf8().data());
     ssh_options_set(ssh_session, SSH_OPTIONS_USER, user.toUtf8().data());
     ssh_options_set(my_ssh_session, SSH_OPTIONS_USER, user.toUtf8().data());
     ssh_options_set(ssh_session, SSH_OPTIONS_PORT_STR, port.toUtf8().data());
     ssh_options_set(my_ssh_session, SSH_OPTIONS_PORT_STR, port.toUtf8().data());
   
   
     // SSH接続
     // SSH接続
     int rc = ssh_connect(ssh_session);
     int rc = ssh_connect(my_ssh_session);
     if (rc != SSH_OK) {
     if (rc != SSH_OK) {
       // 接続に失敗した場合
       // 接続に失敗した場合
       fprintf(stderr, "Error connecting to host: %s\n", ssh_get_error(ssh_session));
       fprintf(stderr, "Error connecting to host: %s\n", ssh_get_error(my_ssh_session));
       ssh_free(ssh_session);
       ssh_free(my_ssh_session);
   
   
       return -1;
       return -1;
226行目: 241行目:
     // ~/.sshディレクトリ等にあるファイルに記述されているサーバのIDを検証
     // ~/.sshディレクトリ等にあるファイルに記述されているサーバのIDを検証
     QString strErrMsg = "";
     QString strErrMsg = "";
     if(VerifyKnownsHost(ssh_session, strErrMsg) < 0)
     if(VerifyKnownsHost(my_ssh_session, strErrMsg) < 0)
     {
     {
       fprintf(stderr, "%s\n", strErrMsg.toUtf8().constData();
       fprintf(stderr, "%s\n", strErrMsg.toUtf8().constData();
       if(ssh_session != nullptr)
       if(my_ssh_session != nullptr)
       {
       {
           ssh_disconnect(ssh_session);
           ssh_disconnect(my_ssh_session);
           ssh_free(ssh_session);
           ssh_free(my_ssh_session);
       }
       }
   
   
243行目: 258行目:
   
   
     // 秘密鍵のパスフレーズを設定していない場合
     // 秘密鍵のパスフレーズを設定していない場合
     rc = ssh_userauth_privatekey_file(ssh_session, nullptr, private_key_path, nullptr);
     rc = ssh_userauth_privatekey_file(my_ssh_session, nullptr, private_key_path, nullptr);
   
   
     // 秘密鍵のパスフレーズを設定している場合
     // 秘密鍵のパスフレーズを設定している場合
     rc = ssh_userauth_privatekey_file(ssh_session, nullptr, private_key_path, "<秘密鍵のパスフレーズ>");
     rc = ssh_userauth_privatekey_file(my_ssh_session, nullptr, private_key_path, "<秘密鍵のパスフレーズ>");
   
   
     if (rc != SSH_AUTH_SUCCESS) {
     if (rc != SSH_AUTH_SUCCESS) {
261行目: 276行目:
   
   
     // SSH接続の切断
     // SSH接続の切断
     ssh_disconnect(ssh_session);
     ssh_disconnect(my_ssh_session);
   
   
     // SSHセッションの解放
     // SSHセッションの解放
     ssh_free(ssh_session);
     ssh_free(my_ssh_session);
   
   
     return 0;
     return 0;
  }
  }
   
   
  int VerifyKnownsHost(ssh_session ssh_session, QString &strErrMsg)
  int VerifyKnownsHost(ssh_session my_ssh_session, QString &strErrMsg)
  {
  {
     // Authenticating the server.
     // Authenticating the server.
     ssh_key srv_pubkey = {};
     ssh_key srv_pubkey = {};
     if(ssh_get_server_publickey(ssh_session, &srv_pubkey) < 0)
     if(ssh_get_server_publickey(my_ssh_session, &srv_pubkey) < 0)
     {
     {
       strErrMsg = tr("Failed to get public key.");
       strErrMsg = tr("Failed to get public key.");
293行目: 308行目:
     }
     }
   
   
     auto state = ssh_session_is_known_server(ssh_session);
     auto state = ssh_session_is_known_server(my_ssh_session);
     if(state == ssh_known_hosts_e::SSH_KNOWN_HOSTS_OK)
     if(state == ssh_known_hosts_e::SSH_KNOWN_HOSTS_OK)
     {  // Authentication Successful
     {  // Authentication Successful
341行目: 356行目:
       else
       else
       {
       {
           iRet = ssh_session_update_known_hosts(ssh_session);
           iRet = ssh_session_update_known_hosts(my_ssh_session);
           if(iRet < 0)
           if(iRet < 0)
           {
           {
368行目: 383行目:
       else
       else
       {
       {
           iRet = ssh_session_update_known_hosts(ssh_session);
           iRet = ssh_session_update_known_hosts(my_ssh_session);
           if(iRet < 0)
           if(iRet < 0)
           {
           {
389行目: 404行目:
   
   
     return 0;
     return 0;
  }
  } </syntaxhighlight>
</syntaxhighlight>
<br><br>
<br><br>


403行目: 417行目:
<br><br>
<br><br>


== libSSH2の使用例 ==
== libSSH2ライブラリを使用したコマンドの使用例 ==
==== ブロッキングモード ====
以下の例では、リモート側のPCにSSH接続して、lsコマンドを実行してその結果をローカル側のPCに表示している。<br>
<br>
以下の例は、<u>ブロッキングモード</u>でlsコマンドを実行している。<br>
<br>
<syntaxhighlight lang="make">
# .pro プロジェクトファイル
# QTcpSocketを使用する場合
QT += network
# pkg-configを使用する場合
CONFIG += link_pkgconfig
LIBS += \
    -L/<libSSH2のインストールディレクトリ>/lib64 -lssh2
# pkg-configを使用しない場合
LIBS += \
    -L/<libSSH2のインストールディレクトリ>/lib64 -lssh2
INCLUDEPATH += \
    /<libSSH2のインストールディレクトリ>/include
</syntaxhighlight>
<br>
  <syntaxhighlight lang="c++">
  <syntaxhighlight lang="c++">
// main.cpp
  #include <QCoreApplication>
  #include <QCoreApplication>
  #include <QFileInfo>
  #include <QTcpSocket>
#include <QTimer>
#include <QElapsedTimer>
  #include <QDebug>
  #include <QDebug>
  #include <libssh2.h>
  #include <libssh2.h>
#include <libssh2_sftp.h>
  #include "DivideByZeroException.h"
  #include "DivideByZeroException.h"
   
   
#ifdef Q_OS_LINUX
  void DisConnect(QTcpSocket &sock, LIBSSH2_SESSION *session);
#include <sys/socket.h>
  int  ExecCommand(QTcpSocket &sock, LIBSSH2_SESSION *session);
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#endif
  void DisConnect(int &sock, LIBSSH2_SESSION *session);
  int  Send(int &sock, LIBSSH2_SESSION *session);
int  waitsocket(libssh2_socket_t socket_fd, LIBSSH2_SESSION *session);
   
   
  int main(int argc, char *argv[])
  int main(int argc, char *argv[])
431行目: 458行目:
   
   
     int rc  = 0;
     int rc  = 0;
     int sock = 0;
     QTcpSocket sock;
     LIBSSH2_SESSION *session = nullptr;
     LIBSSH2_SESSION *session = nullptr;
   
   
#if defined(Q_OS_WIN32) || defined(Q_OS_WIN64)
    // libSSH2オブジェクトの初期化
    WSADATA wsadata;
    auto rc = libssh2_init(0);
    if (rc != 0) {
        qDebug() << "libssh2 initialization failed";
        DisConnect(sock, session);
   
   
    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
        return -1;
    if(rc) {
      std::cerr << "WSAStartup failed with error: " << rc << std::endl;
      return -1;
     }
     }
#endif
   
   
     // 初期化
     // QTcpSocketクラスのインスタンスを生成して、リモートPCに接続
     rc = libssh2_init(0);
     sock.connectToHost(<リモートPCのIPアドレスまたはホスト名>, <リモートPCにSSH接続するポート番号>);
     if (rc != 0) {
       qDebug() << QString("libssh2 initialization failed %1").arg(rc);
    // 最大10[秒]待機
     if (!sock.waitForConnected(10000)) {
       qDebug() << "SSH接続に失敗:" << socket.errorString();
       DisConnect(sock, session);
       DisConnect(sock, session);
   
   
453行目: 482行目:
     }
     }
   
   
     // ソケットの作成
     // SSHのセッションの初期化
     sock = socket(AF_INET, SOCK_STREAM, 0);
     session = libssh2_session_init();
     if (sock == -1) {
     if (!session) {
       qDebug() << QString("failed to create socket.");
       qDebug() << "SSHのセッションの初期化に失敗";
       DisConnect(sock, session);
       DisConnect(sock, session);
   
   
462行目: 491行目:
     }
     }
   
   
    struct sockaddr_in sin = {};
     // SSHのハンドシェイク
    sin.sin_family = AF_INET;
     if (libssh2_session_handshake(session, sock.socketDescriptor()) != 0) {
    sin.sin_port = htons(50022);
       qDebug() << "SSHのハンドシェイクに失敗";
    sin.sin_addr.s_addr = inet_addr("<リモート側PCのIPアドレス または ホスト名>");
     // SSH接続
     if (connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in)) == -1) {
       qDebug() << QString("failed to connect.");
       DisConnect(sock, session);
       DisConnect(sock, session);
   
   
475行目: 499行目:
     }
     }
   
   
     // libSSH2のセッションを初期化
     // リモートPCのフィンガープリントを確認
     session = libssh2_session_init();
     auto fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
    qDebug() << "リモートPCのフィンガープリント:" << fingerprint;
   
   
     // リモート側のPCとのハンドシェイク
     // 認証方法の確認
     libssh2_session_handshake(session, sock);
     auto userauth_list = libssh2_userauth_list(session, "<リモートPCのユーザ名>", strlen(USERNAME));
    qDebug() << "認証方法:" << userauth_list;
   
   
     // パスワード認証
     // パスワード認証を行う場合
     if (libssh2_userauth_password(session, "<リモート側のユーザ名>", "<ユーザ名のパスワード>") != 0) {
     //if (libssh2_userauth_password(session, "<リモートPCのユーザ名>", "<リモートPCのユーザパスワード>") != 0) {
      qDebug() << QString("Authentication failed.");
    //  qDebug() << "パスワードによる認証に失敗";
    //  return -1;
    //}
 
    // 公開鍵認証
    if (libssh2_userauth_publickey_fromfile(session, "<リモートPCのユーザ名>", "<公開鍵ファイルのパス>", "<秘密鍵ファイルのパス>", "<秘密鍵のパスフレーズ>") != 0) {
      qDebug() << "公開鍵認証に失敗";
       DisConnect(sock, session);
       DisConnect(sock, session);
   
   
492行目: 524行目:
   
   
     // SSH接続後の処理
     // SSH接続後の処理
     // SCPでファイルを送信
     // リモートPC上でls -alコマンドを実行
     rc = Send(sock, session);
     rc = ExecCommand(sock, session);
     if (rc != 0) {
     if (rc != 0) {
       DisConnect(sock, session);
       DisConnect(sock, session);
506行目: 538行目:
  }
  }
   
   
  void DisConnect(int &sock, LIBSSH2_SESSION *session)
  void DisConnect(QTcpSocket &sock, LIBSSH2_SESSION *session)
  {
  {
     // セッションの終了
     // セッションの終了
516行目: 548行目:
   
   
     // ソケットを閉じる
     // ソケットを閉じる
     if (sock != LIBSSH2_INVALID_SOCKET) {
     if(sock.isOpen()) {
      shutdown(sock, 2);
        sock.close();
#if defined(Q_OS_WIN32) || defined(Q_OS_WIN64)
      closesocket(sock);
#else
      close(sock);
#endif
     }
     }
   
   
533行目: 558行目:
  }
  }
   
   
  int Send(int &sock, LIBSSH2_SESSION *session)
  int ExecCommand(QTcpSocket &sock, LIBSSH2_SESSION *session)
  {
  {
     // Send a file via scp. The mode parameter must only have permissions.
     // チャンネルをオープン
     LIBSSH2_CHANNEL *channel = nullptr;
     LIBSSH2_CHANNEL *channel = libssh2_channel_open_session(session);
    if (!channel) {
      qDebug() << "チャンネルのオープンに失敗";
      return -1;
    }
   
   
     QString localFilePath = "<ローカルPCのファイルパス  例: /tmp/hoge.png>";
     // リモートPC上でls -alコマンドを実行
    QFile File(localFilePath);
     if (libssh2_channel_exec(channel, "ls -la") != 0) {
     if(!File.open(QIODevice::ReadOnly))
       qDebug() << "コマンドの実行に失敗";
    {
       qDebug() << QString("Cannot open local File(%1) Open Error: %2").arg(QFileInfo(File).fileName(), File.errorString());
       return -1;
       return -1;
     }
     }
   
   
     // QFileInfoクラスではパーミッションは16進数のため、libssh2_scp_send64関数で使用するため8進数に変換する
     // ls -alコマンドの実行結果を取得
     // これは、見た目の数値を同じにする必要がある 例: 0x644(16進数) --> 0644(8進数)
    int rc = 0;
     QFileInfo FileInfo(localFilePath);
    QByteArray buffer;
     //// ステッキービットは不要なため削除
     buffer.resize(1024);  // バッファサイズを1024バイトに指定
     auto hexPermisshionString = QString::number(FileInfo.permissions(), 16).mid(1);
   
     bool ok;
    do {
     //// 8進数に変換
      rc = libssh2_channel_read(channel, buffer.data(), buffer.size());
     unsigned int octPermisshionValue = hexPermisshionString.toInt(&ok, 8);
      if (rc > 0) {
     if (!ok) {
          qDebug().noquote() << QString::fromUtf8(buffer.constData(), rc);
       qDebug() << QString("Failed to convert permission value.");
      }
       return -1;
      else if (rc < 0) {
          qDebug() << "Error reading channel:" << rc;
          break;
      }
     } while (rc > 0);
     // チャンネルの終了を確認
    // 終了コードおよび終了シグナルを取得して表示
    int  exitcode    = 127;
    char *exitsignal = nullptr;
    rc = libssh2_channel_close(channel);
     if (rc == 0) {
      exitcode = libssh2_channel_get_exit_status(channel);
      libssh2_channel_get_exit_signal(channel, &exitsignal, nullptr, nullptr, nullptr, nullptr, nullptr);
    }
    if (exitsignal) qDebug() << "Exit signal:" << exitsignal;
    else            qDebug() << "Exit code:" << exitcode;
    return 0;
}
</syntaxhighlight>
<br>
<syntaxhighlight lang="c++">
// DivideByZeroException.h
#ifndef DIVIDEBYZEROEXCEPTION_H
#define DIVIDEBYZEROEXCEPTION_H
#include <QException>
class DivideByZeroException : public QException
{
public:
    DivideByZeroException() {};
    virtual ~DivideByZeroException() {};
    const char* what() const noexcept override {
      return "Divide by zero exception";
    }
};
#endif // DIVIDEBYZEROEXCEPTION_H
</syntaxhighlight>
<br>
==== ノンブロッキングモード ====
以下の例では、リモート側のPCにSSH接続して、lsコマンドを実行してその結果をローカル側のPCに表示している。<br>
<br>
以下の例は、<u>ノンブロッキングモード</u>でlsコマンドを実行している。<br>
<u>ノンブロッキングモード</u> (シグナル / スロット) で設計する場合、libSSH2ライブラリの関数呼び出しは即座に返されて、処理がバックグラウンドで非同期に進行する。<br>
これにより、プログラムは他の処理を続行でき、必要に応じてリモートホストとの通信が完了するのを待つことができる。<br>
<br>
ノンブロッキングモードを使用する場合、特に入出力操作が発生する待ち時間を最小限に抑え、プログラムがより効率的に動作することが期待される。<br>
しかし、ノンブロッキングモードを扱う際には、非同期処理やイベント駆動型のプログラミングに慣れる必要がある。<br>
<br>
<syntaxhighlight lang="c++">
// SSHClient.hファイル
#include <QCoreApplication>
#include <QTcpSocket>
#include <QTimer>
#include <QDebug>
#include <libssh2.h>
 
class SSHClient : public QObject
{
    Q_OBJECT
private:
    QTcpSocket      *m_Socket;
    LIBSSH2_SESSION *m_Session;
    LIBSSH2_CHANNEL *m_Channel;
    QString        m_Host;
    quint16        m_Port;
    QString        m_User;
    QString        m_Passwaord;
    QString        m_PubKey;
    QString        m_PrivateKey;
    QString        m_Passphrase;
public:
    SSHClient(QString host, quint16 port, QString user, QString password, QObject *parent = nullptr);
    SSHClient(QString host, quint16 port, QString user,
              QString pubkey, QString privkey, QString phrase, QObject *parent = nullptr);
    ~SSHClient();
    void connectToHost();
private slots:
    void onConnected();
    void authenticateUser();
    void openChannel();
    void executeCommand();
    void onReadyRead();
     void readOutput();
     void closeChannel();
};
</syntaxhighlight>
<br>
<syntaxhighlight lang="c++">
// SSHClient.cppファイル
#include "SSHClient.h"
SSHClient::SSHClient(QString host, quint16 port, QString user, QString password, QObject *parent = nullptr) :
    QObject(parent), m_Session(nullptr), m_Channel(nullptr), m_Host(host), m_Port(port), m_User(user), m_Password(password)
{
    m_Socket = new QTcpSocket(this);
    connect(m_Socket, &QTcpSocket::connected, this, &SSHClient::onConnected);
    connect(m_Socket, &QTcpSocket::readyRead, this, &SSHClient::onReadyRead);
    // libSSH2ライブラリの初期化
    if (libssh2_init(0) != 0) {
      qDebug() << "libSSH2ライブラリの初期化に失敗";
      return;
    }
}
SSHClient::SSHClient(QString host, quint16 port, QString user, QString pubkey, QString privkey, QString phrase, QObject *parent = nullptr) :
    QObject(parent), m_Session(nullptr), m_Channel(nullptr),
     m_Host(host), m_Port(port), m_User(user), m_PublicKey(pubkey), m_PrivateKey(privkey), m_Passphrase(phrase)
{
    m_Socket = new QTcpSocket(this);
    connect(m_Socket, &QTcpSocket::connected, this, &SSHClient::onConnected);
    connect(m_Socket, &QTcpSocket::readyRead, this, &SSHClient::onReadyRead);
    // libSSH2ライブラリの初期化
     if (libssh2_init(0) != 0) {
      qDebug() << "libSSH2ライブラリの初期化に失敗";
      return;
    }
}
SSHClient::~SSHClient()
{
    if (m_Channel) libssh2_channel_free(m_Channel);
    if (m_Session) {
       libssh2_session_disconnect(m_Session, "Normal Shutdown");
      libssh2_session_free(m_Session);
    }
    libssh2_exit();
}
void SSHClient::connectToHost()
{
    m_Socket->connectToHost(m_Host, m_Port);
}
void SSHClient::onConnected()
{
    qDebug() << "ホストへの接続に成功";
    m_Session = libssh2_session_init();
    libssh2_session_set_blocking(m_Session, 0);
    int rc = 0;
    do {
      rc = libssh2_session_handshake(m_Session, m_Socket->socketDescriptor());
    } while (rc == LIBSSH2_ERROR_EAGAIN);
    if (rc) {
      qDebug() << "SSHのセッションの確立に失敗:" << rc;
      return;
    }
    authenticateUser();
}
void SSHClient::authenticateUser()
{
    int rc = 0;
    do {
      // パスワード認証を行う場合
      //rc = libssh2_userauth_password(m_Session,
      //                              m_User.toUtf8().constData(),
      //                              m_Password.toUtf8().constData());
      // 公開鍵認証を行う場合
      rc = libssh2_userauth_publickey_fromfile(m_Session,
                                                m_User.toUtf8().constData(),
                                                "",  // クライアントPCに秘密鍵があり、
                                                    // リモートPC側に公開鍵が設置されている場合
                                                m_PrivateKey.toUtf8().constData(),
                                                m_Passphrase.isEmpty() ? nullptr : m_Passphrase.toUtf8().constData());
    } while (rc == LIBSSH2_ERROR_EAGAIN);
    if (rc) {
      qDebug() << "認証に失敗:" << rc;
       return;
     }
     }
   
   
     QString remoteFilePath = "<リモート側PCのファイルパス 例: /home/remote-user/hoge.png>";
     openChannel();
}
  void SSHClient::openChannel()
{
    int rc = 0;
     do {
     do {
      channel = libssh2_scp_send64(session, remoteFilePath.toUtf8().constData(), octPermisshionValue & 0777, FileInfo.size(), 0, 0);
        m_Channel = libssh2_channel_open_session(m_Session);
      if (!channel && libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
    } while (m_Channel == nullptr && libssh2_session_last_error(m_Session, nullptr, nullptr, 0) == LIBSSH2_ERROR_EAGAIN);
          File.close();
    if (!m_Channel) {
      qDebug() << "チャンネルのオープンに失敗";
      return;
    }
   
   
          char *err_msg;
    executeCommand();
          libssh2_session_last_error(session, &err_msg, NULL, 0);
}
          qDebug() << err_msg;
 
void SSHClient::executeCommand()
{
    int rc = 0;
    do {
      rc = libssh2_channel_exec(m_Channel, "ls -la");
    } while (rc == LIBSSH2_ERROR_EAGAIN);
   
   
           return -1;
    if (rc) {
      qDebug() << "lsコマンドの実行に失敗:" << rc;
      return;
    }
    // lsコマンドの出力結果を取得を開始
    QTimer::singleShot(0, this, &SSHClient::readOutput);
}
void SSHClient::onReadyRead()
{
    readOutput();
}
void SSHClient::readOutput()
{
    if (!m_Channel) return;
    QByteArray buffer;
    buffer.resize(1024);
    int rc = 0;
    while (rc != LIBSSH2_ERROR_EAGAIN) {
      rc = libssh2_channel_read(m_Channel, buffer.data(), buffer.size());
      if (rc > 0) {
          qDebug().noquote() << QString::fromUtf8(buffer.constData(), rc);
      }
      else if (rc < 0) {
          qDebug() << "チャンネルの読み取りエラー:" << rc;
          closeChannel();
           return;
       }
       }
     } while (!channel);
     }
   
   
     qDebug() << QString("SCP session waiting to send file.");
     // チャンネルがEOFかどうかを確認
    if (libssh2_channel_eof(m_Channel) == 1) {
      closeChannel();
    }
    else {
      // 続きを読み込む
      QTimer::singleShot(0, this, &SSHClient::readOutput);
    }
}
   
   
    // タイマの開始
void SSHClient::closeChannel()
    QElapsedTimer elapsedTimer;
{
     elapsedTimer.start();
     if (!m_Channel) return;
   
   
     int nread = 0,
     int rc = 0;
        total = 0;
    char mem[1024 * 100] = {};
     do {
     do {
       nread = File.read(mem, sizeof(mem));
       rc = libssh2_channel_close(m_Channel);
       if(nread <= 0) {
    } while (rc == LIBSSH2_ERROR_EAGAIN);
           // EOF
           break;
    if (rc == 0) {
      int exitcode    = libssh2_channel_get_exit_status(m_Channel);
      char *exitsignal = nullptr;
      libssh2_channel_get_exit_signal(m_Channel, &exitsignal, nullptr, nullptr, nullptr, nullptr, nullptr);
       if (exitsignal) {
           qDebug() << "Exit signal:" << exitsignal;
      }
      else {
           qDebug() << "Exit code:" << exitcode;
       }
       }
    }
    libssh2_channel_free(m_Channel);
    m_Channel = nullptr;
    // Disconnect from the host
    m_Socket->disconnectFromHost();
}
</syntaxhighlight>
<br>
<syntaxhighlight lang="c++">
// main.cppファイル
   
   
        auto ptr = mem;
int main(int argc, char *argv[])
        total += nread;
{
        auto prev = 0;
    QCoreApplication a(argc, argv);
        do {
          ssize_t nwritten;
          while ((nwritten = libssh2_channel_write(channel, ptr, nread)) == LIBSSH2_ERROR_EAGAIN) {
              waitsocket(sock, session);
              prev = 0;
          }
   
   
          if (nwritten < 0) {
    // パスワード認証を行う場合
              qDebug() << QString("ERROR %1 total %2 / %3 prev %4").arg((int)nwritten)
    //SSHClient client("<リモートPC側のIPアドレスまたはホスト名>", <リモートPCのポート番号>,
                                                                  .arg((long)total)
    //                "<リモートPC側のユーザ名>", "<リモートPC側のユーザパスワード>");
                                                                  .arg((int)nread)
                                                                  .arg((int)prev);
              break;
          }
          else {
              prev = nread;
   
   
              // nwritten indicates how many bytes were written this time.
    // 公開鍵認証を行う場合
              nread -= nwritten;
    SSHClient client("<リモートPC側のIPアドレスまたはホスト名>", <リモートPCのポート番号>,
              ptr += nwritten;
                    "<リモートPC側のユーザ名>",
          }
                    "<公開鍵ファイルのパス>",  // クライアントPCに秘密鍵があり、リモートPC側に公開鍵が設置されている場合は空欄 ("") にする
      } while (nread);
                    "<秘密鍵ファイルのパス>",
    } while (!nread); // only continue if nread was drained.
                    "<秘密鍵のパスフレーズ>");
   
   
     File.close();
     client.connectToHost();
   
   
     // 経過時間をミリ秒単位で取得
     return a.exec();
    try {
}
      qint64 duration = elapsedTimer.elapsed() == 0 ? throw DivideByZeroException() : elapsedTimer.elapsed();
</syntaxhighlight>
      qDebug() << QString("%1 bytes in %2 milli-seconds makes %3 bytes/sec").arg(static_cast<long>(total))
<br><br>
                                                                            .arg(duration)
 
                                                                            .arg(QString::number((double)((total * 1000) / duration), 'f', 1));
== SCPコマンドの使用例 ==
libSSHライブラリおよびlibSSH2ライブラリを使用したSCPコマンドの使用例は、以下に示すページに記載している。<br>
* [[Qtの基礎_-_SCP#libSSHライブラリを使用したSCPコマンドの使用例|libSSHライブラリを使用したSCPコマンドの使用例]]
* [[Qtの基礎_-_SCP#libSSH2ライブラリを使用したSCPコマンドの使用例|libSSH2ライブラリを使用したSCPコマンドの使用例]]
<br><br>
 
== sshdコマンドの使用 ==
==== OpenSSHのソースコードのダウンロード ====
[https://www.openssh.com/portable.html OpenSSHの公式Webサイト]にアクセスして、ソースコードをダウンロードする。<br>
ダウンロードしたファイルを解凍する。<br>
tar xf openssh-<バージョン>.tar.gz
<br>
このディレクトリ内に必要なヘッダファイル等が存在する。<br>
<br>
なお、OpenSSHのライセンスの全てのコンポーネントは、BSDライセンス、もしくはそれよりも自由なライセンスに属している。<br>
<br>
==== sshd -tコマンド ====
以下の例では、openSSHライブラリを使用して、<code>sshd -t</code>コマンドと同様、指定された設定ファイルの解析と妥当性を確認している。<br>
<br>
# <code>initialize_server_options</code>関数を呼び出して、サーバオプションを初期化する。
# コマンドライン引数からSSHの設定ファイルのパスを取得する。<br>引数が指定されていない場合は、デフォルトの"sshd_config"ファイルを使用する。
# <code>parse_server_config_depth</code>関数を呼び出して、指定されたSSHの設定ファイルを解析する。<br>解析に成功した場合は<code>0</code>、失敗した場合は<code>0以外</code>の値を返す。
# <code>validate_server_config</code>関数を呼び出して、解析された設定ファイルの妥当性を確認する。<br>確認に成功した場合は<code>0</code>、失敗した場合は<code>0以外</code>の値を返す。
# SSHの設定ファイルの解析と妥当性の結果に応じて、成功または失敗のメッセージを表示している。
<br>
<syntaxhighlight lang="c++">
#include <QCoreApplication>
#include <QDebug>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <sshbuf.h>
#include <sshkey.h>
#include <authfile.h>
#include <auth-options.h>
#include <servconf.h>
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    ServerOptions options;
    initialize_server_options(&options);
    // コマンドライン引数からSSHの設定ファイルのパスを取得
    QString configFile = "sshd_config";
    if (a.arguments().size() > 1) {
      configFile = a.arguments().at(1);
     }
     }
     catch (const DivideByZeroException &ex) {
      qDebug() << ex.what();
    // SSHの設定ファイルの解析
       qDebug() << QString("Transfer rate could not be calculated.");
     if (parse_server_config_depth(&options, configFile.toUtf8().constData(), NULL, 0) != 0) {
       qDebug() << QString("SSHの設定ファイルのパースに失敗: %1).arg(configFile);
      return -1;
     }
     }
   
   
     qDebug() << QString("Sending EOF");
     // SSHの設定ファイルの妥当性を確認
     while(libssh2_channel_send_eof(channel) == LIBSSH2_ERROR_EAGAIN);
     if (validate_server_config(&options) != 0) {
      qDebug() << QString("SSHの設定ファイルに誤りがあります: %1").arg(configFile);
    qDebug() << QString("Waiting for EOF");
      return -1;
     while(libssh2_channel_wait_eof(channel) == LIBSSH2_ERROR_EAGAIN);
     }
   
   
     qDebug() << QString("Waiting for channel to close");
     qDebug() << QString("SSHの設定ファイル (%1) は正常です).arg(configFile);
    while(libssh2_channel_wait_closed(channel) == LIBSSH2_ERROR_EAGAIN);
   
   
     return 0;
     return 0;
  }
  }
</syntaxhighlight>
<br>
==== sshd -Tコマンド ====
以下の例では、openSSHライブラリを使用して、<code>sshd -T</code>コマンドと同様、現在の設定オプションの値をダンプ形式で表示している。<br>
<br>
# <code>initialize_server_options</code>関数を呼び出して、サーバオプションを初期化する。
# <code>fill_default_server_options</code>関数を呼び出して、デフォルトのサーバオプションを設定する。
# <code>parse_server_config_depth</code>関数を呼び出して、sshd_configファイルを解析する。<br>解析に成功した場合は<code>0</code>、失敗した場合は<code>0以外</code>の値を返す。
# 解析に成功した場合は、<code>dump_config</code>関数を呼び出して、設定オプションのダンプを表示する。<br>これは、<code>sshd -T</code>コマンドと同様、現在の設定オプションの値を表示する。
<br>
<syntaxhighlight lang="c++">
#include <QCoreApplication>
#include <QDebug>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <sshbuf.h>
#include <sshkey.h>
#include <authfile.h>
#include <auth-options.h>
#include <servconf.h>
   
   
  int waitsocket(libssh2_socket_t socket_fd, LIBSSH2_SESSION *session)
  int main(int argc, char *argv[])
  {
  {
     struct timeval timeout = {};
     QCoreApplication a(argc, argv);
    timeout.tv_sec  = 10;
    timeout.tv_usec = 0;
   
   
     fd_set fd;
     // SSHの設定ファイルオプション
     FD_ZERO(&fd);
     ServerOptions options;
    FD_SET(socket_fd, &fd);
   
   
     // now make sure we wait in the correct direction.
     initialize_server_options(&options);
     auto dir = libssh2_session_block_directions(session);
     fill_default_server_options(&options);
   
   
    fd_set *writefd = nullptr;
     if (parse_server_config_depth(&options, "sshd_config", NULL, 0) != 0) {
    fd_set *readfd  = nullptr;
      qDebug() << "sshd_configファイルのパースに失敗";
     if(dir & LIBSSH2_SESSION_BLOCK_INBOUND)     readfd  = &fd;
      return -1;
    if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)   writefd = &fd;
    }
   
   
     auto rc = select((int)(socket_fd + 1), readfd, writefd, nullptr, &timeout);
     qDebug() << "========= Dump of configuration options =========";
    dump_config(&options);
    qDebug() << "================================================";
   
   
     return rc;
     return 0;
  }
  }
  </syntaxhighlight>
  </syntaxhighlight>
<br><br>
<br><br>


{{#seo:
|title={{PAGENAME}} : Exploring Electronics and SUSE Linux | MochiuWiki
|keywords=MochiuWiki,Mochiu,Wiki,Mochiu Wiki,Electric Circuit,Electric,pcb,Mathematics,AVR,TI,STMicro,AVR,ATmega,MSP430,STM,Arduino,Xilinx,FPGA,Verilog,HDL,PinePhone,Pine Phone,Raspberry,Raspberry Pi,C,C++,C#,Qt,Qml,MFC,Shell,Bash,Zsh,Fish,SUSE,SLE,Suse Enterprise,Suse Linux,openSUSE,open SUSE,Leap,Linux,uCLnux,Podman,電気回路,電子回路,基板,プリント基板
|description={{PAGENAME}} - 電子回路とSUSE Linuxに関する情報 | This page is {{PAGENAME}} in our wiki about electronic circuits and SUSE Linux
|image=/resources/assets/MochiuLogo_Single_Blue.png
}}


__FORCETOC__
__FORCETOC__
[[カテゴリ:Qt]]
[[カテゴリ:Qt]]
「http://mochiuwiki.e2.valueserver.jp/index.php?title=Qtの基礎_-_SSH」から取得