mirror of
https://github.com/zeek/zeek.git
synced 2025-10-02 14:48:21 +00:00
more complex types...
This commit is contained in:
Bernhard Amann
parent
b245d4168a
commit
86730c13dd
8 changed files with 372 additions and 31 deletions
|
|
@ -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;
|
||||
};
|
||||
}
|
||||
|
||||
|
|
|
|||
314
src/InputMgr.cc
314
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;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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 );
|
||||
%}
|
||||
|
||||
|
|
|
|||
|
|
@ -174,4 +174,8 @@ enum Reader %{
|
|||
READER_ASCII,
|
||||
%}
|
||||
|
||||
enum ID %{
|
||||
Unknown,
|
||||
%}
|
||||
|
||||
module GLOBAL;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue