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

 /*  -*- 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 "k3streamsocket.h"
 
 #include <config-network.h>
 
 #include <QSocketNotifier>
 #include <QDateTime>
 #include <QTimer>
 #include <QElapsedTimer>
 #include <QPointer>
 
 #include "k3socketaddress.h"
 #include "k3resolver.h"
 #include "k3socketdevice.h"
 
 using namespace KNetwork;
 
 class KNetwork::KStreamSocketPrivate
 {
 public:
     KResolverResults::ConstIterator local, peer;
     QElapsedTimer startTime;
     QTimer timer;
 
     int timeout;
 
     inline KStreamSocketPrivate()
         : timeout(0)
     { }
 };
 
 KStreamSocket::KStreamSocket(const QString &node, const QString &service,
                              QObject *parent)
     : KClientSocketBase(parent), d(new KStreamSocketPrivate)
 {
     peerResolver().setNodeName(node);
     peerResolver().setServiceName(service);
     peerResolver().setFamily(KResolver::KnownFamily);
     localResolver().setFamily(KResolver::KnownFamily);
 
     setSocketOptions(socketOptions() & ~Blocking);
 
     QObject::connect(&d->timer, SIGNAL(timeout()), this, SLOT(timeoutSlot()));
 }
 
 KStreamSocket::~KStreamSocket()
 {
     delete d;
     // KClientSocketBase's destructor closes the socket
 }
 
 int KStreamSocket::timeout() const
 {
     return d->timeout;
 }
 
 int KStreamSocket::remainingTimeout() const
 {
     if (state() != Connecting) {
         return timeout();
     }
     if (timeout() <= 0) {
         return 0;
     }
 
     return timeout() - d->startTime.elapsed();
 }
 
 void KStreamSocket::setTimeout(int msecs)
 {
     d->timeout = msecs;
 
     if (state() == Connecting) {
         d->timer.start(msecs);
     }
 }
 
 bool KStreamSocket::bind(const QString &node, const QString &service)
 {
     if (state() != Idle) {
         return false;
     }
 
     if (!node.isNull()) {
         localResolver().setNodeName(node);
     }
     if (!service.isNull()) {
         localResolver().setServiceName(service);
     }
     return true;
 }
 
 bool KStreamSocket::bind(const KResolverEntry &entry)
 {
     return KClientSocketBase::bind(entry);
 }
 
 bool KStreamSocket::connect(const QString &node, const QString &service,
                             OpenMode mode)
 {
     Q_UNUSED(mode);
     if (state() == Connected) {
         return true;    // already connected
     }
 
     if (state() > Connected) {
         return false;    // can't do much here
     }
 
     if (!node.isNull()) {
         peerResolver().setNodeName(node);
     }
     if (!service.isNull()) {
         peerResolver().setServiceName(service);
     }
 
     if (state() == Connecting && !blocking()) {
         setError(InProgress);
         emit gotError(InProgress);
         return true;      // we're already connecting
     }
 
     if (state() < HostFound) {
         // connection hasn't started yet
         if (!blocking()) {
             QObject::connect(this, SIGNAL(hostFound()), SLOT(hostFoundSlot()));
             return lookup();
         }
 
         // blocking mode
         if (!lookup()) {
             return false;    // lookup failure
         }
     }
 
     /*
      * lookup results are available here
      */
 
     if (timeout() > 0) {
         if (!blocking() && !d->timer.isActive()) {
             d->timer.setSingleShot(true);
             d->timer.start(timeout());
         } else {
             // blocking connection with timeout
             // this must be handled as a special case because it requires a
             // non-blocking socket
 
             d->timer.stop();  // no need for a timer here
 
             socketDevice()->setBlocking(false);
             while (true) {
                 connectionEvent();
                 if (state() < Connecting) {
                     return false;    // error connecting
                 }
                 if (state() == Connected) {
                     return true;    // connected!
                 }
 
                 if (remainingTimeout() <= 0) {
                     // we've timed out
                     timeoutSlot();
                     return false;
                 }
 
                 if (socketDevice()->error() == InProgress) {
                     bool timedout;
                     socketDevice()->poll(remainingTimeout(), &timedout);
                     if (timedout) {
                         timeoutSlot();
                         return false;
                     }
                 }
             }
         }
     }
 
     connectionEvent();
     return error() == NoError;
 }
 
 bool KStreamSocket::connect(const KResolverEntry &entry, OpenMode mode)
 {
     return KClientSocketBase::connect(entry, mode);
 }
 
 void KStreamSocket::hostFoundSlot()
 {
     QObject::disconnect(this, SLOT(hostFoundSlot()));
     if (timeout() > 0) {
         d->timer.setSingleShot(true);
         d->timer.start(timeout());
     }
     QTimer::singleShot(0, this, SLOT(connectionEvent()));
 }
 
 void KStreamSocket::connectionEvent()
 {
     if (state() != HostFound && state() != Connecting) {
         return;    // nothing to do
     }
 
     const KResolverResults &peer = peerResults();
     if (state() == HostFound) {
         d->startTime.start();
 
         setState(Connecting);
         emit stateChanged(Connecting);
         d->peer = peer.begin();
         d->local = localResults().begin(); // just to be on the safe side
     }
 
     while (d->peer != peer.end()) {
         const KResolverEntry &r = *d->peer;
 
         if (socketDevice()->socket() != -1) {
             // we have an existing file descriptor
             // this means that we've got activity in it (connection result)
             if (socketDevice()->connect(r) && socketDevice()->error() == NoError) {
                 // yes, it did connect!
                 connectionSucceeded(r);
                 return;
             } else if (socketDevice()->error() == InProgress)
                 // nope, still in progress
             {
                 return;
             }
 
             // no, the socket failed to connect
             copyError();
             socketDevice()->close();
             ++d->peer;
             continue;
         }
 
         // try to bind
         if (!bindLocallyFor(r)) {
             // could not find a matching family
             ++d->peer;
             continue;
         }
 
         {
             bool skip = false;
             emit aboutToConnect(r, skip);
             if (skip) {
                 ++d->peer;
                 continue;
             }
         }
 
         if (socketDevice()->connect(r) || socketDevice()->error() == InProgress) {
             // socket is attempting to connect
             if (socketDevice()->error() == InProgress) {
                 QSocketNotifier *n = socketDevice()->readNotifier();
                 QObject::connect(n, SIGNAL(activated(int)),
                                  this, SLOT(connectionEvent()));
                 n->setEnabled(true);
 
                 n = socketDevice()->writeNotifier();
                 QObject::connect(n, SIGNAL(activated(int)),
                                  this, SLOT(connectionEvent()));
                 n->setEnabled(true);
 
                 return;       // wait for activity
             }
 
             // socket has connected
             connectionSucceeded(r);
             return;
         }
 
         // connection failed
         // try next
         copyError();
         socketDevice()->close();
         ++d->peer;
     }
 
     // that was the last item
     socketDevice()->setSocketOptions(socketOptions());
     setState(Idle);
     emit stateChanged(Idle);
     emit gotError(error());
     return;
 }
 
 void KStreamSocket::timeoutSlot()
 {
     if (state() != Connecting) {
         return;
     }
 
     // halt the connections
     socketDevice()->close();  // this also kills the notifiers
 
     setError(Timeout);
     setState(HostFound);
     emit stateChanged(HostFound);
 
     QPointer<KStreamSocket> that = this;
     emit gotError(Timeout);
 
     if (!that.isNull()) {
         emit timedOut();
     }
 }
 
 bool KStreamSocket::bindLocallyFor(const KResolverEntry &peer)
 {
     const KResolverResults &local = localResults();
 
     if (local.isEmpty())
         // user doesn't want to bind to any specific local address
     {
         return true;
     }
 
     bool foundone = false;
     // scan the local resolution for a matching family
     for (d->local = local.begin(); d->local != local.end(); ++d->local)
         if ((*d->local).family() == peer.family()) {
             // found a suitable address!
             foundone = true;
 
             if (socketDevice()->bind(*d->local)) {
                 return true;
             }
         }
 
     if (!foundone) {
         // found nothing
         setError(NotSupported);
         emit gotError(NotSupported);
     } else {
         copyError();
     }
     return false;
 }
 
 void KStreamSocket::connectionSucceeded(const KResolverEntry &peer)
 {
     QObject::disconnect(socketDevice()->readNotifier(), nullptr, this, SLOT(connectionEvent()));
     QObject::disconnect(socketDevice()->writeNotifier(), nullptr, this, SLOT(connectionEvent()));
 
     resetError();
     KActiveSocketBase::open(ReadWrite | Unbuffered);
     setState(Connected);
     socketDevice()->setSocketOptions(socketOptions());
     d->timer.stop();
     emit stateChanged(Connected);
 
     if (!localResults().isEmpty()) {
         emit bound(*d->local);
     }
     emit connected(peer);
 }
 
 #include "moc_k3streamsocket.cpp"