diff -r 000000000000 -r 1918ee327afb src/network/kernel/qhostinfo.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/network/kernel/qhostinfo.cpp	Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,470 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 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 "qhostinfo.h"
+#include "qhostinfo_p.h"
+
+#include "QtCore/qscopedpointer.h"
+#include <qabstracteventdispatcher.h>
+#include <private/qunicodetables_p.h>
+#include <qcoreapplication.h>
+#include <qmetaobject.h>
+#include <qregexp.h>
+#include <private/qnativesocketengine_p.h>
+#include <qstringlist.h>
+#include <qthread.h>
+#include <qtimer.h>
+#include <qurl.h>
+
+#ifdef Q_OS_UNIX
+#  include <unistd.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+Q_GLOBAL_STATIC(QHostInfoAgent, theAgent)
+void QHostInfoAgent::staticCleanup()
+{
+    theAgent()->cleanup();
+}
+
+//#define QHOSTINFO_DEBUG
+
+/*!
+    \class QHostInfo
+    \brief The QHostInfo class provides static functions for host name lookups.
+
+    \reentrant
+    \inmodule QtNetwork
+    \ingroup network
+
+    QHostInfo uses the lookup mechanisms provided by the operating
+    system to find the IP address(es) associated with a host name,
+    or the host name associated with an IP address.
+    The class provides two static convenience functions: one that
+    works asynchronously and emits a signal once the host is found,
+    and one that blocks and returns a QHostInfo object.
+
+    To look up a host's IP addresses asynchronously, call lookupHost(),
+    which takes the host name or IP address, a receiver object, and a slot
+    signature as arguments and returns an ID. You can abort the
+    lookup by calling abortHostLookup() with the lookup ID.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_network_kernel_qhostinfo.cpp 0
+
+
+    The slot is invoked when the results are ready. (If you use
+    Qt for Embedded Linux and disabled multithreading support by defining
+    \c QT_NO_THREAD, lookupHost() will block until the lookup has
+    finished.) The results are stored in a QHostInfo object. Call
+    addresses() to get the list of IP addresses for the host, and
+    hostName() to get the host name that was looked up.
+
+    If the lookup failed, error() returns the type of error that
+    occurred. errorString() gives a human-readable description of the
+    lookup error.
+
+    If you want a blocking lookup, use the QHostInfo::fromName() function:
+
+    \snippet doc/src/snippets/code/src_network_kernel_qhostinfo.cpp 1
+
+    QHostInfo supports Internationalized Domain Names (IDNs) through the
+    IDNA and Punycode standards.
+
+    To retrieve the name of the local host, use the static
+    QHostInfo::localHostName() function.
+
+    \sa QAbstractSocket, {http://www.rfc-editor.org/rfc/rfc3492.txt}{RFC 3492}
+*/
+
+static QBasicAtomicInt theIdCounter = Q_BASIC_ATOMIC_INITIALIZER(1);
+
+/*!
+    Looks up the IP address(es) associated with host name \a name, and
+    returns an ID for the lookup. When the result of the lookup is
+    ready, the slot or signal \a member in \a receiver is called with
+    a QHostInfo argument. The QHostInfo object can then be inspected
+    to get the results of the lookup.
+
+    The lookup is performed by a single function call, for example:
+
+    \snippet doc/src/snippets/code/src_network_kernel_qhostinfo.cpp 2
+
+    The implementation of the slot prints basic information about the
+    addresses returned by the lookup, or reports an error if it failed:
+
+    \snippet doc/src/snippets/code/src_network_kernel_qhostinfo.cpp 3
+
+    If you pass a literal IP address to \a name instead of a host name,
+    QHostInfo will search for the domain name for the IP (i.e., QHostInfo will
+    perform a \e reverse lookup). On success, the resulting QHostInfo will
+    contain both the resolved domain name and IP addresses for the host
+    name. Example:
+
+    \snippet doc/src/snippets/code/src_network_kernel_qhostinfo.cpp 4
+
+    \sa abortHostLookup(), addresses(), error(), fromName()
+*/
+int QHostInfo::lookupHost(const QString &name, QObject *receiver,
+                          const char *member)
+{
+#if defined QHOSTINFO_DEBUG
+    qDebug("QHostInfo::lookupHost(\"%s\", %p, %s)",
+           name.toLatin1().constData(), receiver, member ? member + 1 : 0);
+#endif
+    if (!QAbstractEventDispatcher::instance(QThread::currentThread())) {
+        qWarning("QHostInfo::lookupHost() called with no event dispatcher");
+        return -1;
+    }
+
+    qRegisterMetaType<QHostInfo>("QHostInfo");
+
+#if defined(Q_OS_WIN32) || defined(Q_OS_WINCE)
+    QWindowsSockInit bust; // makes sure WSAStartup was callled
+#endif
+
+    QScopedPointer<QHostInfoResult> result(new QHostInfoResult);
+    result.data()->autoDelete = false;
+    QObject::connect(result.data(), SIGNAL(resultsReady(QHostInfo)),
+                     receiver, member);
+    int id = result.data()->lookupId = theIdCounter.fetchAndAddRelaxed(1);
+
+    if (name.isEmpty()) {
+        QHostInfo info(id);
+        info.setError(QHostInfo::HostNotFound);
+        info.setErrorString(QObject::tr("No host name given"));
+        QMetaObject::invokeMethod(result.data(), "emitResultsReady", Qt::QueuedConnection,
+                                  Q_ARG(QHostInfo, info));
+        result.take()->autoDelete = true;
+        return id;
+    }
+
+    QHostInfoAgent *agent = theAgent();
+    agent->addHostName(name, result.take());
+
+#if !defined QT_NO_THREAD
+    if (!agent->isRunning())
+        agent->start();
+#else
+//    if (!agent->isRunning())
+	agent->run();
+//    else
+//	agent->wakeOne();
+#endif
+    return id;
+}
+
+/*!
+    Aborts the host lookup with the ID \a id, as returned by lookupHost().
+
+    \sa lookupHost(), lookupId()
+*/
+void QHostInfo::abortHostLookup(int id)
+{
+    QHostInfoAgent *agent = theAgent();
+    agent->abortLookup(id);
+}
+
+/*!
+    Looks up the IP address(es) for the given host \a name. The
+    function blocks during the lookup which means that execution of
+    the program is suspended until the results of the lookup are
+    ready. Returns the result of the lookup in a QHostInfo object.
+
+    If you pass a literal IP address to \a name instead of a host name,
+    QHostInfo will search for the domain name for the IP (i.e., QHostInfo will
+    perform a \e reverse lookup). On success, the returned QHostInfo will
+    contain both the resolved domain name and IP addresses for the host name.
+
+    \sa lookupHost()
+*/
+QHostInfo QHostInfo::fromName(const QString &name)
+{
+#if defined QHOSTINFO_DEBUG
+    qDebug("QHostInfo::fromName(\"%s\")",name.toLatin1().constData());
+#endif
+
+    return QHostInfoAgent::fromName(name);
+}
+
+/*!
+    \internal
+    Pops a query off the queries list, performs a blocking call to
+    QHostInfoAgent::lookupHost(), and emits the resultsReady()
+    signal. This process repeats until the queries list is empty.
+*/
+void QHostInfoAgent::run()
+{
+#ifndef QT_NO_THREAD
+    // Dont' allow thread termination during event delivery, but allow it
+    // during the actual blocking host lookup stage.
+    setTerminationEnabled(false);
+    forever
+#endif
+    {
+        QHostInfoQuery *query;
+        {
+#ifndef QT_NO_THREAD
+            // the queries list is shared between threads. lock all
+            // access to it.
+            QMutexLocker locker(&mutex);
+            if (!quit && queries.isEmpty())
+                cond.wait(&mutex);
+            if (quit) {
+                // Reset the quit variable in case QCoreApplication is
+                // destroyed and recreated.
+                quit = false;
+                break;
+            }
+	    if (queries.isEmpty())
+		continue;
+#else
+	    if (queries.isEmpty())
+		return;
+#endif
+            query = queries.takeFirst();
+            pendingQueryId = query->object->lookupId;
+        }
+
+#if defined(QHOSTINFO_DEBUG)
+        qDebug("QHostInfoAgent::run(%p): looking up \"%s\"", this,
+               query->hostName.toLatin1().constData());
+#endif
+
+#ifndef QT_NO_THREAD
+        // Start query - allow termination at this point, but not outside. We
+        // don't want to all termination during event delivery, but we don't
+        // want the lookup to prevent the app from quitting (the agent
+        // destructor terminates the thread).
+        setTerminationEnabled(true);
+#endif
+        QHostInfo info = fromName(query->hostName);
+#ifndef QT_NO_THREAD
+        setTerminationEnabled(false);
+#endif
+
+        int id = query->object->lookupId;
+        info.setLookupId(id);
+        if (pendingQueryId == id)
+            query->object->emitResultsReady(info);
+        delete query;
+    }
+}
+
+/*!
+    \enum QHostInfo::HostInfoError
+
+    This enum describes the various errors that can occur when trying
+    to resolve a host name.
+
+    \value NoError The lookup was successful.
+    \value HostNotFound No IP addresses were found for the host.
+    \value UnknownError An unknown error occurred.
+
+    \sa error(), setError()
+*/
+
+/*!
+    Constructs an empty host info object with lookup ID \a id.
+
+    \sa lookupId()
+*/
+QHostInfo::QHostInfo(int id)
+    : d(new QHostInfoPrivate)
+{
+    d->lookupId = id;
+}
+
+/*!
+    Constructs a copy of \a other.
+*/
+QHostInfo::QHostInfo(const QHostInfo &other)
+    : d(new QHostInfoPrivate(*other.d.data()))
+{
+}
+
+/*!
+    Assigns the data of the \a other object to this host info object,
+    and returns a reference to it.
+*/
+QHostInfo &QHostInfo::operator=(const QHostInfo &other)
+{
+    *d.data() = *other.d.data();
+    return *this;
+}
+
+/*!
+    Destroys the host info object.
+*/
+QHostInfo::~QHostInfo()
+{
+}
+
+/*!
+    Returns the list of IP addresses associated with hostName(). This
+    list may be empty.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_network_kernel_qhostinfo.cpp 5
+
+    \sa hostName(), error()
+*/
+QList<QHostAddress> QHostInfo::addresses() const
+{
+    return d->addrs;
+}
+
+/*!
+    Sets the list of addresses in this QHostInfo to \a addresses.
+
+    \sa addresses()
+*/
+void QHostInfo::setAddresses(const QList<QHostAddress> &addresses)
+{
+    d->addrs = addresses;
+}
+
+/*!
+    Returns the name of the host whose IP addresses were looked up.
+
+    \sa localHostName()
+*/
+QString QHostInfo::hostName() const
+{
+    return d->hostName;
+}
+
+/*!
+    Sets the host name of this QHostInfo to \a hostName.
+
+    \sa hostName()
+*/
+void QHostInfo::setHostName(const QString &hostName)
+{
+    d->hostName = hostName;
+}
+
+/*!
+    Returns the type of error that occurred if the host name lookup
+    failed; otherwise returns NoError.
+
+    \sa setError(), errorString()
+*/
+QHostInfo::HostInfoError QHostInfo::error() const
+{
+    return d->err;
+}
+
+/*!
+    Sets the error type of this QHostInfo to \a error.
+
+    \sa error(), errorString()
+*/
+void QHostInfo::setError(HostInfoError error)
+{
+    d->err = error;
+}
+
+/*!
+    Returns the ID of this lookup.
+
+    \sa setLookupId(), abortHostLookup(), hostName()
+*/
+int QHostInfo::lookupId() const
+{
+    return d->lookupId;
+}
+
+/*!
+    Sets the ID of this lookup to \a id.
+
+    \sa lookupId(), lookupHost()
+*/
+void QHostInfo::setLookupId(int id)
+{
+    d->lookupId = id;
+}
+
+/*!
+    If the lookup failed, this function returns a human readable
+    description of the error; otherwise "Unknown error" is returned.
+
+    \sa setErrorString(), error()
+*/
+QString QHostInfo::errorString() const
+{
+    return d->errorStr;
+}
+
+/*!
+    Sets the human readable description of the error that occurred to \a str
+    if the lookup failed.
+
+    \sa errorString(), setError()
+*/
+void QHostInfo::setErrorString(const QString &str)
+{
+    d->errorStr = str;
+}
+
+/*!
+    \fn QString QHostInfo::localHostName()
+
+    Returns the host name of this machine.
+
+    \sa hostName()
+*/
+
+/*!
+    \fn QString QHostInfo::localDomainName()
+
+    Returns the DNS domain of this machine.
+
+    Note: DNS domains are not related to domain names found in
+    Windows networks.
+
+    \sa hostName()
+*/
+
+QT_END_NAMESPACE