it compiles (but doesn't do anything useful)

src/CMakeLists.txt

@@ -141,6 +141,7 @@ endmacro(GET_BIF_OUTPUT_FILES)
 set(BIF_SRCS
     bro.bif
     logging.bif
+    input.bif
     event.bif
     const.bif
     types.bif
@@ -332,6 +333,9 @@ set(bro_SRCS
     IRC.cc
     List.cc
     Reporter.cc
+    InputMgr.cc
+	InputReader.cc
+	InputReaderAscii.cc
     LogMgr.cc
     LogWriter.cc
     LogWriterAscii.cc

src/Func.cc

@@ -523,11 +523,13 @@ void builtin_error(const char* msg, BroObj* arg)
 
 #include "bro.bif.func_h"
 #include "logging.bif.func_h"
+#include "input.bif.func_h"
 #include "reporter.bif.func_h"
 #include "strings.bif.func_h"
 
 #include "bro.bif.func_def"
 #include "logging.bif.func_def"
+#include "input.bif.func_def"
 #include "reporter.bif.func_def"
 #include "strings.bif.func_def"
 
@@ -542,6 +544,7 @@ void init_builtin_funcs()
 
 #include "bro.bif.func_init"
 #include "logging.bif.func_init"
+#include "input.bif.func_init"
 #include "reporter.bif.func_init"
 #include "strings.bif.func_init"
 

src/InputMgr.cc

@@ -0,0 +1,90 @@
+// See the file "COPYING" in the main distribution directory for copyright.
+
+#include <algorithm>
+
+#include "InputMgr.h"
+#include "Event.h"
+#include "EventHandler.h"
+#include "NetVar.h"
+#include "Net.h"
+
+
+#include "InputReader.h"
+
+#include "InputReaderAscii.h"
+
+
+struct InputReaderDefinition {
+	bro_int_t type; // the type
+	const char *name; // descriptive name for error messages
+	bool (*init)(); // optional one-time inifializing function
+	InputReader* (*factory)();	// factory function for creating instances
+};
+
+InputReaderDefinition input_readers[] = {
+	{ BifEnum::Input::READER_ASCII, "Ascii", 0, InputReaderAscii::Instantiate },
+	
+	// End marker
+	{ BifEnum::Input::READER_DEFAULT, "None", 0, (InputReader* (*)())0 }
+};
+
+InputMgr::InputMgr()
+{
+	DBG_LOG(DBG_LOGGING, "this has to happen");
+}
+
+
+// create a new input reader object to be used at whomevers leisure lateron.
+InputReader* InputMgr::CreateReader(EnumVal* reader, string source) 
+{
+	InputReaderDefinition* ir = input_readers;
+	exit(12);
+		
+	while ( true ) {
+		if ( ir->type == BifEnum::Input::READER_DEFAULT ) 
+		{
+			DBG_LOG(DBG_LOGGING, "unknown reader when creating reader");
+			reporter->Error("unknown reader when creating reader");
+			return 0;
+		}
+
+		if ( ir->type != reader->AsEnum() ) {
+			// no, didn't find the right one...
+			++ir;
+			continue;
+		}
+
+		
+		// call init function of writer if presnt
+		if ( ir->init ) 
+		{
+			if ( (*ir->init)() ) 
+				{
+					//clear it to be not called again
+					ir->init = 0;
+				} else {
+					// ohok. init failed, kill factory for all eternity
+					ir->factory = 0;
+					DBG_LOG(DBG_LOGGING, "failed to init input class %s", ir->name);
+					return 0;
+				}
+				
+		}
+		
+		if ( !ir->factory ) 
+			// no factory?
+			return 0;
+		
+		// all done. break.
+		break;
+	}
+	
+	assert(ir->factory);
+	InputReader* reader_obj = (*ir->factory)();
+	assert(reader_obj);
+	
+	return reader_obj;
+	
+}
+		
+		

src/InputMgr.h

@@ -0,0 +1,24 @@
+// See the file "COPYING" in the main distribution directory for copyright.
+
+#ifndef INPUTMGR_H
+#define INPUTMGR_H
+
+#include "InputReader.h"
+#include "BroString.h"
+
+#include "Val.h"
+#include "EventHandler.h"
+#include "RemoteSerializer.h"
+
+
+class InputMgr {
+public:
+    InputMgr();
+    
+    InputReader* CreateReader(EnumVal* reader, string source);
+};
+
+extern InputMgr* input_mgr;
+
+
+#endif /* INPUTMGR_H */

src/InputReader.cc

@@ -0,0 +1,12 @@
+
+#include "InputReader.h"
+
+InputReader::InputReader()
+{
+    
+}
+
+InputReader::~InputReader() 
+{
+	
+}

src/InputReader.h

@@ -0,0 +1,29 @@
+// See the file "COPYING" in the main distribution directory for copyright.
+// 
+// Same notes about thread safety as in LogWriter.h apply.
+
+
+#ifndef INPUTREADER_H
+#define INPUTREADER_H
+
+class InputReader {
+public:
+    InputReader();
+    virtual ~InputReader();
+    
+protected:
+    // Methods that have to be overwritten by the individual readers
+    
+private:
+    friend class InputMgr;
+    
+    // When an error occurs, this method is called to set a flag marking the 
+    // writer as disabled.
+    
+    bool disabled;
+    
+    bool Disabled() { return disabled; }
+};
+
+
+#endif /* INPUTREADER_H */

src/InputReaderAscii.cc

@@ -0,0 +1,12 @@
+
+#include "InputReaderAscii.h"
+#include "DebugLogger.h"
+
+InputReaderAscii::InputReaderAscii()
+{
+	DBG_LOG(DBG_LOGGING, "input reader initialized");
+}
+
+InputReaderAscii::~InputReaderAscii()
+{
+}

src/InputReaderAscii.h

@@ -0,0 +1,20 @@
+
+#ifndef INPUTREADERASCII_H
+#define INPUTREADERASCII_H
+
+#include "InputReader.h"
+
+class InputReaderAscii : public InputReader {
+public:
+    InputReaderAscii();
+    ~InputReaderAscii();
+    
+    static InputReader* Instantiate() { return new InputReaderAscii; }
+    
+protected:
+    
+private:
+};
+
+
+#endif /* INPUTREADERASCII_H */

src/NetVar.cc

@@ -255,6 +255,7 @@ StringVal* cmd_line_bpf_filter;
 #include "types.bif.netvar_def"
 #include "event.bif.netvar_def"
 #include "logging.bif.netvar_def"
+#include "input.bif.netvar_def"
 #include "reporter.bif.netvar_def"
 
 void init_event_handlers()
@@ -315,6 +316,7 @@ void init_net_var()
 #include "const.bif.netvar_init"
 #include "types.bif.netvar_init"
 #include "logging.bif.netvar_init"
+#include "input.bif.netvar_init"
 #include "reporter.bif.netvar_init"
 
 	conn_id = internal_type("conn_id")->AsRecordType();

src/input.bif

@@ -0,0 +1,16 @@
+# functions and types for the input framework
+
+module Input;
+
+%%{
+#include "InputMgr.h"
+#include "NetVar.h"
+%%}
+
+function Input::__create_reader%(reader: Input::Reader, source: string%) : bool
+	%{
+	exit(5);
+	InputReader *the_reader = input_mgr->CreateReader(reader->AsEnumVal(), source->AsString()->CheckString());
+	return new Val( the_reader != 0, TYPE_BOOL );
+	%}
+	

src/main.cc

@@ -30,6 +30,7 @@ extern "C" void OPENSSL_add_all_algorithms_conf(void);
 #include "File.h"
 #include "Reporter.h"
 #include "LogMgr.h"
+#include "InputMgr.h"
 #include "Net.h"
 #include "NetVar.h"
 #include "Var.h"
@@ -72,6 +73,7 @@ name_list prefixes;
 DNS_Mgr* dns_mgr;
 TimerMgr* timer_mgr;
 LogMgr* log_mgr;
+InputMgr* input_mgr;
 Stmt* stmts;
 EventHandlerPtr net_done = 0;
 RuleMatcher* rule_matcher = 0;
@@ -724,6 +726,8 @@ int main(int argc, char** argv)
 	remote_serializer = new RemoteSerializer();
 	event_registry = new EventRegistry();
 	log_mgr = new LogMgr();
+        
+    input_mgr = new InputMgr();
 
 	if ( events_file )
 		event_player = new EventPlayer(events_file);

src/types.bif

@@ -167,4 +167,11 @@ enum ID %{
 	Unknown,
 %}
 
+module Input;
+
+enum Reader %{
+	READER_DEFAULT,
+	READER_ASCII,
+%}
+
 module GLOBAL;