summaryrefslogtreecommitdiffstats
path: root/tdecore/network/kresolverworkerbase.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/kresolverworkerbase.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/kresolverworkerbase.h')
-rw-r--r--tdecore/network/kresolverworkerbase.h317
1 files changed, 317 insertions, 0 deletions
diff --git a/tdecore/network/kresolverworkerbase.h b/tdecore/network/kresolverworkerbase.h
new file mode 100644
index 000000000..4dee33239
--- /dev/null
+++ b/tdecore/network/kresolverworkerbase.h
@@ -0,0 +1,317 @@
+/* -*- C++ -*-
+ * Copyright (C) 2003,2004 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.
+ */
+
+#ifndef KRESOLVERWORKERBASE_H
+#define KRESOLVERWORKERBASE_H
+
+#include "kresolver.h"
+
+// forward declarations
+class TQString;
+template <class T> class TQValueList;
+
+namespace KNetwork {
+
+ namespace Internal
+ {
+ class KResolverThread;
+ struct InputData;
+ }
+
+/** @internal
+ * This class is the base functionality for a resolver worker. That is,
+ * the class that does the actual work.
+ *
+ * In the future, this class might be exposed to allow plug-ins. So, try and
+ * make it binary compatible.
+ *
+ * Note that hostnames are still encoded in Unicode at this point. It's up to
+ * the worker class to decide which encoding to use. In the case of DNS,
+ * an ASCII Compatible Encoding (ACE) must be used.
+ * See @ref KResolver::domainToAscii.
+ *
+ * Also specially note that the run method in this class is called in a
+ * thread that is not the program's main thread. So do not do anything there
+ * that you shouldn't!
+ *
+ * @class KResolverWorkerBase kresolverworkerbase.h kresolverworkerbase.h
+ */
+class KResolverWorkerBase
+{
+public:
+
+ /**
+ * Helper class for locking the resolver subsystem.
+ * Similar to TQMutexLocker.
+ *
+ * @author Luís Pedro Coelho
+ * @since 3.4
+ */
+ class ResolverLocker
+ {
+ public:
+ /**
+ * Constructor. Acquires a lock.
+ */
+ ResolverLocker(KResolverWorkerBase* parent)
+ : parent( parent )
+ {
+ parent->acquireResolver();
+ }
+
+ /**
+ * Destructor. Releases the lock.
+ */
+ ~ResolverLocker()
+ {
+ parent->releaseResolver();
+ }
+
+ /**
+ * Releases the lock and then reacquires it.
+ * It may be necessary to call this if the resolving function
+ * decides to retry.
+ */
+ void openClose()
+ {
+ parent->releaseResolver();
+ parent->acquireResolver();
+ }
+
+ private:
+ /// @internal
+ KResolverWorkerBase* parent;
+ };
+private:
+ // this will be like our d pointer
+ KNetwork::Internal::KResolverThread *th;
+ const KNetwork::Internal::InputData *input;
+ friend class KNetwork::Internal::KResolverThread;
+ friend class KNetwork::Internal::KResolverManager;
+ friend class KResolverWorkerBase::ResolverLocker;
+
+ int m_finished : 1;
+ int m_reserved : 31; // reserved
+
+public:
+ /**
+ * Derived classes will put their resolved data in this list, or will
+ * leave it empty in case of error.
+ *
+ * Status and error codes should also be stored in this object (the
+ * @ref setError function does that).
+ */
+ KResolverResults results;
+
+public:
+ // default constructor
+ KResolverWorkerBase();
+
+ // virtual destructor
+ virtual ~KResolverWorkerBase();
+
+ /**
+ * This is the hostname to be looked for
+ */
+ TQString nodeName() const;
+
+ /**
+ * And this is the service name
+ */
+ TQString serviceName() const;
+
+ /**
+ * gets the flags
+ */
+ int flags() const;
+
+ /**
+ * gets the family mask
+ */
+ int familyMask() const;
+
+ /**
+ * gets the socket type
+ */
+ int socketType() const;
+
+ /**
+ * gets the protocol number
+ */
+ int protocol() const;
+
+ /**
+ * gets the protocol name, if applicable
+ */
+ TQCString protocolName() const;
+
+ /**
+ * Call this function to indicate that processing
+ * has finished. This is useful in the preprocessing
+ * stage, to indicate that @ref run doesn't have to be
+ * called.
+ */
+ void finished();
+
+protected:
+ // like a QThread
+ /**
+ * This is the function that should be overriden in derived classes.
+ *
+ * Derived classes will do their blocking job in this function and return
+ * either success or failure to work (not the lookup). That is, whether the
+ * lookup result was a domain found or not, if we got our answer, we should
+ * indicate success. The error itself must be set with @ref setError.
+ *
+ * \b Important: this function gets called in a separate thread!
+ *
+ * @return true on success
+ */
+ virtual bool run() = 0;
+
+ /**
+ * This function gets called during pre processing for this class and you must
+ * override it.
+ *
+ * \b Important: this function gets called in the main event thread. And it MUST
+ * NOT block.
+ *
+ * This function can be used for an object to determine if it will be able
+ * to resolve the given data or not even before launching into a blocking
+ * operation. This function should return true if the object is capable of
+ * handling this kind of data; false otherwise. Note that the return value
+ * of 'true' means that the object's blocking answer will be considered authoritative.
+ *
+ * This function MUST NOT queue further requests. Leave that to @ref run.
+ *
+ * This function is pure virtual; you must override it.
+ *
+ * @return true on success
+ */
+ virtual bool preprocess() = 0;
+
+ /**
+ * This function gets called during post processing for this class.
+ *
+ * \b Important: this function gets called in the main event thread. And it MUST
+ * NOT block.
+ *
+ * @returns true on success
+ */
+ virtual bool postprocess();
+
+ /**
+ * Sets the error
+ */
+ inline void setError(int errorcode, int syserror = 0)
+ { results.setError(errorcode, syserror); }
+
+ /**
+ * Enqueue the given resolver for post-processing.
+ *
+ * Use this function to make the manager call for another resolution.
+ * This is suitable for workers that do post-processing.
+ *
+ * The manager will make sure that any requests enqueued by this function
+ * are done before calling the postprocessing function, which you should
+ * override.
+ *
+ * \b Important: do use KResolver's own enqueueing functions (i.e., @ref KResolver::start).
+ * Instead, use this function.
+ *
+ * @returns true on successful queueing or false if a problem ocurred
+ */
+ bool enqueue(KResolver* other);
+
+ /**
+ * @overload
+ */
+ bool enqueue(KResolverWorkerBase* worker);
+
+ /**
+ * Checks the resolver subsystem status.
+ * @returns true if the resolver subsystem changed, false otherwise.
+ * If this function returns true, it might be necessary to
+ * restart the resolution altogether.
+ * @since 3.4
+ */
+ bool checkResolver();
+
+ /**
+ * This function has to be called from the resolver workers that require
+ * use of the DNS resolver code (i.e., res_* functions, generally in
+ * libresolv). It indicates that the function is starting a resolution
+ * and that the resolver backend shouldn't change asynchronously.
+ *
+ * If any pending res_init's are required, they will be performed before
+ * this function returns.
+ *
+ * @since 3.4
+ */
+ void acquireResolver();
+
+ /**
+ * This function is the counterpart for @ref acquireResolver: the worker
+ * thread indicates that it's done with the resolver.
+ *
+ * @since 3.4
+ */
+ void releaseResolver();
+
+};
+
+/** @internal
+ * This class provides functionality for creating and registering worker classes.
+ *
+ * @class KResolverWorkerFactoryBase kresolverworkerbase.h kresolverworkerbase.h
+ */
+class KResolverWorkerFactoryBase
+{
+public:
+ virtual KResolverWorkerBase* create() const = 0;
+
+ /**
+ * Wrapper call to register workers
+ *
+ * It is NOT thread-safe!
+ */
+ static void registerNewWorker(KResolverWorkerFactoryBase* factory);
+};
+
+/** @internal
+ * This class provides functionality for creating and registering worker classes.
+ *
+ * @class KResolverWorkerFactory kresolverworkerbase.h kresolverworkerbase.h
+ */
+template<class Worker>
+class KResolverWorkerFactory: public KResolverWorkerFactoryBase
+{
+public:
+ virtual KResolverWorkerBase* create() const
+ { return new Worker; }
+};
+
+} // namespace KNetwork
+
+#endif