src/ssh/myssh.cpp

Go to the documentation of this file.

#include "myssh.hpp"

#include <QDebug>

using namespace std;

struct termios terminal;



#ifndef HAVE_CFMAKERAW
static void cfmakeraw(struct termios *termios_p){
    termios_p->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
    termios_p->c_oflag &= ~OPOST;
    termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
    termios_p->c_cflag &= ~(CSIZE|PARENB);
    termios_p->c_cflag |= CS8;
}
#endif

void Myssh::_lock()
{
    while(_isLocked) {}
    _isLocked = true;
}
void Myssh::_unlock()
{
    _isLocked = false;
}

QStringList Myssh::send_cmd(QString s)
{
    QStringList outerr;
    const char * c = (s+"\n").toStdString().c_str();
    char * commande = (char*)malloc(s.length()+2);
    strncpy(commande, c, s.length()+2);
    int res = 0;

    _lock();

    res = channel_write(channel, commande, strlen(commande));
    sleep(1);
    //FIXME: should be: return (res == SSH_SUCCESS);
    outerr.append(_getStdOut());
    outerr.append(_getStdErr());

    _unlock();

    return outerr;
}

QString Myssh::_getStdOut()
{
    QString _out;
    int res;
    char buf[MYSSH_BUFFER_SIZE];

    _out = QString("");

    //FIXME: why do we have to do that???
    channel_request_exec(channel, "");
    buf[MYSSH_BUFFER_SIZE-1] = '\0';
    res = channel_read_nonblocking(channel, buf, MYSSH_BUFFER_SIZE-1, 0);

    while (res > 0)
    {
        buf[res] = '\0';
        _out.append(buf);
        channel_request_exec(channel, "");
        res = channel_read_nonblocking(channel, buf, MYSSH_BUFFER_SIZE-1, 0);
    }
    return _out;
}

QString Myssh::_getStdErr()
{
    QString _err;
    int res;
    char buf[MYSSH_BUFFER_SIZE];

    _err = QString("");

    //FIXME: why do we have to do that???
    channel_request_exec(channel, "");
    buf[MYSSH_BUFFER_SIZE-1] = '\0';
    res = channel_read_nonblocking(channel, buf, MYSSH_BUFFER_SIZE-1, 1);
    while (res > 0)
    {
        buf[res] = '\0';
        _err.append(buf);
        res = channel_read_nonblocking(channel, buf, MYSSH_BUFFER_SIZE-1, 1);
    }
    return _err;
}

void Myssh::shell()
{
    struct termios terminal_local;
    int interactive=isatty(0);

    channel = channel_new(session);
    
    if(interactive){
        tcgetattr(0,&terminal_local);
        memcpy(&terminal,&terminal_local,sizeof(struct termios));
    }
    if(channel_open_session(channel)){
        _errmsg = QString("Error opening channel: ")+ssh_get_error(session);
        return;
    }
  
    if(interactive)
        channel_request_pty(channel);
       
    if(channel_request_shell(channel)){
        _errmsg = QString("Requesting shell: ")+ssh_get_error(session);
        return;
    }
    if(interactive){
        cfmakeraw(&terminal_local);
        tcsetattr(0,TCSANOW,&terminal_local);
    }
}


int Myssh::auth_kbdint(){
    int err=ssh_userauth_kbdint(session,NULL,NULL);
    char *name,*instruction,*prompt,*ptr;
    char buffer[128];
    int i,n;
    char echo;
    while (err==SSH_AUTH_INFO){
        name=ssh_userauth_kbdint_getname(session);
        instruction=ssh_userauth_kbdint_getinstruction(session);
        n=ssh_userauth_kbdint_getnprompts(session);
        if(strlen(name)>0)
            printf("%s\n",name);
        if(strlen(instruction)>0)
            printf("%s\n",instruction);
        for(i=0;i<n;++i)
        {
            prompt=ssh_userauth_kbdint_getprompt(session,i,&echo);
            if(echo)
            {
                printf("%s",prompt);
                fgets(buffer,sizeof(buffer),stdin);
                buffer[sizeof(buffer)-1]=0;
                if((ptr=strchr(buffer,'\n')))
                    *ptr=0;
                ssh_userauth_kbdint_setanswer(session,i,buffer);
                memset(buffer,0,strlen(buffer));
            } else {
                ptr=getpass(prompt);
                ssh_userauth_kbdint_setanswer(session,i,ptr);
            }
        }
        err=ssh_userauth_kbdint(session,NULL,NULL);
   }
   return err;
}

void Myssh::disconnect_ssh()
{
    ssh_disconnect(session);
    connected = false;
}

int Myssh::connect_ssh(char * login,char * passwd,char * host)
{

    int auth=0;
    char *banner;
    connected=false;

    _lock();

    options=ssh_options_new();

    ssh_options_set_username(options,login);
    ssh_options_set_host(options,host);

    session=ssh_new();
    ssh_set_options(session,options);
    if(ssh_connect(session)){
        _errmsg = QString("Connection failed: ")+ ssh_get_error(session);
        ssh_disconnect(session);
        ssh_finalize();
        _unlock();
        return 1;
    }

    /* no ? you should :) */
    auth=ssh_userauth_autopubkey(session);
    qDebug() << "auth = " << auth;
    if(auth==SSH_AUTH_ERROR){
        _errmsg = QString("Authenticating with pubkey: ")+ssh_get_error(session);
        ssh_finalize();
        _unlock();
        return -1;
    }

    banner=ssh_get_issue_banner(session);
    if(banner){
        printf("%s\n",banner);
        free(banner);
    }

    if(auth!=SSH_AUTH_SUCCESS){
        auth=auth_kbdint();
        if(auth==SSH_AUTH_ERROR){
            _errmsg = QString("authenticating with keyb-interactive: ")+ssh_get_error(session);
            ssh_finalize();
            _unlock();
            return -1;
        }
    }

    if(auth!=SSH_AUTH_SUCCESS){
        if(ssh_userauth_password(session,NULL,passwd) != SSH_AUTH_SUCCESS){
            _errmsg = QString("Authentication failed: ")+ssh_get_error(session);
            ssh_disconnect(session);
            ssh_finalize();
            _unlock();
            return -1;
        } else {
            connected = true;
        }
    }

    shell();

    _unlock();

    return 0;
}

---