/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtNetwork module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qsocks5socketengine_p.h"

#ifndef QT_NO_SOCKS5

#include "qtcpsocket.h"

#include "qudpsocket.h"

#include "qtcpserver.h"

#include "qdebug.h"

#include "qhash.h"

#include "qqueue.h"

#include "qdatetime.h"

#include "qmutex.h"

#include "qthread.h"

#include "qcoreapplication.h"

#include "qurl.h"

#include "qauthenticator.h"

#include <qendian.h>

QT_BEGIN_NAMESPACE

#ifdef Q_OS_SYMBIAN

static const int MaxWriteBufferSize = 4*1024;

#else

static const int MaxWriteBufferSize = 128*1024;

#endif

//#define QSOCKS5SOCKETLAYER_DEBUG

#define MAX_DATA_DUMP 256

#if !defined(Q_OS_WINCE)

#define SOCKS5_BLOCKING_BIND_TIMEOUT 5000

#else

#define SOCKS5_BLOCKING_BIND_TIMEOUT 10000

#endif

#define Q_INIT_CHECK(returnValue) do { \

    if (!d->data) { \

        return returnValue; \

    } } while (0)

#define S5_VERSION_5 0x05

#define S5_CONNECT 0x01

#define S5_BIND 0x02

#define S5_UDP_ASSOCIATE 0x03

#define S5_IP_V4 0x01

#define S5_DOMAINNAME 0x03

#define S5_IP_V6 0x04

#define S5_SUCCESS 0x00

#define S5_R_ERROR_SOCKS_FAILURE 0x01

#define S5_R_ERROR_CON_NOT_ALLOWED 0x02

#define S5_R_ERROR_NET_UNREACH 0x03

#define S5_R_ERROR_HOST_UNREACH 0x04

#define S5_R_ERROR_CONN_REFUSED 0x05

#define S5_R_ERROR_TTL 0x06

#define S5_R_ERROR_CMD_NOT_SUPPORTED 0x07

#define S5_R_ERROR_ADD_TYPE_NOT_SUPORTED 0x08

#define S5_AUTHMETHOD_NONE 0x00

#define S5_AUTHMETHOD_PASSWORD 0x02

#define S5_AUTHMETHOD_NOTACCEPTABLE 0xFF

#define S5_PASSWORDAUTH_VERSION 0x01

#ifdef QSOCKS5SOCKETLAYER_DEBUG

#  define QSOCKS5_Q_DEBUG qDebug() << this

#  define QSOCKS5_D_DEBUG qDebug() << q_ptr

#  define QSOCKS5_DEBUG qDebug() << "[QSocks5]"

static QString s5StateToString(QSocks5SocketEnginePrivate::Socks5State s)

{

    switch (s) {

    case QSocks5SocketEnginePrivate::Uninitialized: return QLatin1String("Uninitialized");

    case QSocks5SocketEnginePrivate::ConnectError: return QLatin1String("ConnectError");

    case QSocks5SocketEnginePrivate::AuthenticationMethodsSent: return QLatin1String("AuthenticationMethodsSent");

    case QSocks5SocketEnginePrivate::Authenticating: return QLatin1String("Authenticating");

    case QSocks5SocketEnginePrivate::AuthenticatingError: return QLatin1String("AuthenticatingError");

    case QSocks5SocketEnginePrivate::RequestMethodSent: return QLatin1String("RequestMethodSent");

    case QSocks5SocketEnginePrivate::RequestError: return QLatin1String("RequestError");

    case QSocks5SocketEnginePrivate::Connected: return QLatin1String("Connected");

    case QSocks5SocketEnginePrivate::UdpAssociateSuccess: return QLatin1String("UdpAssociateSuccess");

    case QSocks5SocketEnginePrivate::BindSuccess: return QLatin1String("BindSuccess");

    case QSocks5SocketEnginePrivate::ControlSocketError: return QLatin1String("ControlSocketError");

    case QSocks5SocketEnginePrivate::SocksError: return QLatin1String("SocksError");

    case QSocks5SocketEnginePrivate::HostNameLookupError: return QLatin1String("HostNameLookupError");

    default: break;

    }

    return QLatin1String("unknown state");

}

static QString dump(const QByteArray &buf)

{

    QString data;

    for (int i = 0; i < qMin<int>(MAX_DATA_DUMP, buf.size()); ++i) {

        if (i) data += QLatin1Char(' ');

        uint val = (unsigned char)buf.at(i);

       // data += QString("0x%1").arg(val, 3, 16, QLatin1Char('0'));

        data += QString::number(val);

    }

    if (buf.size() > MAX_DATA_DUMP)

        data += QLatin1String(" ...");

    return QString::fromLatin1("size: %1 data: { %2 }").arg(buf.size()).arg(data);

}

#else

#  define QSOCKS5_DEBUG if (0) qDebug()

#  define QSOCKS5_Q_DEBUG if (0) qDebug()

#  define QSOCKS5_D_DEBUG if (0) qDebug()

static inline QString s5StateToString(QSocks5SocketEnginePrivate::Socks5State) { return QString(); }

static inline QString dump(const QByteArray &) { return QString(); }

#endif

/*

   inserts the host address in buf at pos and updates pos.

   if the func fails the data in buf and the vallue of pos is undefined

*/

static bool qt_socks5_set_host_address_and_port(const QHostAddress &address, quint16 port, QByteArray *pBuf)

{

    QSOCKS5_DEBUG << "setting [" << address << ':' << port << ']';

    union {

        quint16 port;

        quint32 ipv4;

        QIPv6Address ipv6;

        char ptr;

    } data;

    // add address

    if (address.protocol() == QAbstractSocket::IPv4Protocol) {

        data.ipv4 = qToBigEndian<quint32>(address.toIPv4Address());

        pBuf->append(S5_IP_V4);

        pBuf->append(QByteArray::fromRawData(&data.ptr, sizeof data.ipv4));

    } else if (address.protocol() == QAbstractSocket::IPv6Protocol) {

        data.ipv6 = address.toIPv6Address();

        pBuf->append(S5_IP_V6);

        pBuf->append(QByteArray::fromRawData(&data.ptr, sizeof data.ipv6));

    } else {

        return false;

    }

    // add port

    data.port = qToBigEndian<quint16>(port);

    pBuf->append(QByteArray::fromRawData(&data.ptr, sizeof data.port));

    return true;

}

/*

   like above, but for a hostname

*/

static bool qt_socks5_set_host_name_and_port(const QString &hostname, quint16 port, QByteArray *pBuf)

{

    QSOCKS5_DEBUG << "setting [" << hostname << ':' << port << ']';

    QByteArray encodedHostName = QUrl::toAce(hostname);

    QByteArray &buf = *pBuf;

    if (encodedHostName.length() > 255)

        return false;

    buf.append(S5_DOMAINNAME);

    buf.append(uchar(encodedHostName.length()));

    buf.append(encodedHostName);

    // add port

    union {

        quint16 port;

        char ptr;

    } data;

    data.port = qToBigEndian<quint16>(port);

    buf.append(QByteArray::fromRawData(&data.ptr, sizeof data.port));

    return true;

}

/*

   retrives the host address in buf at pos and updates pos.

   if the func fails the value of the address and the pos is undefined

*/

static bool qt_socks5_get_host_address_and_port(const QByteArray &buf, QHostAddress *pAddress, quint16 *pPort, int *pPos)

