QtNet.cpp

/*
 * Copyright (C) 2012 Rajendran Thirupugalsamy
 * See LICENSE for full copyright and license information.
 * See COPYING for distribution information.
 */

#include "QtCommon.h"
#include "GuiTerminalWindow.h"
extern "C" {
#include "ssh.h"
#include "putty.h"
#include "network.h"
}
#include <QHostAddress>
#include <QHostInfo>
#include <QNetworkInterface>

struct SockAddr_tag {
    QHostAddress *qtaddr;
    const char *error;
};

static void sk_tcp_flush(Socket /*s*/) {}

/*
 * Each socket abstraction contains a `void *' private field in
 * which the client can keep state.
 */
static void sk_tcp_set_private_ptr(Socket sock, void *ptr)
{
    Actual_Socket s = (Actual_Socket) sock;
    s->private_ptr = ptr;
}

static void *sk_tcp_get_private_ptr(Socket sock)
{
    Actual_Socket s = (Actual_Socket) sock;
    return s->private_ptr;
}

static const char *sk_tcp_socket_error(Socket sock)
{
    Actual_Socket s = (Actual_Socket) sock;
    return s->error;
}

static int sk_tcp_write (Socket sock, const char *data, int len)
{
    Actual_Socket s = (Actual_Socket) sock;
    int i,j;
    char pr[10000];
    for(i=0, j=0; i<len; i++)
            j+= sprintf(pr+j, "%u ", (unsigned char)data[i]);
    //qDebug()<<"sk_tcp_write"<<len<<pr;
    int ret = s->qtsock->write(data, len);
    noise_ultralight(len);
    if(ret<=0)
        qDebug()<<"tcp_write ret "<<ret;
    return ret;
}

static int sk_tcp_write_oob (Socket sock, const char *data, int len)
{
    Actual_Socket s = (Actual_Socket) sock;
    int ret = s->qtsock->write(data, len);
    qDebug()<<"tcp_write_oob ret "<<ret<<"\n";
    return ret;
}

static void sk_tcp_close (Socket sock)
{
    Actual_Socket s = (Actual_Socket) sock;
    if (s->qtsock)
        s->qtsock->disconnectFromHost();
}

static void sk_tcp_set_frozen (Socket /*sock*/, int /*is_frozen*/)
{
    qDebug()<<"sk_tcp_set_frozen() NOT IMPL\n";
}

static Plug sk_tcp_plug (Socket sock, Plug p)
{
    Actual_Socket s = (Actual_Socket) sock;
    Plug ret = s->plug;
    if (p)
        s->plug = p;
    return ret;
}


Socket sk_new(char *addr, int port, int privport, int oobinline,
              int nodelay, int keepalive, Plug plug)
{
    static const struct socket_function_table fn_table = {
        sk_tcp_plug,
        sk_tcp_close,
        sk_tcp_write,
        sk_tcp_write_oob,
        sk_tcp_flush,
        sk_tcp_set_private_ptr,
        sk_tcp_get_private_ptr,
        sk_tcp_set_frozen,
        sk_tcp_socket_error
    };

    Actual_Socket ret;

    /*
     * Create Socket structure.
     */
    ret = snew(struct Socket_tag);
    ret->fn = &fn_table;
    ret->error = NULL;
    ret->plug = plug;
    bufchain_init(&ret->output_data);
    ret->connected = 0;		       /* to start with */
    ret->writable = 0;		       /* to start with */
    ret->sending_oob = 0;
    ret->frozen = 0;
    ret->frozen_readable = 0;
    ret->localhost_only = 0;	       /* unused, but best init anyway */
    ret->pending_error = 0;
    ret->parent = ret->child = NULL;
    ret->oobinline = oobinline;
    ret->nodelay = nodelay;
    ret->keepalive = keepalive;
    ret->privport = privport;
    ret->port = port;
    //ret->addr = addr;
    //START_STEP(ret->addr, ret->step);
    //ret->s = INVALID_SOCKET;

    /*do {
        err = try_connect(ret);
    } while (err && sk_nextaddr(ret->addr, &ret->step));
    */
    ret->qtsock = new QTcpSocket();
    ret->qtsock->connectToHost(QString(addr), port);

    if(nodelay)
        ret->qtsock->setSocketOption(QAbstractSocket::LowDelayOption, 1);

    return (Socket) ret;
}

int sk_addrtype(SockAddr addr)
{
    const QHostAddress *a = addr->qtaddr;
    switch(a->protocol()) {
    case QAbstractSocket::IPv4Protocol:
        return ADDRTYPE_IPV4;
    case QAbstractSocket::IPv6Protocol:
        return ADDRTYPE_IPV6;
    default:
        return ADDRTYPE_NAME;
    }
}

void sk_addrcopy(SockAddr addr, char *buf)
{
    QHostAddress *a = addr->qtaddr;
    QString str = a->toString();
    QByteArray bstr = str.toUtf8();
    const char* cstr = bstr.constData();
    memcpy(buf, cstr, bstr.length());
}

SockAddr sk_addr_dup(SockAddr addr)
{
    if(!addr) return NULL;
    SockAddr ret = new SockAddr_tag;
    ret->qtaddr = new QHostAddress(*addr->qtaddr);
    ret->error = addr->error;
    return ret;
}

void sk_addr_free(SockAddr addr)
{
    if (!addr)
        return;
    if (addr->qtaddr)
        delete addr->qtaddr;
    addr->qtaddr = NULL;
    addr->error = NULL;
}

SockAddr sk_namelookup(const char *host, char **canonicalname,
               int address_family)
{
     SockAddr ret = new SockAddr_tag;
     ret->error = NULL;
     QHostInfo info = QHostInfo::fromName(host);
     if (info.error() == QHostInfo::NoError) {
         foreach(const QHostAddress &address, info.addresses()) {
             int this_addrtype = address.protocol() == QAbstractSocket::IPv4Protocol ? ADDRTYPE_IPV4 :
                                 address.protocol() == QAbstractSocket::IPv6Protocol ? ADDRTYPE_IPV6 :
                                 ADDRTYPE_UNSPEC;
             if (this_addrtype == address_family) {
                 QHostAddress *a = new QHostAddress(address);
                 QString str = info.hostName();
                 QByteArray bstr = str.toUtf8();
                 const char* cstr = bstr.constData();
                 *canonicalname = snewn(1+strlen(cstr), char);
                 strcpy(*canonicalname, cstr);
                 ret->qtaddr = a;
                 return ret;
             }
         }
     }
     if (info.addresses().size()>0) {
         QHostAddress *a = new QHostAddress(info.addresses().at(0));
         QString str = info.hostName();
         QByteArray bstr = str.toUtf8();
         const char* cstr = bstr.constData();
         *canonicalname = snewn(1+strlen(cstr), char);
         strcpy(*canonicalname, cstr);
         ret->qtaddr = a;
         return ret;
     }
     *canonicalname = snewn(1, char);
     *canonicalname[0] = '\0';
     ret->qtaddr = new QHostAddress();
     ret->error = info.error()==QHostInfo::HostNotFound ? "Host not found" :
                  info.error()==QHostInfo::UnknownError ? "Unknown error" :
                  "No IP address found";
     return ret;
}

SockAddr sk_nonamelookup(const char * /*host*/)
{
    // TODO not supported for now
    SockAddr ret = new SockAddr_tag;
    ret->qtaddr = new QHostAddress();
    ret->error = "Not supported";
    return ret;
}

const char *sk_addr_error(SockAddr addr)
{
    if (!addr) return NULL;
    return addr->error;
}

int sk_hostname_is_local(char *name)
{
    return !strcmp(name, "localhost") ||
       !strcmp(name, "::1") ||
       !strncmp(name, "127.", 4);
}

