Threaded logging framework.

This is based on Gilbert's code but I ended up refactoring it quite a
bit. That's why I didn't do a direct merge but started with a new
branch and copied things over to adapt. It looks quite a bit different
now as I tried to generalize things a bit more to also support the
Input Framework.

The larger changes code are:

    - Moved all logging code into subdirectory src/logging/. Code
      here is in namespace "logging".

    - Moved all threading code into subdirectory src/threading/. Code
      here is in namespace "threading".

    - Introduced a central thread manager that tracks threads and is
      in charge of termination and (eventually) statistics.

    - Refactored logging independent threading code into base classes
      BasicThread and MsgThread. The former encapsulates all the
      pthread code with simple start/stop methods and provides a
      single Run() method to override.

      The latter is derived from BasicThread and adds bi-directional
      message passing between main and child threads. The hope is that
      the Input Framework can reuse this part quite directly.

    - A log writer is now split into a general WriterFrontend
      (LogEmissary in Gilbert's code) and a type-specific
      WriterBackend. Specific writers are implemented by deriving from
      the latter. (The plugin interface is almost unchanged compared
      to the 2.0 version.).

      Frontend and backend communicate via MsgThread's message
      passing.

    - MsgThread (and thus WriterBackend) has a Heartbeat() method that
      a thread can override to execute code on a regular basis. It's
      triggered roughly once a second by the main thread.

    - Integration into "the rest of Bro". Threads can send messages to
      the reporter and do debugging output; they are hooked into the
      I/O loop for sending messages back; and there's a new debugging
      stream "threading" that logs, well, threading activity.

This all seems to work for the most part, but it's not done yet.

TODO list:

    - Not all tests pass yet. In particular, diffs for the external
      tests seem to indicate some memory problem (no crashes, just an
      occasional weird character).

    - Only tested in --enable-debug mode.

    - Only tested on Linux.

    - Needs leak check.

    - Each log write is currently a single inter-thread message. Bring
      Gilbert's bulk writes back.

    - Code needs further cleanup.

    - Document the class API.

    - Document the internal structure of the logging framework.

    - Check for robustness: live traffic, aborting, signals, etc.

    - Add thread statistics to profile.log (most of the code is there).

    - Customize the OS-visible thread names on platforms that support it.

src/logging/WriterFrontend.h

@@ -0,0 +1,66 @@
+// See the file "COPYING" in the main distribution directory for copyright.
+//
+// Bridge class between main process and writer threads.
+
+#ifndef LOGGING_WRITERFRONTEND_H
+#define LOGGING_WRITERFRONTEND_H
+
+#include "Manager.h"
+
+#include "threading/MsgThread.h"
+
+namespace logging  {
+
+class WriterBackend;
+
+class WriterFrontend {
+public:
+	WriterFrontend(bro_int_t type);
+	virtual ~WriterFrontend();
+
+	// Disables the writers and stop the backend thread.
+	void Stop();
+
+	// Interface methods to interact with the writer from the main thread
+	// (and only from the main thread), typicalli from the log manager.
+	// All these methods forward (via inter-thread messaging) to the
+	// corresponding methods of an internally created WriterBackend. See
+	// there for documentation.
+	//
+	// If any of these operations fails, the writer will be automatically
+	// (but asynchronoulsy) disabled.
+
+	void Init(string path, int num_fields, const Field* const * fields);
+	void Write(int num_fields, Value** vals);
+	void SetBuf(bool enabled);
+	void Flush();
+	void Rotate(string rotated_path, double open, double close, bool terminating);
+	void Finish();
+
+	// Calling this disable the writer. All methods calls will be no-ops
+	// from now on. The Manager will eventually remove disabled writers.
+	void SetDisable()	{ disabled = true; }
+	bool Disabled()	{ return disabled; }
+
+	const string Path() const	{ return path; }
+	int NumFields() const	{ return num_fields; }
+	const Field* const * Fields() const	{ return fields; }
+
+protected:
+	friend class Manager;
+
+
+	WriterBackend* backend;
+	bool disabled;
+	bool initialized;
+
+	string path;
+	int num_fields;
+	const Field* const * fields;
+};
+
+}
+
+
+
+#endif