summaryrefslogtreecommitdiffstats
path: root/tdecore/network/kserversocket.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tdecore/network/kserversocket.cpp')
-rw-r--r--tdecore/network/kserversocket.cpp413
1 files changed, 413 insertions, 0 deletions
diff --git a/tdecore/network/kserversocket.cpp b/tdecore/network/kserversocket.cpp
new file mode 100644
index 000000000..bd63d6306
--- /dev/null
+++ b/tdecore/network/kserversocket.cpp
@@ -0,0 +1,413 @@
+/* -*- C++ -*-
+ * Copyright (C) 2003 Thiago Macieira <thiago.macieira@kdemail.net>
+ *
+ *
+ * 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 <config.h>
+
+#include <tqsocketnotifier.h>
+#include <tqmutex.h>
+
+#include "ksocketaddress.h"
+#include "kresolver.h"
+#include "ksocketbase.h"
+#include "ksocketdevice.h"
+#include "kstreamsocket.h"
+#include "kbufferedsocket.h"
+#include "kserversocket.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(TQObject* parent, const char *name)
+ : TQObject(parent, name), d(new KServerSocketPrivate)
+{
+ TQObject::connect(&d->resolver, TQT_SIGNAL(finished(KResolverResults)),
+ this, TQT_SLOT(lookupFinishedSlot()));
+}
+
+KServerSocket::KServerSocket(const TQString& service, TQObject* parent, const char *name)
+ : TQObject(parent, name), d(new KServerSocketPrivate)
+{
+ TQObject::connect(&d->resolver, TQT_SIGNAL(finished(KResolverResults)),
+ this, TQT_SLOT(lookupFinishedSlot()));
+ d->resolver.setServiceName(service);
+}
+
+KServerSocket::KServerSocket(const TQString& node, const TQString& service,
+ TQObject* parent, const char* name)
+ : TQObject(parent, name), d(new KServerSocketPrivate)
+{
+ TQObject::connect(&d->resolver, TQT_SIGNAL(finished(KResolverResults)),
+ this, TQT_SLOT(lookupFinishedSlot()));
+ setAddress(node, service);
+}
+
+KServerSocket::~KServerSocket()
+{
+ close();
+ delete d;
+}
+
+bool KServerSocket::setSocketOptions(int opts)
+{
+ TQMutexLocker 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 TQString& service)
+{
+ d->resolver.setNodeName(TQString::null);
+ d->resolver.setServiceName(service);
+ d->resolverResults.empty();
+ if (d->state <= KServerSocketPrivate::LookupDone)
+ d->state = KServerSocketPrivate::None;
+}
+
+void KServerSocket::setAddress(const TQString& node, const TQString& service)
+{
+ d->resolver.setNodeName(node);
+ d->resolver.setServiceName(service);
+ d->resolverResults.empty();
+ 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(TQString::tqfromLatin1(""));
+
+ // 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 TQString& node, const TQString& service)
+{
+ setAddress(node, service);
+ return bind();
+}
+
+bool KServerSocket::bind(const TQString& 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;
+}
+
+KActiveSocketBase* KServerSocket::accept()
+{
+ if (d->state < KServerSocketPrivate::Listening)
+ {
+ if (!blocking())
+ {
+ listen();
+ setError(WouldBlock);
+ return NULL;
+ }
+ else if (!listen())
+ // error happened during listen
+ return false;
+ }
+
+ // check to see if we're doing a timeout
+ if (blocking() && d->timeout > 0)
+ {
+ bool timedout;
+ if (!socketDevice()->poll(d->timeout, &timedout))
+ {
+ copyError();
+ return NULL;
+ }
+
+ if (timedout)
+ return 0L;
+ }
+
+ // we're listening here
+ KSocketDevice* accepted = socketDevice()->accept();
+ if (!accepted)
+ {
+ // error happened during accept
+ copyError();
+ return NULL;
+ }
+
+ KStreamSocket* streamsocket;
+ if (d->useKBufferedSocket)
+ streamsocket = new KBufferedSocket();
+ else
+ streamsocket = new KStreamSocket();
+ 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);
+ streamsocket->setFlags(IO_Sequential | IO_Raw | IO_ReadWrite | IO_Open | IO_Async);
+
+ 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.begin();
+ for ( ; it != d->resolverResults.end(); ++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
+ TQObject::connect(socketDevice()->readNotifier(), TQT_SIGNAL(activated(int)),
+ this, TQT_SIGNAL(readyAccept()));
+ d->state = KServerSocketPrivate::Listening;
+ return true;
+}
+
+
+#include "kserversocket.moc"