File indexing completed on 2023-09-24 04:04:39

 /*  -*- C++ -*-
  *  Copyright (C) 2003 Thiago Macieira <thiago@kde.org>
  *
  *
  *  Permission is hereby granted, free of charge, to any person obtaining
  *  a copy of this software and associated documentation files (the
  *  "Software"), to deal in the Software without restriction, including
  *  without limitation the rights to use, copy, modify, merge, publish,
  *  distribute, sublicense, and/or sell copies of the Software, and to
  *  permit persons to whom the Software is furnished to do so, subject to
  *  the following conditions:
  *
  *  The above copyright notice and this permission notice shall be included
  *  in all copies or substantial portions of the Software.
  *
  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
 #include "k3serversocket.h"
 
 #include <config-network.h>
 
 #include <QSocketNotifier>
 #include <QMutex>
 
 #include "k3socketaddress.h"
 #include "k3resolver.h"
 #include "k3socketdevice.h"
 #include "k3bufferedsocket.h"
 
 using namespace KNetwork;
 
 class KNetwork::KServerSocketPrivate
 {
 public:
     KResolver resolver;
     KResolverResults resolverResults;
 
     enum { None, LookupDone, Bound, Listening } state;
     int backlog;
     int timeout;
 
     bool bindWhenFound : 1, listenWhenBound : 1, useKBufferedSocket : 1;
 
     KServerSocketPrivate()
         : state(None), timeout(0), bindWhenFound(false), listenWhenBound(false),
           useKBufferedSocket(true)
     {
         resolver.setFlags(KResolver::Passive);
         resolver.setFamily(KResolver::KnownFamily);
     }
 };
 
 KServerSocket::KServerSocket(QObject *parent)
     : QObject(parent), d(new KServerSocketPrivate)
 {
     QObject::connect(&d->resolver, SIGNAL(finished(KNetwork::KResolverResults)),
                      this, SLOT(lookupFinishedSlot()));
 }
 
 KServerSocket::KServerSocket(const QString &service, QObject *parent)
     : QObject(parent), d(new KServerSocketPrivate)
 {
     QObject::connect(&d->resolver, SIGNAL(finished(KNetwork::KResolverResults)),
                      this, SLOT(lookupFinishedSlot()));
     d->resolver.setServiceName(service);
 }
 
 KServerSocket::KServerSocket(const QString &node, const QString &service,
                              QObject *parent)
     : QObject(parent), d(new KServerSocketPrivate)
 {
     QObject::connect(&d->resolver, SIGNAL(finished(KNetwork::KResolverResults)),
                      this, SLOT(lookupFinishedSlot()));
     setAddress(node, service);
 }
 
 KServerSocket::~KServerSocket()
 {
     close();
     delete d;
 }
 
 bool KServerSocket::setSocketOptions(int opts)
 {
     QMutexLocker locker(mutex());
     KSocketBase::setSocketOptions(opts); // call parent
     bool result = socketDevice()->setSocketOptions(opts); // and set the implementation
     copyError();
     return result;
 }
 
 KResolver &KServerSocket::resolver() const
 {
     return d->resolver;
 }
 
 const KResolverResults &KServerSocket::resolverResults() const
 {
     return d->resolverResults;
 }
 
 void KServerSocket::setResolutionEnabled(bool enable)
 {
     if (enable) {
         d->resolver.setFlags(d->resolver.flags() & ~KResolver::NoResolve);
     } else {
         d->resolver.setFlags(d->resolver.flags() | KResolver::NoResolve);
     }
 }
 
 void KServerSocket::setFamily(int families)
 {
     d->resolver.setFamily(families);
 }
 
 void KServerSocket::setAddress(const QString &service)
 {
     d->resolver.setNodeName(QString());
     d->resolver.setServiceName(service);
     d->resolverResults.clear();
     if (d->state <= KServerSocketPrivate::LookupDone) {
         d->state = KServerSocketPrivate::None;
     }
 }
 
 void KServerSocket::setAddress(const QString &node, const QString &service)
 {
     d->resolver.setNodeName(node);
     d->resolver.setServiceName(service);
     d->resolverResults.clear();
     if (d->state <= KServerSocketPrivate::LookupDone) {
         d->state = KServerSocketPrivate::None;
     }
 }
 
 void KServerSocket::setTimeout(int msec)
 {
     d->timeout = msec;
 }
 
 bool KServerSocket::lookup()
 {
     setError(NoError);
     if (d->resolver.isRunning() && !blocking()) {
         return true;    // already doing lookup
     }
 
     if (d->state >= KServerSocketPrivate::LookupDone) {
         return true;    // results are already available
     }
 
     // make sure we have at least one parameter for lookup
     if (d->resolver.serviceName().isNull() &&
             !d->resolver.nodeName().isNull()) {
         d->resolver.setServiceName(QLatin1String(""));
     }
 
     // don't restart the lookups if they had succeeded and
     // the input values weren't changed
 
     // reset results
     d->resolverResults = KResolverResults();
 
     if (d->resolver.status() <= 0)
         // if it's already running, there's no harm in calling again
     {
         d->resolver.start();    // signal may emit
     }
 
     if (blocking()) {
         // we're in blocking mode operation
         // wait for the results
 
         d->resolver.wait();   // signal may be emitted again
         // lookupFinishedSlot has been called
     }
 
     return true;
 }
 
 bool KServerSocket::bind(const KResolverEntry &address)
 {
     if (socketDevice()->bind(address)) {
         setError(NoError);
 
         d->state = KServerSocketPrivate::Bound;
         emit bound(address);
         return true;
     }
     copyError();
     return false;
 }
 
 bool KServerSocket::bind(const QString &node, const QString &service)
 {
     setAddress(node, service);
     return bind();
 }
 
 bool KServerSocket::bind(const QString &service)
 {
     setAddress(service);
     return bind();
 }
 
 bool KServerSocket::bind()
 {
     if (d->state >= KServerSocketPrivate::Bound) {
         return true;
     }
 
     if (d->state < KServerSocketPrivate::LookupDone) {
         if (!blocking()) {
             d->bindWhenFound = true;
             bool ok = lookup();   // will call doBind
             if (d->state >= KServerSocketPrivate::Bound) {
                 d->bindWhenFound = false;
             }
             return ok;
         }
 
         // not blocking
         if (!lookup()) {
             return false;
         }
     }
 
     return doBind();
 }
 
 bool KServerSocket::listen(int backlog)
 {
     // WARNING
     // this function has to be reentrant
     // due to the mechanisms used for binding, this function might
     // end up calling itself
 
     if (d->state == KServerSocketPrivate::Listening) {
         return true;    // already listening
     }
 
     d->backlog = backlog;
 
     if (d->state < KServerSocketPrivate::Bound) {
         // we must bind
         // note that we can end up calling ourselves here
         d->listenWhenBound = true;
         if (!bind()) {
             d->listenWhenBound = false;
             return false;
         }
 
         if (d->state < KServerSocketPrivate::Bound)
             // asynchronous lookup in progress...
             // we can't be blocking here anyways
         {
             return true;
         }
 
         d->listenWhenBound = false;
     }
 
     if (d->state < KServerSocketPrivate::Listening) {
         return doListen();
     }
 
     return true;
 }
 
 void KServerSocket::close()
 {
     socketDevice()->close();
     if (d->resolver.isRunning()) {
         d->resolver.cancel(false);
     }
     d->state = KServerSocketPrivate::None;
     emit closed();
 }
 
 void KServerSocket::setAcceptBuffered(bool enable)
 {
     d->useKBufferedSocket = enable;
 }
 
 KStreamSocket *KServerSocket::accept()
 {
     if (d->state < KServerSocketPrivate::Listening) {
         if (!blocking()) {
             listen();
             setError(WouldBlock);
             return nullptr;
         } else if (!listen())
             // error happened during listen
         {
             return nullptr;
         }
     }
 
     // check to see if we're doing a timeout
     if (blocking() && d->timeout > 0) {
         bool timedout;
         if (!socketDevice()->poll(d->timeout, &timedout)) {
             copyError();
             return nullptr;
         }
 
         if (timedout) {
             return nullptr;
         }
     }
 
     // we're listening here
     KSocketDevice *accepted = socketDevice()->accept();
     if (!accepted) {
         // error happened during accept
         copyError();
         return nullptr;
     }
 
     KStreamSocket *streamsocket;
     if (d->useKBufferedSocket) {
         streamsocket = new KBufferedSocket();
         streamsocket->setOpenMode(KStreamSocket::ReadWrite);
     } else {
         streamsocket = new KStreamSocket();
         streamsocket->setOpenMode(KStreamSocket::ReadWrite |
                                   KStreamSocket::Unbuffered);
     }
     streamsocket->setSocketDevice(accepted);
 
     // FIXME!
     // when KStreamSocket can find out the state of the socket passed through
     // setSocketDevice, this will probably be unnecessary:
     streamsocket->setState(KStreamSocket::Connected);
 
     return streamsocket;
 }
 
 KSocketAddress KServerSocket::localAddress() const
 {
     return socketDevice()->localAddress();
 }
 
 KSocketAddress KServerSocket::externalAddress() const
 {
     return socketDevice()->externalAddress();
 }
 
 void KServerSocket::lookupFinishedSlot()
 {
     if (d->resolver.isRunning() || d->state > KServerSocketPrivate::LookupDone) {
         return;
     }
 
     if (d->resolver.status() < 0) {
         setError(LookupFailure);
         emit gotError(LookupFailure);
         d->bindWhenFound = d->listenWhenBound = false;
         d->state = KServerSocketPrivate::None;
         return;
     }
 
     // lookup succeeded
     d->resolverResults = d->resolver.results();
     d->state = KServerSocketPrivate::LookupDone;
     emit hostFound();
 
     if (d->bindWhenFound) {
         doBind();
     }
 }
 
 void KServerSocket::copyError()
 {
     setError(socketDevice()->error());
 }
 
 bool KServerSocket::doBind()
 {
     d->bindWhenFound = false;
     // loop through the results and bind to the first that works
 
     KResolverResults::ConstIterator it = d->resolverResults.constBegin();
     for (; it != d->resolverResults.constEnd(); ++it)
         if (bind(*it)) {
             if (d->listenWhenBound) {
                 return doListen();
             }
             return true;
         } else {
             socketDevice()->close();    // didn't work, try again
         }
 
     // failed to bind
     emit gotError(error());
     return false;
 }
 
 bool KServerSocket::doListen()
 {
     if (!socketDevice()->listen(d->backlog)) {
         copyError();
         emit gotError(error());
         return false;     // failed to listen
     }
 
     // set up ready accept signal
     QObject::connect(socketDevice()->readNotifier(), SIGNAL(activated(int)),
                      this, SIGNAL(readyAccept()));
     d->state = KServerSocketPrivate::Listening;
     return true;
 }
 
 #include "moc_k3serversocket.cpp"