void sk_getaddr(SockAddr addr, char *buf, int buflen)
{
    QHostAddress *a = addr->qtaddr;
    QString str = a->toString();
    QByteArray bstr = str.toUtf8();
    const char* cstr = bstr.constData();
    if(buflen>bstr.length()) buflen = bstr.length();
    strncpy(buf, cstr, buflen);
    buf[buflen-1] = '\0';
}

int sk_address_is_local(SockAddr addr)
{
    const QHostAddress *a = addr->qtaddr;
    if (*a==QHostAddress::LocalHost || *a==QHostAddress::LocalHostIPv6)
        return 1;
    foreach(const QHostAddress &locaddr, QNetworkInterface::allAddresses()) {
        if (*a==locaddr)
            return 1;
    }
    return 0;
}

Socket sk_new(SockAddr addr, int port, int privport, int oobinline,
          int nodelay, int keepalive, Plug plug)
{
    static const struct socket_function_table fn_table = {
        sk_tcp_plug,
        sk_tcp_close,
        sk_tcp_write,
        sk_tcp_write_oob,
        sk_tcp_flush,
        sk_tcp_set_private_ptr,
        sk_tcp_get_private_ptr,
        sk_tcp_set_frozen,
        sk_tcp_socket_error
    };

    Actual_Socket ret;

    /*
     * Create Socket structure.
     */
    ret = snew(struct Socket_tag);
    ret->fn = &fn_table;
    ret->error = NULL;
    ret->plug = plug;
    bufchain_init(&ret->output_data);
    ret->connected = 0;		       /* to start with */
    ret->writable = 0;		       /* to start with */
    ret->sending_oob = 0;
    ret->frozen = 0;
    ret->frozen_readable = 0;
    ret->localhost_only = 0;	       /* unused, but best init anyway */
    ret->pending_error = 0;
    ret->parent = ret->child = NULL;
    ret->oobinline = oobinline;
    ret->nodelay = nodelay;
    ret->keepalive = keepalive;
    ret->privport = privport;
    ret->port = port;
    ret->addr = addr;
    ret->qtsock = NULL;

    if (!addr || !addr->qtaddr) {
        ret->error = "Cannot create socket";
        goto cu0;
    }

    ret->qtsock = new QTcpSocket();
    ret->qtsock->connectToHost(*addr->qtaddr, port);

    if(nodelay)
        ret->qtsock->setSocketOption(QAbstractSocket::LowDelayOption, 1);

cu0:
    return (Socket) ret;
}

Socket sk_newlistener(char * /*srcaddr*/, int /*port*/, Plug /*plug*/, int /*local_host_only*/,
              int /*orig_address_family*/)
{
    // TODO not implemented
    return NULL;
}

char *get_hostname(void)
{
    static char hostname[512];
    QString str = QHostInfo::localHostName();
    QByteArray bstr = str.toUtf8();
    const char* cstr = bstr.constData();
    memcpy(hostname, cstr, bstr.length());
    return hostname;
}

int net_service_lookup(char * /*service*/)
{
    // TODO not implemented
    return 0;
}

Socket sk_register(void * /*sock*/, Plug /*plug*/)
{
    // TODO not implemented
    return NULL;
}

SockAddr platform_get_x11_unix_address(const char * /*path*/, int /*displaynum*/)
{
    /*
    SockAddr ret = snew(struct SockAddr_tag);
    memset(ret, 0, sizeof(struct SockAddr_tag));
    ret->error = "unix sockets not supported on this platform";
    ret->refcount = 1;
    return ret;
    */
    return NULL;
}

Socket platform_new_connection(SockAddr /*addr*/, char * /*hostname*/,
                   int /*port*/, int /*privport*/,
                   int /*oobinline*/, int /*nodelay*/, int /*keepalive*/,
                   Plug /*plug*/, const Config * /*cfg*/)
{
    // TODO not yet implemented
    return NULL;
}