summaryrefslogtreecommitdiffstats
path: root/tdecore/network/kstreamsocket.h
diff options
context:
space:
mode:
authorTimothy Pearson <kb9vqf@pearsoncomputing.net>2011-11-06 15:56:40 -0600
committerTimothy Pearson <kb9vqf@pearsoncomputing.net>2011-11-06 15:56:40 -0600
commite16866e072f94410321d70daedbcb855ea878cac (patch)
treeee3f52eabde7da1a0e6ca845fb9c2813cf1558cf /tdecore/network/kstreamsocket.h
parenta58c20c1a7593631a1b50213c805507ebc16adaf (diff)
downloadtdelibs-e16866e072f94410321d70daedbcb855ea878cac.tar.gz
tdelibs-e16866e072f94410321d70daedbcb855ea878cac.zip
Actually move the kde files that were renamed in the last commit
Diffstat (limited to 'tdecore/network/kstreamsocket.h')
-rw-r--r--tdecore/network/kstreamsocket.h250
1 files changed, 250 insertions, 0 deletions
diff --git a/tdecore/network/kstreamsocket.h b/tdecore/network/kstreamsocket.h
new file mode 100644
index 000000000..9b58bf23a
--- /dev/null
+++ b/tdecore/network/kstreamsocket.h
@@ -0,0 +1,250 @@
+/* -*- 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.
+ */
+
+#ifndef KSTREAMSOCKET_H
+#define KSTREAMSOCKET_H
+
+#include <tqstring.h>
+
+#include "kclientsocketbase.h"
+
+/** A namespace to store all networking-related (socket) classes. */
+namespace KNetwork {
+
+class KResolverEntry;
+class KResolverResults;
+class KServerSocket;
+class KBufferedSocket;
+
+class KStreamSocketPrivate;
+/** @class KStreamSocket kstreamsocket.h kstreamsocket.h
+ * @brief Simple stream socket
+ *
+ * This class provides functionality to creating unbuffered, stream
+ * sockets. In the case of Internet (IP) sockets, this class creates and
+ * uses TCP/IP sockets.
+ *
+ * Objects of this class start, by default, on non-blocking mode. Call
+ * setBlocking if you wish to change that.
+ *
+ * KStreamSocket objects are thread-safe and can be used in auxiliary
+ * threads (i.e., not the thread in which the Qt event loop runs in).
+ * Note that KBufferedSocket cannot be used reliably in an auxiliary thread.
+ *
+ * Sample usage:
+ * \code
+ * TQByteArray httpGet(const TQString& hostname)
+ * {
+ * KStreamSocket socket(hostname, "http");
+ * if (!socket.connect())
+ * return TQByteArray();
+ * TQByteArray data = socket.readAll();
+ * return data;
+ * }
+ * \endcode
+ *
+ * Here's another sample, showing asynchronous operation:
+ * \code
+ * DataRetriever::DataRetriever(const TQString& hostname, const TQString& port)
+ * : socket(hostname, port)
+ * {
+ * // connect signals to our slots
+ * TQObject::connect(&socket, TQT_SIGNAL(connected(const KResolverEntry&)),
+ * this, TQT_SLOT(slotSocketConnected()));
+ * TQObject::connect(&socket, TQT_SIGNAL(gotError(int)),
+ * this, TQT_SLOT(slotSocketError(int)));
+ * TQObject::connect(&socket, TQT_SIGNAL(readyRead()),
+ * this, TQT_SLOT(slotSocketReadyToRead()));
+ * TQObject::connect(&socket, TQT_SIGNAL(readyWrite()),
+ * this, TQT_SLOT(slotSocketReadyToWrite()));
+ *
+ * // set non-blocking mode in order to work asynchronously
+ * socket.setBlocking(false);
+ *
+ * // turn on signal emission
+ * socket.enableRead(true);
+ * socket.enableWrite(true);
+ *
+ * // start connecting
+ * socket.connect();
+ * }
+ * \endcode
+ *
+ * @see KNetwork::KBufferedSocket, KNetwork::KServerSocket
+ * @author Thiago Macieira <thiago@kde.org>
+ */
+class KDECORE_EXPORT KStreamSocket: public KClientSocketBase
+{
+ Q_OBJECT
+ TQ_OBJECT
+
+public:
+ /**
+ * Default constructor.
+ *
+ * @param node destination host
+ * @param service destination service to connect to
+ * @param parent the parent TQObject object
+ * @param name name for this object
+ */
+ KStreamSocket(const TQString& node = TQString::null, const TQString& service = TQString::null,
+ TQObject* parent = 0L, const char *name = 0L);
+
+ /**
+ * Destructor. This closes the socket.
+ */
+ virtual ~KStreamSocket();
+
+ /**
+ * Retrieves the timeout value (in milliseconds).
+ */
+ int timeout() const;
+
+ /**
+ * Retrieves the remaining timeout time (in milliseconds). This value
+ * equals @ref timeout() if there's no connection in progress.
+ */
+ int remainingTimeout() const;
+
+ /**
+ * Sets the timeout value. Setting this value while a connection attempt
+ * is in progress will reset the timer.
+ *
+ * Please note that the timeout value is valid for the connection attempt
+ * only. No other operations are timed against this value -- including the
+ * name lookup associated.
+ *
+ * @param msecs the timeout value in milliseconds
+ */
+ void setTimeout(int msecs);
+
+ /**
+ * Binds this socket to the given nodename and service,
+ * or use the default ones if none are given. In order to bind to a service
+ * and allow the operating system to choose the interface, set @p node to
+ * TQString::null.
+ *
+ * Reimplemented from KClientSocketBase.
+ *
+ * Upon successful binding, the @ref bound signal will be
+ * emitted. If an error is found, the @ref gotError
+ * signal will be emitted.
+ *
+ * @note Due to the internals of the name lookup and binding
+ * mechanism, some (if not most) implementations of this function
+ * do not actually bind the socket until the connection
+ * is requested (see @ref connect). They only set the values
+ * for future reference.
+ *
+ * This function returns true on success.
+ *
+ * @param node the nodename
+ * @param service the service
+ */
+ virtual bool bind(const TQString& node = TQString::null,
+ const TQString& service = TQString::null);
+
+ /**
+ * Reimplemented from KClientSocketBase. Connect this socket to this
+ * specific address.
+ *
+ * Unlike @ref bind(const TQString&, const TQString&) above, this function
+ * really does bind the socket. No lookup is performed. The @ref bound
+ * signal will be emitted.
+ */
+ virtual bool bind(const KResolverEntry& entry)
+ { return KClientSocketBase::bind(entry); }
+
+ /**
+ * Reimplemented from KClientSocketBase.
+ *
+ * Attempts to connect to the these hostname and service,
+ * or use the default ones if none are given. If a connection attempt
+ * is already in progress, check on its state and set the error status
+ * (NoError, meaning the connection is completed, or InProgress).
+ *
+ * If the blocking mode for this object is on, this function will only
+ * return when all the resolved peer addresses have been tried or when
+ * a connection is established.
+ *
+ * Upon successfully connecting, the @ref connected signal
+ * will be emitted. If an error is found, the @ref gotError
+ * signal will be emitted.
+ *
+ * This function also implements timeout handling.
+ *
+ * @param node the remote node to connect to
+ * @param service the service on the remote node to connect to
+ */
+ virtual bool connect(const TQString& node = TQString::null,
+ const TQString& service = TQString::null);
+
+ /**
+ * Unshadowing from KClientSocketBase.
+ */
+ virtual bool connect(const KResolverEntry& entry);
+
+signals:
+ /**
+ * This signal is emitted when a connection timeout occurs.
+ */
+ void timedOut();
+
+private slots:
+ void hostFoundSlot();
+ void connectionEvent();
+ void timeoutSlot();
+
+private:
+ /**
+ * @internal
+ * If the user requested local bind before connection, bind the socket to one
+ * suitable address and return true. Also sets d->local to the address used.
+ *
+ * Return false in case of error.
+ */
+ bool bindLocallyFor(const KResolverEntry& peer);
+
+ /**
+ * @internal
+ * Finishes the connection process by setting internal values and
+ * emitting the proper signals.
+ *
+ * Note: assumes d->local iterator points to the address that we bound
+ * to.
+ */
+ void connectionSucceeded(const KResolverEntry& peer);
+
+ KStreamSocket(const KStreamSocket&);
+ KStreamSocket& operator=(const KStreamSocket&);
+
+ KStreamSocketPrivate *d;
+
+ friend class KServerSocket;
+ friend class KBufferedSocket;
+};
+
+} // namespace KNetwork
+
+#endif