~ubuntu-branches/debian/experimental/kopete/experimental

#include "irisnetplugin.h"

 

#include "objectsession.h"

#include "netinterface.h"

 

//#define JDNS_DEBUG

        Q_OBJECT

 

public:

        QHostAddress mul_addr4, mul_addr6;

        NetInterfaceManager netman;

        QList<NetInterface*> ifaces;

 

                qDeleteAll(ifaces);

 

                if(uni_net)

                        list += uni_net;

                if(uni_local)

                        list += mul;

 

                // calls shutdown on the list, waits for shutdownFinished, deletes

 

                // get final debug

                jdns_debugReady();

        }

 

        {

                if(!uni_net)

                {

                        uni_net->setDebug(&db, "U");

                        bool ok4 = uni_net->addInterface(QHostAddress::Any);

                        bool ok6 = uni_net->addInterface(QHostAddress::AnyIPv6);

                return uni_net;

        }

 

        {

                if(!uni_local)

                {

                        uni_local->setDebug(&db, "L");

                        bool ok4 = uni_local->addInterface(QHostAddress::Any);

                        bool ok6 = uni_local->addInterface(QHostAddress::AnyIPv6);

                return uni_local;

        }

 

        {

                if(!mul)

                {

                        mul->setDebug(&db, "M");

 

                        connect(&netman, SIGNAL(interfaceAvailable(QString)), SLOT(iface_available(QString)));

        {

        public:

                int id;

                int type;

                bool longLived;

                ObjectSession sess;

                return 0;

        }

 

        {

                for(int n = 0; n < items.count(); ++n)

                {

                        // perform the query

                        Item *i = new Item(this);

                        i->id = idman.reserveId();

                        connect(i->req, SIGNAL(resultsReady()), SLOT(req_resultsReady()));

                        i->type = qType;

                        i->longLived = false;

                                        return i->id;

                                }

 

                                i->longLived = true;

                        }

                        else

                        {

                                i->longLived = false;

                        }

                        connect(i->req, SIGNAL(resultsReady()), SLOT(req_resultsReady()));

private slots:

        void req_resultsReady()

        {

                Item *i = getItemByReq(req);

                Q_ASSERT(i);

 

                }

                else

                {

 

                        error = NameResolver::ErrorGeneric;

                                error = NameResolver::ErrorNoName;

                                error = NameResolver::ErrorTimeout;

                        else // ErrorGeneric or ErrorNoNet

                                error = NameResolver::ErrorGeneric;

 

public:

        QByteArray type, typeAndDomain;

 

                QObject(parent),

                req(_jdns, this)

        {

                AddressFirstCome  = 2

        };

 

        bool haveTxt;

        SrvState srvState;

        QTimer *opTimer;

        bool have4, have6;

        QHostAddress addr4, addr6;

 

                QObject(parent),

                reqtxt(_jdns, this),

                req(_jdns, this),

 

signals:

        void finished();

 

private:

        void cleanup()

                        //   out then we consider the whole job to have

                        //   failed.

                        cleanup();

                }

                else if(srvState == AddressWait)

                {

                        if(!tryDone())

                        {

                                cleanup();

                        }

                }

        }

 

        Type type;

        QByteArray host;

        bool success_;

 

                QObject(parent),

                pub_addr(_jdns, this),

                pub_ptr(_jdns, this)

        bool have6, have4;

        ObjectSession sess;

 

                QObject(parent),

                started(false),

                use6(false),

 

signals:

        void published();

 

private:

        friend class JDnsPublish;

 

        JDnsPublish *jdnsPub;

        bool started;

        QJDns::Record rec;

        bool have;

        bool need_update;

        Q_OBJECT

 

public:

 

        bool have_srv, have_txt, have_ptr;

        bool need_update_txt;

 

        QSet<JDnsPublishExtra*> extraList;

 

                QObject(parent),

                jdns(_jdns),

                pub_srv(_jdns, this),

 

signals:

        void published();

 

private:

        friend class JDnsPublishExtra;

                }

                else

                {