{

    bool ret = false;

    int pos = *pPos;

    const unsigned char *pBuf = reinterpret_cast<const unsigned char*>(buf.constData());

    QHostAddress address;

    quint16 port = 0;

    if (buf.size() - pos < 1) {

        QSOCKS5_DEBUG << "need more data address/port";

        return false;

    }

    if (pBuf[pos] == S5_IP_V4) {

        pos++;

        if (buf.size() - pos < 4) {

            QSOCKS5_DEBUG << "need more data for ip4 address";

            return false;

        }

        address.setAddress(qFromBigEndian<quint32>(&pBuf[pos]));

        pos += 4;

        ret = true;

    } else if (pBuf[pos] == S5_IP_V6) {

        pos++;

        if (buf.size() - pos < 16) {

            QSOCKS5_DEBUG << "need more data for ip6 address";

            return false;

        }

        QIPv6Address add;

        for (int i = 0; i < 16; ++i)

            add[i] = buf[pos++];

        ret = true;

    } else if (pBuf[pos] == S5_DOMAINNAME){

        // just skip it

        pos++;

        qDebug() << "skipping hostname of len" << uint(pBuf[pos]);

        pos += uchar(pBuf[pos]);

    } else {

        QSOCKS5_DEBUG << "invalid address type" << (int)pBuf[pos];

        ret = false;

    }

    if (ret) {

        if (buf.size() - pos < 2) {

            QSOCKS5_DEBUG << "need more data for port";

            return false;

        }

        port = qFromBigEndian<quint16>(&pBuf[pos]);

        pos += 2;

    }

    if (ret) {

        QSOCKS5_DEBUG << "got [" << address << ':' << port << ']';

        *pAddress = address;

        *pPort = port;

        *pPos = pos;

    }

    return ret;

}

/*

   Returns the difference between msecs and elapsed. If msecs is -1,

   however, -1 is returned.

*/

static int qt_timeout_value(int msecs, int elapsed)

{

    if (msecs == -1)

        return -1;

    int timeout = msecs - elapsed;

    return timeout < 0 ? 0 : timeout;

}

struct QSocks5Data

{

    QTcpSocket *controlSocket;

    QSocks5Authenticator *authenticator;

};

struct QSocks5ConnectData : public QSocks5Data

{

    QByteArray readBuffer;

};

struct QSocks5BindData : public QSocks5Data

{

    QHostAddress localAddress;

    quint16 localPort;

    QHostAddress peerAddress;

    quint16 peerPort;

    QDateTime timeStamp;

};

struct QSocks5RevivedDatagram

{

    QByteArray data;

    QHostAddress address;

    quint16 port;

};

#ifndef QT_NO_UDPSOCKET

struct QSocks5UdpAssociateData : public QSocks5Data

{

    QUdpSocket *udpSocket;

    QHostAddress associateAddress;

    quint16 associatePort;

    QQueue<QSocks5RevivedDatagram> pendingDatagrams;

};

#endif

// needs to be thread safe

class QSocks5BindStore : public QObject

{

public:

    QSocks5BindStore();

    ~QSocks5BindStore();

    void add(int socketDescriptor, QSocks5BindData *bindData);

    bool contains(int socketDescriptor);

    QSocks5BindData *retrieve(int socketDescriptor);

protected:

    void timerEvent(QTimerEvent * event);

    QMutex mutex;

    int sweepTimerId;

    //socket descriptor, data, timestamp

    QHash<int, QSocks5BindData *> store;

};

Q_GLOBAL_STATIC(QSocks5BindStore, socks5BindStore)

QSocks5BindStore::QSocks5BindStore()

    : mutex(QMutex::Recursive)

    , sweepTimerId(-1)

{

    QCoreApplication *app = QCoreApplication::instance();

    if (app && app->thread() != thread())

        moveToThread(app->thread());

}

QSocks5BindStore::~QSocks5BindStore()

{

}

void QSocks5BindStore::add(int socketDescriptor, QSocks5BindData *bindData)

{

    QMutexLocker lock(&mutex);

    if (store.contains(socketDescriptor)) {

        // qDebug() << "delete it";

    }

    bindData->timeStamp = QDateTime::currentDateTime();

    store.insert(socketDescriptor, bindData);

    // start sweep timer if not started

    if (sweepTimerId == -1)

        sweepTimerId = startTimer(60000);

}

bool QSocks5BindStore::contains(int socketDescriptor)

{

    QMutexLocker lock(&mutex);

    return store.contains(socketDescriptor);

}

QSocks5BindData *QSocks5BindStore::retrieve(int socketDescriptor)

{

    QMutexLocker lock(&mutex);

    if (!store.contains(socketDescriptor))

        return 0;

    QSocks5BindData *bindData = store.take(socketDescriptor);

    if (bindData) {

        if (bindData->controlSocket->thread() != QThread::currentThread()) {

            qWarning("Can not access socks5 bind data from different thread");

            return 0;

        }

    } else {

        QSOCKS5_DEBUG << "__ERROR__ binddata == 0";

    }

    // stop the sweep timer if not needed

    if (store.isEmpty()) {

        killTimer(sweepTimerId);

        sweepTimerId = -1;

    }

    return bindData;

}

void QSocks5BindStore::timerEvent(QTimerEvent * event)

{

    QMutexLocker lock(&mutex);

    if (event->timerId() == sweepTimerId) {

        QSOCKS5_DEBUG << "QSocks5BindStore performing sweep";

        QMutableHashIterator<int, QSocks5BindData *> it(store);

        while (it.hasNext()) {

            it.next();

            if (it.value()->timeStamp.secsTo(QDateTime::currentDateTime()) > 350) {

                QSOCKS5_DEBUG << "QSocks5BindStore removing JJJJ";

                it.remove();

            }

        }

    }

}

QSocks5Authenticator::QSocks5Authenticator()

{

}

QSocks5Authenticator::~QSocks5Authenticator()

{

}

char QSocks5Authenticator::methodId()

{

    return 0x00;

}

bool QSocks5Authenticator::beginAuthenticate(QTcpSocket *socket, bool *completed)

{

    Q_UNUSED(socket);

    *completed = true;

    return true;

}

bool QSocks5Authenticator::continueAuthenticate(QTcpSocket *socket, bool *completed)

{

    Q_UNUSED(socket);

    *completed = true;

    return true;

}

bool QSocks5Authenticator::seal(const QByteArray buf, QByteArray *sealedBuf)

{

    *sealedBuf = buf;

    return true;

}

bool QSocks5Authenticator::unSeal(const QByteArray sealedBuf, QByteArray *buf)

{

    *buf = sealedBuf;

    return true;

}

bool QSocks5Authenticator::unSeal(QTcpSocket *sealedSocket, QByteArray *buf)

{

    return unSeal(sealedSocket->readAll(), buf);

}

QSocks5PasswordAuthenticator::QSocks5PasswordAuthenticator(const QString &userName, const QString &password)

{

    this->userName = userName;

    this->password = password;

}

char QSocks5PasswordAuthenticator::methodId()

{

    return 0x02;

}

bool QSocks5PasswordAuthenticator::beginAuthenticate(QTcpSocket *socket, bool *completed)

{

    *completed = false;

    QByteArray uname = userName.toLatin1();

    QByteArray passwd = password.toLatin1();

    QByteArray dataBuf(3 + uname.size() + passwd.size(), 0);

    char *buf = dataBuf.data();

    int pos = 0;

    buf[pos++] = S5_PASSWORDAUTH_VERSION;

    buf[pos++] = uname.size();

    memcpy(&buf[pos], uname.data(), uname.size());

    pos += uname.size();

    buf[pos++] = passwd.size();

    memcpy(&buf[pos], passwd.data(), passwd.size());

    return socket->write(dataBuf) == dataBuf.size();

}

bool QSocks5PasswordAuthenticator::continueAuthenticate(QTcpSocket *socket, bool *completed)

{

    *completed = false;

    if (socket->bytesAvailable() < 2)

        return true;

    QByteArray buf = socket->read(2);

    if (buf.at(0) == S5_PASSWORDAUTH_VERSION && buf.at(1) == 0x00) {

        *completed = true;

        return true;

    }

    // must disconnect

    socket->close();

    return false;

}

QString QSocks5PasswordAuthenticator::errorString()

{

    return QLatin1String("Socks5 user name or password incorrect");

}

QSocks5SocketEnginePrivate::QSocks5SocketEnginePrivate()

    : socks5State(Uninitialized)

    , readNotificationEnabled(false)

    , writeNotificationEnabled(false)

    , exceptNotificationEnabled(false)

    , socketDescriptor(-1)

    , data(0)

    , connectData(0)

#ifndef QT_NO_UDPSOCKET