diff --git a/scripts/base/frameworks/input/main.bro b/scripts/base/frameworks/input/main.bro
index b5a05af3b6..4bb7129d03 100644
--- a/scripts/base/frameworks/input/main.bro
+++ b/scripts/base/frameworks/input/main.bro
@@ -2,11 +2,14 @@
 module Input;
 
 export {
+	const default_reader = READER_ASCII &redef;
+
 	type ReaderDescription: record {
 		source: string;
 		idx: any;
 		val: any;
 		destination: any;
+		reader: Reader &default=default_reader;
 	};
 }
 
diff --git a/src/InputMgr.cc b/src/InputMgr.cc
index 5c30922863..648a933a22 100644
--- a/src/InputMgr.cc
+++ b/src/InputMgr.cc
@@ -21,6 +21,8 @@ struct InputMgr::ReaderInfo {
 	unsigned int num_val_fields;
 
 	TableVal* tab;
+	RecordType* rtype;
+	RecordType* itype;
 
 	};
 
@@ -45,7 +47,7 @@ InputMgr::InputMgr()
 
 
 // create a new input reader object to be used at whomevers leisure lateron.
-InputReader* InputMgr::CreateReader(EnumVal* reader, RecordVal* description) 
+InputReader* InputMgr::CreateReader(EnumVal* id, RecordVal* description) 
 {
 	InputReaderDefinition* ir = input_readers;
 	
@@ -55,6 +57,8 @@ InputReader* InputMgr::CreateReader(EnumVal* reader, RecordVal* description)
 		reporter->Error("readerDescription argument not of right type");
 		return 0;
 	}
+
+	EnumVal* reader = description->Lookup(rtype->FieldOffset("reader"))->AsEnumVal();
 	
 	while ( true ) {
 		if ( ir->type == BifEnum::Input::READER_DEFAULT ) 
@@ -106,38 +110,191 @@ InputReader* InputMgr::CreateReader(EnumVal* reader, RecordVal* description)
 	RecordType *val = description->Lookup(rtype->FieldOffset("val"))->AsType()->AsTypeType()->Type()->AsRecordType();
 	TableVal *dst = description->Lookup(rtype->FieldOffset("destination"))->AsTableVal();
 
-	LogField** fields = new LogField*[idx->NumFields() + val->NumFields()];
-	for ( int i = 0; i < idx->NumFields(); i++ ) 
-	{
-		// FIXME: do type checking...
-		LogField* field = new LogField();
-		field->name = idx->FieldName(i);
-		field->type = idx->FieldType(i)->Tag();
-		fields[i] = field;
+
+	vector<LogField*> fieldsV; // vector, because we don't know the length beforehands
+	
+
+	bool status = !UnrollRecordType(&fieldsV, idx, "");
+
+	int idxfields = fieldsV.size();
+	
+	status = status || !UnrollRecordType(&fieldsV, val, "");
+	int valfields = fieldsV.size() - idxfields;
+
+	if ( status ) {
+		reporter->Error("Problem unrolling");
+		return 0;
 	}
-	for ( int i = 0; i < val->NumFields(); i++ ) 
-	{
-		// FIXME: do type checking...
-		LogField* field = new LogField();
-		field->name = val->FieldName(i);
-		field->type = val->FieldType(i)->Tag();
-		fields[idx->NumFields() + i] = field;
+	
+	
+	LogField** fields = new LogField*[fieldsV.size()];
+	for ( unsigned int i = 0; i < fieldsV.size(); i++ ) {
+		fields[i] = fieldsV[i];
 	}
 
 	ReaderInfo* info = new ReaderInfo;
 	info->reader = reader_obj;
 	info->type = reader;
-	info->num_idx_fields = idx->NumFields();
-	info->num_val_fields = val->NumFields();
+	Ref(reader);
+	info->num_idx_fields = idxfields;
+	info->num_val_fields = valfields;
 	info->tab = dst;
+	Ref(dst);
+	info->rtype = val;
+	Ref(val); // we save a pointer of it... I really hope that this wasn't already done anywhere.
+	info->id = id;
+	Ref(id); // ditto...
+	info->itype = idx;
+	Ref(idx);
 	readers.push_back(info);
 
 
-	reader_obj->Init(source, idx->NumFields() + val->NumFields(), fields);
+	reader_obj->Init(source, fieldsV.size(), fields);
 	reader_obj->Update();
 	
 	return reader_obj;
 	
+}
+bool InputMgr::IsCompatibleType(BroType* t)
+	{
+	if ( ! t )
+		return false;
+
+	switch ( t->Tag() )	{
+	case TYPE_BOOL:
+	case TYPE_INT:
+	case TYPE_COUNT:
+	case TYPE_COUNTER:
+	case TYPE_PORT:
+	case TYPE_SUBNET:
+	case TYPE_ADDR:
+	case TYPE_DOUBLE:
+	case TYPE_TIME:
+	case TYPE_INTERVAL:
+	case TYPE_ENUM:
+	case TYPE_STRING:
+	case TYPE_RECORD:
+		// for record: check, if all elements are compatible? But... LogMgr also doesn't do this.
+		// ^ recursive checking is done in UnrollRecordType.
+		return true;
+	
+	case TYPE_FILE:
+	case TYPE_FUNC:
+		return false;
+
+
+	case TYPE_TABLE:
+		return false;
+
+	case TYPE_VECTOR:
+		{
+		return IsCompatibleType(t->AsVectorType()->YieldType());
+		}
+
+	default:
+		return false;
+	}
+
+	return false;
+	}
+
+
+bool InputMgr::RemoveReader(EnumVal* id) {
+	ReaderInfo *i = 0;
+	for ( vector<ReaderInfo *>::iterator s = readers.begin(); s != readers.end(); ++s )
+		{
+		if ( (*s)->id == id ) 
+		{
+			i = (*s);
+			readers.erase(s); // remove from vector
+			break;	
+		}
+		}
+
+	if ( i == 0 ) {
+		return false; // not found
+	}
+
+	Unref(i->type);
+	Unref(i->tab);
+	Unref(i->itype);
+	Unref(i->rtype);
+	Unref(i->id);
+
+	delete(i->reader);
+	delete(i);
+
+	return true;
+}
+
+bool InputMgr::UnrollRecordType(vector<LogField*> *fields, const RecordType *rec, const string& nameprepend) {
+	for ( int i = 0; i < rec->NumFields(); i++ ) 
+	{
+
+		if ( !IsCompatibleType(rec->FieldType(i)) ) {
+			reporter->Error("Incompatible type \"%s\" in table definition for InputReader", type_name(rec->FieldType(i)->Tag()));
+			return false;
+		}
+
+		if ( rec->FieldType(i)->Tag() == TYPE_RECORD ) 
+		{
+			
+			string prep = nameprepend + rec->FieldName(i) + ".";
+			
+			if ( !UnrollRecordType(fields, rec->FieldType(i)->AsRecordType(), prep) ) 
+			{
+				return false;
+			}
+
+		} else {
+			LogField* field = new LogField();
+			field->name = nameprepend + rec->FieldName(i);
+			field->type = rec->FieldType(i)->Tag();	
+
+			fields->push_back(field);
+		}
+	}
+
+	return true;
+	
+}
+
+bool InputMgr::ForceUpdate(EnumVal* id)
+{
+	ReaderInfo *i = FindReader(id);
+	if ( i == 0 ) {
+		reporter->Error("Reader not found");
+		return false;
+	}
+
+	i->reader->Update();
+	return true;
+}
+
+Val* InputMgr::LogValToIndexVal(int num_fields, const RecordType *type, const LogVal* const *vals) {
+	Val* idxval;
+	int position = 0;
+
+
+	if ( num_fields == 1 ) {
+		idxval = LogValToVal(vals[0]);
+	} else {
+		ListVal *l = new ListVal(TYPE_ANY);
+		for ( int j = 0 ; j < type->NumFields(); j++ ) {
+			if ( type->FieldType(j)->Tag() == TYPE_RECORD ) {
+				l->Append(LogValToRecordVal(vals, type->FieldType(j)->AsRecordType(), &position));
+			} else {
+				l->Append(LogValToVal(vals[position], type->FieldType(j)->Tag()));
+				position++;
+			}
+		}
+		idxval = l;
+	}
+
+	assert ( position == num_fields );
+
+	return idxval;
+
 }
 
 void InputMgr::Put(const InputReader* reader, const LogVal* const *vals) {
@@ -147,10 +304,65 @@ void InputMgr::Put(const InputReader* reader, const LogVal* const *vals) {
 		return;
 	}
 
-	i->tab->Assign(LogValToVal(vals[0]), LogValToVal(vals[1]));
-	reporter->Error("assigned");
+	Val* idxval = LogValToIndexVal(i->num_idx_fields, i->itype, vals);
+	Val* valval;
+	
+	int position = i->num_idx_fields;
+	if ( i->num_val_fields == 1 ) {
+		valval = LogValToVal(vals[i->num_idx_fields]);
+	} else {
+		RecordVal * r = new RecordVal(i->rtype);
+
+		/* if ( i->rtype->NumFields() != (int) i->num_val_fields ) {
+			reporter->InternalError("Type mismatch");
+			return;
+		} */
+
+		for ( int j = 0; j < i->rtype->NumFields(); j++) {
+
+			Val* val = 0;
+			if ( i->rtype->FieldType(j)->Tag() == TYPE_RECORD ) {
+				val = LogValToRecordVal(vals, i->rtype->FieldType(j)->AsRecordType(), &position);
+			} else {
+				val =  LogValToVal(vals[position], i->rtype->FieldType(j)->Tag());
+				position++;
+			}
+			
+			if ( val == 0 ) {
+				reporter->InternalError("conversion error");
+				return;
+			}
+
+			r->Assign(j,val);
+
+		}
+		valval = r;
+	}
+
+	i->tab->Assign(idxval, valval);
 }
 
+void InputMgr::Clear(const InputReader* reader) {
+	ReaderInfo *i = FindReader(reader);
+	if ( i == 0 ) {
+		reporter->InternalError("Unknown reader");
+		return;
+	}
+	
+	i->tab->RemoveAll();
+}
+
+bool InputMgr::Delete(const InputReader* reader, const LogVal* const *vals) {
+	ReaderInfo *i = FindReader(reader);
+	if ( i == 0 ) {
+		reporter->InternalError("Unknown reader");
+		return false;
+	}
+	
+	Val* idxval = LogValToIndexVal(i->num_idx_fields, i->itype, vals);
+
+	return ( i->tab->Delete(idxval) != 0 );
+} 
 
 void InputMgr::Error(InputReader* reader, const char* msg)
 {
@@ -174,7 +386,46 @@ void InputMgr::SendEvent(const string& name, const int num_vals, const LogVal* c
 	mgr.Dispatch(new Event(handler, vl));
 }
 
-Val* InputMgr::LogValToVal(const LogVal* val) {
+
+Val* InputMgr::LogValToRecordVal(const LogVal* const *vals, RecordType *request_type, int* position) {
+	if ( position == 0 ) {
+		reporter->InternalError("Need position");
+		return 0;
+	}
+
+	/*
+	if ( request_type->Tag() != TYPE_RECORD ) {
+		reporter->InternalError("I only work with records");
+		return 0;
+	} */
+
+
+	RecordVal* rec = new RecordVal(request_type->AsRecordType());
+	for ( int i = 0; i < request_type->NumFields(); i++ ) {
+
+		Val* fieldVal = 0;
+		if ( request_type->FieldType(i)->Tag() == TYPE_RECORD ) {
+			fieldVal = LogValToRecordVal(vals, request_type->FieldType(i)->AsRecordType(), position);	
+		} else {
+			fieldVal = LogValToVal(vals[*position], request_type->FieldType(i)->Tag());
+			(*position)++;
+		}
+
+		rec->Assign(i, fieldVal);
+	}
+
+	return rec;
+
+} 
+
+Val* InputMgr::LogValToVal(const LogVal* val, TypeTag request_type) {
+	
+	if ( request_type != TYPE_ANY && request_type != val->type ) {
+		reporter->InternalError("Typetags don't match: %d vs %d", request_type, val->type);
+		return 0;
+	}
+	
+
 	switch ( val->type ) {
 	case TYPE_BOOL:
 	case TYPE_INT:
@@ -203,6 +454,10 @@ Val* InputMgr::LogValToVal(const LogVal* val) {
 		return new PortVal(val->val.uint_val);
 		break;
 
+	case TYPE_ADDR:
+		return new AddrVal(val->val.addr_val);
+		break;
+
 	default:
 		reporter->InternalError("unsupported type for input_read");
 	}
@@ -225,3 +480,18 @@ InputMgr::ReaderInfo* InputMgr::FindReader(const InputReader* reader)
 	return 0;
 	}
 
+		
+InputMgr::ReaderInfo* InputMgr::FindReader(const EnumVal* id)
+	{
+	for ( vector<ReaderInfo *>::iterator s = readers.begin(); s != readers.end(); ++s )
+		{
+		if ( (*s)->id == id ) 
+		{
+			return *s;
+		}
+		}
+
+	return 0;
+	}
+
+
diff --git a/src/InputMgr.h b/src/InputMgr.h
index 136be2d608..d5f732935c 100644
--- a/src/InputMgr.h
+++ b/src/InputMgr.h
@@ -11,13 +11,17 @@
 #include "RemoteSerializer.h"
 #include "LogMgr.h" // for the LogVal and LogType data types
 
+#include <vector>
+
 class InputReader;
 
 class InputMgr {
 public:
     InputMgr();
     
-    InputReader* CreateReader(EnumVal* reader, RecordVal* description);
+    	InputReader* CreateReader(EnumVal* id, RecordVal* description);
+	bool ForceUpdate(EnumVal* id);
+	bool RemoveReader(EnumVal* id);	
 	
 protected:
 	friend class InputReader;
@@ -26,14 +30,23 @@ protected:
 	void Error(InputReader* reader, const char* msg);
 
 	void Put(const InputReader* reader, const LogVal* const *vals);
+	void Clear(const InputReader* reader);
+	bool Delete(const InputReader* reader, const LogVal* const *vals);
 	
 private:
 	struct ReaderInfo;
 
-	Val* LogValToVal(const LogVal* val);
+	bool IsCompatibleType(BroType* t);
+
+	bool UnrollRecordType(vector<LogField*> *fields, const RecordType *rec, const string& nameprepend);
+
+	Val* LogValToVal(const LogVal* val, TypeTag request_type = TYPE_ANY);
+	Val* LogValToIndexVal(int num_fields, const RecordType* type, const LogVal* const *vals);
+	Val* LogValToRecordVal(const LogVal* const *vals, RecordType *request_type, int* position);	
 
 	void SendEvent(const string& name, const int num_vals, const LogVal* const *vals);
 	ReaderInfo* FindReader(const InputReader* reader);
+	ReaderInfo* FindReader(const EnumVal* id);
 
 	vector<ReaderInfo*> readers;
 };
diff --git a/src/InputReader.cc b/src/InputReader.cc
index 6502fdb421..1facc57c7f 100644
--- a/src/InputReader.cc
+++ b/src/InputReader.cc
@@ -30,6 +30,17 @@ void InputReader::Put(const LogVal* const *val)
 	input_mgr->Put(this, val);
 }
 
+void InputReader::Clear() 
+{
+	input_mgr->Clear(this);
+}
+
+void InputReader::Delete(const LogVal* const *val) 
+{
+	input_mgr->Delete(this, val);
+}
+
+
 bool InputReader::Init(string arg_source, int arg_num_fields,
 					   const LogField* const * arg_fields) 
 {
diff --git a/src/InputReader.h b/src/InputReader.h
index 3725c3d461..0e93344e1a 100644
--- a/src/InputReader.h
+++ b/src/InputReader.h
@@ -43,6 +43,8 @@ protected:
 	void SendEvent(const string& name, const int num_vals, const LogVal* const *vals);
 
 	void Put(const LogVal* const *val);
+	void Clear();
+	void Delete(const LogVal* const *val);
 
 private:
     friend class InputMgr;
diff --git a/src/InputReaderAscii.cc b/src/InputReaderAscii.cc
index d0d4a3014c..e4d581c0d8 100644
--- a/src/InputReaderAscii.cc
+++ b/src/InputReaderAscii.cc
@@ -144,6 +144,13 @@ bool InputReaderAscii::DoUpdate() {
 				break;
 
 			case TYPE_BOOL:
+				if ( s == "T" ) {
+					val->val.int_val = 1;
+				} else {
+					val->val.int_val = 0;
+				}
+				break;
+
 			case TYPE_INT:
 				val->val.int_val = atoi(s.c_str());
 				break;
@@ -155,16 +162,37 @@ bool InputReaderAscii::DoUpdate() {
 				break;
 
 			case TYPE_COUNT:
+			case TYPE_COUNTER:
+			case TYPE_PORT:
 				val->val.uint_val = atoi(s.c_str());
 				break;
 
+			case TYPE_SUBNET: {
+				int pos = s.find("/");
+				string width = s.substr(pos);
+				val->val.subnet_val.width = atoi(width.c_str());
+				string addr = s.substr(0, pos);
+				s = addr;
+				// fallthrough
+				}
+			case TYPE_ADDR: {
+				addr_type t =  dotted_to_addr(s.c_str());
+#ifdef BROv6
+				copy_addr(t, val->val.addr_val);
+#else
+				copy_addr(&t, val->val.addr_val);
+#endif
+				break;
+				}
+
+
 			default:
 				Error(Fmt("unsupported field format %d for %s", currMapping.type,
 			 	 currMapping.name.c_str()));
 				return false;
 			}	
 
-			fields[currField] = val;
+			fields[currMapping.position] = val;
 
 			currField++;
 		}
@@ -174,10 +202,7 @@ bool InputReaderAscii::DoUpdate() {
 			return false;
 		}
 
-		// ok, now we have built our line. send it back to... whomever.
-		// for testing purposes: fixed event.
-
-		SendEvent("inputEvent", num_fields, fields);
+		// ok, now we have built our line. send it back to the input manager
 		Put(fields);
 
 	}
diff --git a/src/input.bif b/src/input.bif
index 3da869ea08..4e2cbf07b5 100644
--- a/src/input.bif
+++ b/src/input.bif
@@ -9,9 +9,22 @@ module Input;
 
 type ReaderDescription: record;
 
-function Input::__create_reader%(reader: Input::Reader, description: Input::ReaderDescription%) : bool
+function Input::__create_reader%(id: ID, description: Input::ReaderDescription%) : bool
 	%{
-	InputReader *the_reader = input_mgr->CreateReader(reader->AsEnumVal(), description->AsRecordVal());
+	InputReader *the_reader = input_mgr->CreateReader(id->AsEnumVal(), description->AsRecordVal());
 	return new Val( the_reader != 0, TYPE_BOOL );
 	%}
+
+function Input::__force_update%(id: ID%) : bool
+	%{
+	bool res = input_mgr->ForceUpdate(id->AsEnumVal());
+	return new Val( res, TYPE_BOOL );
+	%}
+
 	
+function Input::__remove_reader%(id: ID%) : bool
+	%{
+	bool res = input_mgr->RemoveReader(id->AsEnumVal());
+	return new Val( res, TYPE_BOOL );
+	%}
+
diff --git a/src/types.bif b/src/types.bif
index ee43207ddd..7b81a7f631 100644
--- a/src/types.bif
+++ b/src/types.bif
@@ -174,4 +174,8 @@ enum Reader %{
 	READER_ASCII,
 %}
 
+enum ID %{
+	Unknown,
+%}
+
 module GLOBAL;