From: Ebersold Date: Mon, 16 May 2022 17:03:54 +0000 (+0200) Subject: Started snmp mib parsing X-Git-Url: https://git.ebersold.fr/?a=commitdiff_plain;h=b6d2dcc28bda1d1c67abfb9ca14f9730d49933f4;p=parser%2Fasn1.git Started snmp mib parsing --- diff --git a/adt/asn1_meta.h b/adt/asn1_meta.h index 51e8b11..dedb2c2 100644 --- a/adt/asn1_meta.h +++ b/adt/asn1_meta.h @@ -18,6 +18,9 @@ namespace asn1 OBJECTCLASS, /* FCT := CLASS {} */ OBJECTSET, /* objref DefinedObject := {set } */ OBJECTFIELD, + SNMP_MODULE_IDENT, /* Mib MODULE-IDENTITY */ + SNMP_TEXTUAL_CONV, /* Mib TEXTUAL-CONVENTION */ + SNMP_OBJECT_TYPE, /* Mib OBJECT-TYPE */ MAX } id; inline meta(meta::id id = INVALID) : m_id(id) {}; diff --git a/adt/asn1_meta.inc b/adt/asn1_meta.inc index 4a9da44..0e0342a 100644 --- a/adt/asn1_meta.inc +++ b/adt/asn1_meta.inc @@ -11,4 +11,7 @@ ASSIGNMENT(OBJECTCLASS,objectclass,assignment) ASSIGNMENT(OBJECTSET,objectset,assignment) ASSIGNMENT(OBJECTFIELD,objectfield,assignment) +ASSIGNMENT(SNMP_MODULE_IDENT,snmp_mib_identity,assignment) +ASSIGNMENT(SNMP_TEXTUAL_CONV,snmp_mib_tc,assignment) +ASSIGNMENT(SNMP_OBJECT_TYPE,snmp_mib_object_type,assignment) #undef ASSIGNMENT diff --git a/adt/asn1_node_valuetype.h b/adt/asn1_node_valuetype.h index d0ba83e..e04815b 100644 --- a/adt/asn1_node_valuetype.h +++ b/adt/asn1_node_valuetype.h @@ -3,7 +3,9 @@ class objectset_assignment; /** - * Helper node that deals with all kind of value. + * Helper node that deals with all kind of value. It representes + * an ASN1 ReferencedValue: DefinedValue + * | ValueFromObject * Possible meta * -> VALUE * -> VALUESET diff --git a/adt/asn1_recursive_visitor.h b/adt/asn1_recursive_visitor.h index ad562c6..1eb3802 100644 --- a/adt/asn1_recursive_visitor.h +++ b/adt/asn1_recursive_visitor.h @@ -385,6 +385,10 @@ DEF_TRAVERSE_ASSIGN(objectset,{ }) DEF_TRAVERSE_ASSIGN(objectfield,{}) +DEF_TRAVERSE_ASSIGN(snmp_mib_identity,{}) +DEF_TRAVERSE_ASSIGN(snmp_mib_tc,{}) +DEF_TRAVERSE_ASSIGN(snmp_mib_object_type,{}) + /* Implementation Traverse type */ diff --git a/libparser/asn1.l b/libparser/asn1.l index c5067d1..bb5e647 100644 --- a/libparser/asn1.l +++ b/libparser/asn1.l @@ -7,6 +7,7 @@ #include "asn1_node.h" #include "asn1_constraint.h" #include "asn1_module.h" +#include "asn1_parser.h" /* %option never-interactive @@ -46,6 +47,8 @@ typedef union #define YY_DECL int _asn1_lex(YYSTYPE *yylval) #endif +static asn1::parser *gParser = asn1::parser::instance(); + #include "pasn1.hpp" long @@ -63,6 +66,12 @@ void _asn1_error(const char *s) { #define REF_VF { yylval->reference = new asn1::valuefield_reference(yytext);return T_VALUEFIELDREFERENCE;} #define NODE_TOK(x) { yylval->node = new asn1::node(yytext);return x;} +#define SNMP_TOK(x) { yylval->node = new asn1::node(yytext); \ + if (gParser->is_mode_mib()) \ + { return x; } else \ + return T_CAPITALREFERENCE; \ + } + #define NUM_TOK(x) { asn1::valuetype *vt = new asn1::valuetype(std::string(yytext),NULL);\ (yylval)->node = vt; \ asn1::value *v = new asn1::value(asn1::value::VT_INTEGER); \ @@ -101,6 +110,10 @@ void _asn1_error(const char *s) { %x with_syntax %x object +%x snmp_imports +%x snmp +%x snmp_quoted_string + /* */ Digits [0-9]+ NDigits -{Digits} @@ -130,7 +143,7 @@ wsp [\t\r\v\f\n ] -{3,}/[\r\n] /* Comment */ -- yy_push_state(dash_comment); --- yy_push_state(dash_comment); +-- yy_push_state(dash_comment); { /* Very special to treat rules for dash_comment rules */ {nl} yy_pop_state(); @@ -147,112 +160,185 @@ wsp [\t\r\v\f\n ] . /* skip */ } -"::=" TOK(T_ASSIGN) +"::=" TOK(T_ASSIGN) {BString} TOK(T_bstring) -{Digits} NUM_TOK(T_NUM) -{NDigits} NUM_TOK(T_NUM) +{Digits} NUM_TOK(T_NUM) +{NDigits} NUM_TOK(T_NUM) -ABSENT TOK(T_ABSENT) -ABSTRACT TOK(T_ABSTRACT) -ABSTRACT-SYNTAX TOK(T_ABSTRACT_SYNTAX) +ABSENT TOK(T_ABSENT) +ABSTRACT TOK(T_ABSTRACT) +ABSTRACT-SYNTAX TOK(T_ABSTRACT_SYNTAX) ALL TOK(T_ALL) -ANY TOK(T_ANY) -APPLICATION TOK(T_APPLICATION) -AUTOMATIC TOK(T_AUTOMATIC) -BEGIN TOK(T_BEGIN) -BIT TOK(T_BIT) - -BMPString TOK(T_BMPString) -BOOLEAN TOK(T_BOOLEAN) -BY TOK(T_BY) -CHARACTER TOK(T_CHARACTER) -CHOICE TOK(T_CHOICE) -CLASS TOK(T_CLASS) -COMPONENT TOK(T_COMPONENT) -COMPONENTS TOK(T_COMPONENTS) -CONTAINING TOK(T_CONTAINING) -CONSTRAINED TOK(T_CONSTRAINED) -DATE TOK(T_DATE) -DATE-TIME TOK(T_DATE_TIME) -DEFAULT TOK(T_DEFAULT) -DEFINED TOK(T_DEFINED) /* Not reserved word in ASN1 may be old parser (ANY DEFINED BY) */ - -DEFINITIONS TOK(T_DEFINITIONS) -DURATION TOK(T_DURATION) +ANY TOK(T_ANY) +APPLICATION TOK(T_APPLICATION) +AUTOMATIC TOK(T_AUTOMATIC) +BEGIN TOK(T_BEGIN) +BITS TOK(T_BIT) +BIT TOK(T_BIT) + +BMPString TOK(T_BMPString) +BOOLEAN TOK(T_BOOLEAN) +BY TOK(T_BY) +CHARACTER TOK(T_CHARACTER) +CHOICE TOK(T_CHOICE) +CLASS TOK(T_CLASS) +COMPONENT TOK(T_COMPONENT) +COMPONENTS TOK(T_COMPONENTS) +CONTAINING TOK(T_CONTAINING) +CONSTRAINED TOK(T_CONSTRAINED) +DATE TOK(T_DATE) +DATE-TIME TOK(T_DATE_TIME) +DEFAULT TOK(T_DEFAULT) +DEFINED TOK(T_DEFINED) /* Not reserved word in ASN1 may be old parser (ANY DEFINED BY) */ + +DEFINITIONS TOK(T_DEFINITIONS) +DURATION TOK(T_DURATION) EMBEDDED -ENCODED TOK(T_ENCODED) -ENCODING-CONTROL TOK(T_ENCODING_CONTROL) -END TOK(T_END) -ENUMERATED TOK(T_ENUMERATED) -EXCEPT TOK(T_EXCEPT) -EXPLICIT TOK(T_EXPLICIT) -EXPORTS TOK(T_EXPORTS) -EXTENSIBILITY TOK(T_EXTENSIBILITY) -EXTERNAL TOK(T_EXTERNAL) -FALSE TOK(T_ASN1_FALSE) -FROM TOK(T_FROM) -GeneralizedTime TOK(T_GeneralizedTime) -GeneralString TOK(T_GeneralizedString) -GraphicString TOK(T_GraphicString) -{HString} TOK(T_hstring) -IA5String TOK(T_IA5String) -IDENTIFIER TOK(T_STR_IDENTIFIER) -IMPLICIT TOK(T_IMPLICIT) -IMPLIED TOK(T_IMPLIED) -IMPORTS TOK(T_IMPORTS) -INCLUDES TOK(T_INCLUDES) -INSTANCE TOK(T_INSTANCE) -INSTRUCTIONS TOK(T_INSTRUCTIONS) -INTEGER TOK(T_INTEGER) -INTERSECTION TOK(T_INTERSECTION) -ISO64String TOK(T_ISO646String) -MAX TOK(T_MAX) -MIN TOK(T_MIN) -MINUS-INFINITY TOK(T_MINUS_INFINITY) -NOT-A-NUMBER TOK(T_NOT_A_NUMBER) -NULL TOK(T_NULL) -NumericString TOK(T_NumericString) -ObjectDescriptor TOK(T_ObjectDescriptorString) -OBJECT TOK(T_OBJECT) -OCTET TOK(T_OCTET) -OF TOK(T_OF) -OID-IRI TOK(T_OID_IRI) -OPTIONAL TOK(T_OPTIONAL) -PATTERN TOK(T_PATTERN) -PDV -PLUS-INFINITY -PRESENT TOK(T_PRESENT) -PrintableString TOK(T_PrintableString) -PRIVATE -REAL TOK(T_REAL) -RELATIVE-OID TOK(T_RELATIVE_OID) -RELATIVE-OID-IRI TOK(T_RELATIVE_OID_IRI) -SEQUENCE TOK(T_SEQUENCE) -SET TOK(T_SET) -SETTINGS TOK(T_SETTINGS) -SIZE TOK(T_SIZE) -STRING TOK(T_STRING) -SYNTAX TOK(T_SYNTAX) -T61String TOK(T_T61String) -TAGS TOK(T_TAGS) -TeletexString TOK(T_TeletexString) -TIME TOK(T_TIME) -TIME-OF-DAY TOK(T_TIME_OF_DAY) -TRUE TOK(T_ASN1_TRUE) -UNION TOK(T_UNION) -UNIQUE TOK(T_UNIQUE) -UNIVERSAL TOK(T_UNIVERSAL) -UniversalString TOK(T_UniversalString) - -UTCTime TOK(T_UTCTime) -UTF8String TOK(T_UTF8String) - -VideotextString TOK(T_VideotextString) -VisibleString TOK(T_VisibleString) -WITH TOK(T_WITH) +ENCODED TOK(T_ENCODED) +ENCODING-CONTROL TOK(T_ENCODING_CONTROL) +END TOK(T_END) +ENUMERATED TOK(T_ENUMERATED) +EXCEPT TOK(T_EXCEPT) +EXPLICIT TOK(T_EXPLICIT) +EXPORTS TOK(T_EXPORTS) +EXTENSIBILITY TOK(T_EXTENSIBILITY) +EXTERNAL TOK(T_EXTERNAL) +FALSE TOK(T_ASN1_FALSE) +FROM TOK(T_FROM) +GeneralizedTime TOK(T_GeneralizedTime) +GeneralString TOK(T_GeneralizedString) +GraphicString TOK(T_GraphicString) +{HString} TOK(T_hstring) +IA5String TOK(T_IA5String) +IDENTIFIER TOK(T_STR_IDENTIFIER) +IMPLICIT TOK(T_IMPLICIT) +IMPLIED TOK(T_IMPLIED) +IMPORTS { + if (gParser->is_mode_mib()) + yy_push_state(snmp_imports); + return T_IMPORTS; + } +INCLUDES TOK(T_INCLUDES) +INSTANCE TOK(T_INSTANCE) +INSTRUCTIONS TOK(T_INSTRUCTIONS) +INTEGER TOK(T_INTEGER) +INTERSECTION TOK(T_INTERSECTION) +ISO64String TOK(T_ISO646String) +MAX TOK(T_MAX) +MAX-ACCESS TOK(T_MAX_ACCESS) +MIN TOK(T_MIN) +MINUS-INFINITY TOK(T_MINUS_INFINITY) +NOT-A-NUMBER TOK(T_NOT_A_NUMBER) +NULL TOK(T_NULL) +NumericString TOK(T_NumericString) +ObjectDescriptor TOK(T_ObjectDescriptorString) +OBJECTS TOK(T_OBJECTS) +OBJECT TOK(T_OBJECT) +OCTET TOK(T_OCTET) +OF TOK(T_OF) +OID-IRI TOK(T_OID_IRI) +OPTIONAL TOK(T_OPTIONAL) +PATTERN TOK(T_PATTERN) +PDV +PLUS-INFINITY +PRESENT TOK(T_PRESENT) +PrintableString TOK(T_PrintableString) +PRIVATE +REAL TOK(T_REAL) +RELATIVE-OID TOK(T_RELATIVE_OID) +RELATIVE-OID-IRI TOK(T_RELATIVE_OID_IRI) +SEQUENCE TOK(T_SEQUENCE) +SET TOK(T_SET) +SETTINGS TOK(T_SETTINGS) +SIZE TOK(T_SIZE) +STRING TOK(T_STRING) +SYNTAX TOK(T_SYNTAX) +T61String TOK(T_T61String) +TAGS TOK(T_TAGS) +TeletexString TOK(T_TeletexString) +TIME TOK(T_TIME) +TIME-OF-DAY TOK(T_TIME_OF_DAY) +TRUE TOK(T_ASN1_TRUE) +UNION TOK(T_UNION) +UNITS TOK(T_UNITS) +UNIQUE TOK(T_UNIQUE) +UNIVERSAL TOK(T_UNIVERSAL) +UniversalString TOK(T_UniversalString) + +UTCTime TOK(T_UTCTime) +UTF8String TOK(T_UTF8String) + +VideotextString TOK(T_VideotextString) +VisibleString TOK(T_VisibleString) +WITH TOK(T_WITH) + +%{ /** SIM SNMP MACRO Names */ %} + +MODULE-IDENTITY SNMP_TOK(T_MACRO_NAME) +OBJECT-IDENTITY SNMP_TOK(T_MACRO_OBJECT_IDENTITY) +OBJECT-TYPE SNMP_TOK(T_MACRO_OBJECT_TYPE) +NOTIFICATION-TYPE SNMP_TOK(T_MACRO_NOTIFICATION_TYPE) +TRAP-TYPE SNMP_TOK(T_MACRO_TRAP_TYPE) +TEXTUAL-CONVENTION SNMP_TOK(T_MACRO_TC) +OBJECT-GROUP SNMP_TOK(T_MACRO_OBJECT_GROUP) +NOTIFICATION-GROUP SNMP_TOK(T_MACRO_NOTIFICATION_GROUP) +MODULE-COMPLIANCE SNMP_TOK(T_MACRO_MODULE_COMPLIANCE) +AGENT-COMPABILITIES SNMP_TOK(T_MACRO_NAME) + +{ + {Identifier} NODE_TOK(T_IDENTIFIER) + {String_Literal} NODE_TOK(T_IDENTIFIER) + {CapitalReference} NODE_TOK(T_CAPITALREFERENCE) + {TypeReference} NODE_TOK(T_TYPEREFERENCE) + "{" TOK(T_LBRACET) + "}" TOK(T_RBRACET) + "," TOK(T_COMMA) + ";" { + yy_pop_state(); + return T_SIMILICON; + } + {wsp}+ /* ignore whitespace*/ +} +{ + \"[^\"]*\" { return T_QUOTED_STRING;} +} +{ + ACCESS TOK(T_ACCESS) + AUGMENTS TOK(T_AUGMENTS) + CONTACT-INFO TOK(T_CONTACT_INFO) + DESCRIPTION TOK(T_DESCRIPTION) + DISPLAY-HINT TOK(T_DISPLAY_HINT) + DEFVAL TOK(T_DEFVAL) + ENTERPRISE TOK(T_ENTERPRISE) + GROUP TOK(T_GROUP) + INDEX TOK(T_INDEX) + LAST-UPDATED TOK(T_LAST_UPDATED) + MANDATORY-GROUPS TOK(T_MANDATORY_GROUPS) + MIN-ACCESS TOK(T_MIN_ACCESS) + MODULE TOK(T_MODULE) + NOTIFICATIONS TOK(T_NOTIFICATIONS) + REVISION TOK(T_REVISION) + REFERENCE TOK(T_REFERENCE) + ORGANIZATION TOK(T_ORGANIZATION) + STATUS TOK(T_STATUS) + UNITS TOK(T_UNITS) + VARIABLES TOK(T_VARIABLES) + WRITE-SYNTAX TOK(T_WRITE_SYNTAX) + {Identifier} NODE_TOK(T_IDENTIFIER) + {CapitalReference} NODE_TOK(T_CAPITALREFERENCE) + {TypeReference} NODE_TOK(T_TYPEREFERENCE) + \"[^\"]*\" { /* QUOTED STRING */ + yylval->node = new asn1::node(yytext); + return T_QUOTED_STRING; + } + ";" { + return T_SIMILICON; + } + {wsp}+ /* ignore whitespace*/ +} {Identifier} NODE_TOK(T_IDENTIFIER) @@ -277,17 +363,17 @@ WITH TOK(T_WITH) "!" TOK(T_EXCLAMATION) "[" TOK(T_LBRACKET) "]" TOK(T_RBRACKET) -"{" TOK(T_LBRACET) -"}" TOK(T_RBRACET) -")" TOK(T_RPARENTHESES) -"(" TOK(T_LPARENTHESES) -"." TOK(T_POINT) -".." TOK(T_TWOPOINT) -"..." TOK(T_THREEPOINT) -"," TOK(T_COMMA) +"{" TOK(T_LBRACET) +"}" TOK(T_RBRACET) +")" TOK(T_RPARENTHESES) +"(" TOK(T_LPARENTHESES) +"." TOK(T_POINT) +".." TOK(T_TWOPOINT) +"..." TOK(T_THREEPOINT) +"," TOK(T_COMMA) ";" TOK(T_SIMILICON) ":" TOK(T_COLON) -"|" TOK(T_UNION) +"|" TOK(T_UNION) "^" TOK(T_EXCEPT) "_" TOK(T_USCORE) {wsp}+ /* ignore whitespace*/ @@ -368,6 +454,16 @@ void disable_object() { yy_pop_state(); } +/* SNMP MIB INFORMATION LEX*/ +void enable_snmp() +{ + yy_push_state(snmp); +} +void disable_snmp() +{ + yy_pop_state(); +} + diff --git a/libparser/asn1.y b/libparser/asn1.y index f102f2c..0543511 100644 --- a/libparser/asn1.y +++ b/libparser/asn1.y @@ -47,18 +47,34 @@ extern void enable_encoding_control(void); extern void disable_with_syntax(void); extern void enable_object(void); extern void disable_object(void); + +extern void enable_snmp(void); +extern void disable_snmp(void); + +#if 1 +#define OLD_ENABLE_SNMP() +#define OLD_DISABLE_SNMP() +#define NEW_ENABLE_SNMP() enable_snmp() +#define NEW_DISABLE_SNMP() disable_snmp() +#else +#define OLD_ENABLE_SNMP() enable_snmp() +#define OLD_DISABLE_SNMP() disable_snmp() +#define NEW_ENABLE_SNMP() +#define NEW_DISABLE_SNMP() +#endif //#include "lasn1.cpp" static asn1::parser *gParser = asn1::parser::instance(); +#define LOG_BUF_LEN 256 #if defined(__GNUC__) && defined(DEBUG) #define ASN_LOG_DEBUG(fmt,args...) do {\ - char _lbuf[256]; \ + char _lbuf[LOG_BUF_LEN]; \ if ( gLog.is_open()) { \ gLog<<"DEBUG "; \ - sprintf(_lbuf,fmt,##args); gLog<<_lbuf; \ - sprintf(_lbuf," (asn1.y : %d)\n",__LINE__); gLog<<_lbuf; \ + snprintf(_lbuf,LOG_BUF_LEN,fmt,##args); gLog<<_lbuf; \ + snprintf(_lbuf,LOG_BUF_LEN," (asn1.y : %d)\n",__LINE__); gLog<<_lbuf; \ } else if (gParser->debug_console() ) { \ fprintf(stderr,"asn1_parser (DEBUG): "); \ fprintf(stderr,fmt,##args);\ @@ -67,11 +83,11 @@ asn1::parser *gParser = asn1::parser::instance(); } while (0) #define ASN_LOG_WARNING(fmt,args...) do {\ - char _lbuf[256]; \ + char _lbuf[LOG_BUF_LEN]; \ if (gLog.is_open()) { \ gLog<<"WARN "; \ - sprintf(_lbuf,fmt,##args); gLog<<_lbuf; \ - sprintf(_lbuf," (asn1.y : %d)\n",__LINE__); gLog<<_lbuf; \ + snprintf(_lbuf,LOG_BUF_LEN,fmt,##args); gLog<<_lbuf; \ + snprintf(_lbuf,LOG_BUF_LEN," (asn1.y : %d)\n",__LINE__); gLog<<_lbuf; \ } \ fprintf(stderr,"asn1_parser (WARNI): "); \ fprintf(stderr,fmt,##args);\ @@ -79,11 +95,11 @@ asn1::parser *gParser = asn1::parser::instance(); } while (0) #define ASN_LOG_ERROR(fmt,args...) do {\ - char _lbuf[256]; \ + char _lbuf[LOG_BUF_LEN]; \ if ( gLog.is_open()) { \ gLog<<"ERROR "; \ - sprintf(_lbuf,fmt,##args); gLog<<_lbuf; \ - sprintf(_lbuf," (asn1.y : %d)\n",__LINE__); gLog<<_lbuf; \ + snprintf(_lbuf,LOG_BUF_LEN,fmt,##args); gLog<<_lbuf; \ + snprintf(_lbuf,LOG_BUF_LEN," (asn1.y : %d)\n",__LINE__); gLog<<_lbuf; \ } \ fprintf(stderr,"asn1_parser (ERROR): "); \ fprintf(stderr,fmt,##args);\ @@ -161,6 +177,8 @@ static asn1::classdef *gCurrentClassDef = NULL; %token T_ABSENT %token T_ABSTRACT %token T_ABSTRACT_SYNTAX +%token T_ACCESS +%token T_AUGMENTS %token T_ALL %token T_ANY %token T_APPLICATION @@ -171,6 +189,7 @@ static asn1::classdef *gCurrentClassDef = NULL; %token T_AUTOMATIC %token T_BEGIN %token T_BIT +%token T_BITS %token T_BOOLEAN %token T_BY %token T_CAPITALREFERENCE @@ -178,63 +197,93 @@ static asn1::classdef *gCurrentClassDef = NULL; %token T_CHOICE %token T_CLASS %token T_COLON +%token T_CONTACT_INFO %token T_COMPONENT %token T_COMPONENTS %token T_CONTAINING +%token T_DESCRIPTION +%token T_DEFVAL %token T_DATE %token T_DATE_TIME %token T_CONSTRAINED %token T_DEFAULT %token T_DEFINITIONS +%token T_DISPLAY_HINT %token T_DURATION %token T_ENCODED %token T_ENCODING_CONTROL %token T_END +%token T_ENTERPRISE %token T_EXPLICIT %token T_EXCEPT %token T_EXCLAMATION %token T_EXPORTS %token T_EXTENSIBILITY %token T_EXTERNAL +%token T_GROUP %token T_IDENTIFIER %token T_IMPLICIT %token T_IMPLIED %token T_INCLUDES +%token T_INDEX %token T_INSTANCE %token T_INSTRUCTIONS %token T_INTEGER %token T_INTERSECTION +%token T_LAST_UPDATED %token T_LT +%token T_MACRO_NAME +%token T_MACRO_NOTIFICATION_TYPE +%token T_MACRO_NOTIFICATION_GROUP +%token T_MACRO_OBJECT_GROUP +%token T_MACRO_OBJECT_TYPE +%token T_MACRO_TRAP_TYPE +%token T_MACRO_OBJECT_IDENTITY +%token T_MACRO_TC +%token T_MACRO_MODULE_COMPLIANCE +%token T_MANDATORY_GROUPS %token T_MAX +%token T_MAX_ACCESS %token T_MIN +%token T_MIN_ACCESS +%token T_MODULE %token T_MINUS_INFINITY %token T_NOT_A_NUMBER +%token T_NOTIFICATIONS %token T_NULL %token T_NUM +%token T_OBJECT +%token T_OBJECTS %token T_OCTET %token T_OPTIONAL %token T_OF %token T_OID_IRI -%token T_OBJECT +%token T_ORGANIZATION %token T_Quadruple +%token T_QUOTED_STRING %token T_POINT %token T_PATTERN %token T_PRESENT %token T_PRIVATE %token T_REAL +%token T_REFERENCE %token T_RELATIVE_OID %token T_RELATIVE_OID_IRI +%token T_REVISION %token T_SIMILICON %token T_SEQUENCE %token T_SET %token T_SETTINGS %token T_SIZE +%token T_STATUS %token T_STRING %token T_SYNTAX %token T_Tuple %token T_UNION +%token T_UNITS %token T_UNIVERSAL %token T_UNIQUE +%token T_VARIABLES %token T_STR_IDENTIFIER %token T_TYPEREFERENCE %token T_TYPEFIELDREFERENCE @@ -275,6 +324,7 @@ static asn1::classdef *gCurrentClassDef = NULL; %token T_TWOPOINT %token T_THREEPOINT %token T_WITH +%token T_WRITE_SYNTAX %token T_USCORE %token T_bstring %token T_hstring @@ -374,6 +424,7 @@ static asn1::classdef *gCurrentClassDef = NULL; %type set_def %type set_value %type sequence_def +%type snmp_assignment %type choice_def %type defined_syntax_list %type parameter_list @@ -411,7 +462,6 @@ static asn1::classdef *gCurrentClassDef = NULL; %name-prefix="_asn1_" %pure-parser - %% definition_files:definitions @@ -661,10 +711,15 @@ definition_module: opt_exports opt_imports asn1::module *m = get_current_module(); m->imports(i); m->exports(e); + /* May be enable snmp here if mib*/ + if (asn1::parser::instance()->is_mode_mib()) + { NEW_ENABLE_SNMP(); } } type_constant_list { $$ = $4; - } + if (asn1::parser::instance()->is_mode_mib()) + { NEW_DISABLE_SNMP(); } + } ; opt_tags_def: /* Empty */ @@ -3201,6 +3256,391 @@ defined_syntax_token: } ; +/* + * SNMP / MIB rules + */ +snmp_assignment: snmp_module_identity + { + ASN_LOG_DEBUG("snmp_assignment :"); + $$ = new asn1::snmp_mib_identity_assignment($1->name()); + } + | snmp_textual_convention { + ASN_LOG_DEBUG("snmp_textual_convention:"); + $$ = new asn1::snmp_mib_identity_assignment($1->name()); + } + | snmp_object_type { + ASN_LOG_DEBUG("snmp_object_type :"); + $$ = new asn1::snmp_mib_identity_assignment($1->name()); + } + | snmp_notification_type { + ASN_LOG_DEBUG("snmp_notification_type :"); + $$ = new asn1::snmp_mib_identity_assignment($1->name()); + } + | snmp_trap_type { + ASN_LOG_DEBUG("snmp_notification_type :"); + $$ = new asn1::snmp_mib_identity_assignment($1->name()); + } + | snmp_notification_group { + ASN_LOG_DEBUG("snmp_notification_group :"); + $$ = new asn1::snmp_mib_identity_assignment($1->name()); + } + | snmp_module_compliance { + ASN_LOG_DEBUG("snmp_object_type :"); + $$ = new asn1::snmp_mib_identity_assignment($1->name()); + } + | snmp_object_group { + ASN_LOG_DEBUG("snmp_object_group :"); + $$ = new asn1::snmp_mib_identity_assignment($1->name()); + } + | snmp_object_identity { + ASN_LOG_DEBUG("snmp_object_identity :"); + $$ = new asn1::snmp_mib_identity_assignment($1->name()); + } +; + +/* SNMP common rules */ +snmp_description: T_DESCRIPTION T_QUOTED_STRING { + ASN_LOG_DEBUG("snmp_mi_description: %s",$2->name().c_str()); + } +; + +snmp_status: T_STATUS T_IDENTIFIER +; + +/** SNMP MODULE_IDENTITY */ +snmp_module_identity: T_IDENTIFIER T_MACRO_NAME { + ASN_LOG_DEBUG("snmp_module_identity: %s ",$1->name().c_str()); + } snmp_mi_attributes { + ASN_LOG_DEBUG("snmp_module_identity: + %s",$1->name().c_str()); + } T_ASSIGN { + ASN_LOG_DEBUG("snmp_module_identity: %s have assigment",$1->name().c_str()); + } T_LBRACET obj_constant_list T_RBRACET { + ASN_LOG_DEBUG("snmp_module_identity: %s end",$1->name().c_str()); + asn1::module *m = get_current_module(); + asn1::node *ids = m->leave_context(); + $$ = ids; + $$ = $1; +} +; + +snmp_mi_attributes: snmp_mi_last_update + snmp_mi_organization + snmp_mi_contact + snmp_description + snmp_mi_revisions { + ASN_LOG_DEBUG("snmp_mi_attributes: end"); +} +; + +snmp_mi_last_update: T_LAST_UPDATED T_QUOTED_STRING { + ASN_LOG_DEBUG("snmp_mi_last_updated %s",$2->name().c_str()); + } +; +snmp_mi_organization: T_ORGANIZATION T_QUOTED_STRING { + ASN_LOG_DEBUG("snmp_mi_organization"); + } +; +snmp_mi_contact: T_CONTACT_INFO T_QUOTED_STRING { + ASN_LOG_DEBUG("snmp_mi_contact:"); + } +; + +snmp_mi_revisions: snmp_mi_revision { + } + | snmp_mi_revision snmp_mi_revisions { + } +; + +snmp_mi_revision: T_REVISION T_QUOTED_STRING + T_DESCRIPTION T_QUOTED_STRING { + ASN_LOG_DEBUG("snmp_mi_revision: revision %s / description %s",$2->name().c_str(),$4->name().c_str()); + } +; + +/** SNMP TEXTUAL CONVENTION */ +snmp_textual_convention: T_TYPEREFERENCE T_ASSIGN T_MACRO_TC snmp_tc_attributes { + $$ = $1; + } +; + +snmp_tc_attributes: snmp_tc_display + snmp_tc_status + snmp_tc_description + snmp_tc_reference + snmp_tc_syntax +; + +snmp_tc_display: /* can be null */ + | T_DISPLAY_HINT T_QUOTED_STRING { +}; + +snmp_tc_status: /* can be null */ + | snmp_status { +}; + +snmp_tc_description: /* can be null */ + | snmp_description { +}; + +snmp_tc_reference: /* can be null */ + | T_REFERENCE T_QUOTED_STRING { +}; + +snmp_tc_syntax: /* can be null */ + | T_SYNTAX type_assign_right opt_constraint_def { +}; + +/** SNMP OBJECT-TYPE */ +snmp_object_type: T_IDENTIFIER T_MACRO_OBJECT_TYPE snmp_ot_attributes + T_ASSIGN T_LBRACET obj_constant_list T_RBRACET { + asn1::module *m = get_current_module(); + asn1::node *ids = m->leave_context(); + $$ = $1; + } +; + +snmp_ot_attributes: snmp_ot_syntax + snmp_ot_units + snmp_ot_access + snmp_ot_status + snmp_description + snmp_ot_index + snmp_ot_augments + snmp_ot_reference + snmp_ot_defval +; + +snmp_ot_syntax: T_SYNTAX type_assign_right opt_constraint_def { + } + | T_SYNTAX T_BITS T_LBRACET snmp_ot_bits T_RBRACET { + } +; + +snmp_ot_bits:obj_constant { + } + | snmp_ot_bits T_COMMA obj_constant { + } +; + +snmp_ot_units: /* NULL*/ + | T_UNITS T_QUOTED_STRING { + } +; +snmp_ot_access: T_MAX_ACCESS T_IDENTIFIER { + } + | T_ACCESS T_IDENTIFIER { +} +; + +snmp_ot_status: T_STATUS T_IDENTIFIER { + } +; + +snmp_ot_augments: /**/ + | T_AUGMENTS T_LBRACET snmp_ot_indexes T_RBRACET { + } +; +snmp_ot_index: /**/ + | T_INDEX T_LBRACET snmp_ot_indexes T_RBRACET { + } +; +snmp_ot_indexes: T_IDENTIFIER { + } + | snmp_ot_indexes T_COMMA T_IDENTIFIER { +} +; + +snmp_ot_reference: /**/ + | T_REFERENCE T_QUOTED_STRING { + } +; + +snmp_ot_defval: /*NULL */ + | T_DEFVAL T_LBRACET T_IDENTIFIER T_RBRACET { + } + | T_DEFVAL T_LBRACET T_NUM T_RBRACET { + } +; + +/** SNMP TRAP-TYPE */ +snmp_trap_type: T_IDENTIFIER T_MACRO_TRAP_TYPE snmp_tt_attributes + T_ASSIGN pos_neg_num { + $$ = $1; + } +; + +snmp_tt_attributes: snmp_tt_entreprise + snmp_tt_vars + snmp_tc_description + snmp_tc_reference +; + +snmp_tt_entreprise: T_ENTERPRISE T_LBRACET T_RBRACET + | T_ENTERPRISE T_IDENTIFIER +; + +snmp_tt_vars: /* NULL */ + | T_VARIABLES T_LBRACET snmp_tt_variable_list T_RBRACET +; + +snmp_tt_variable_list: T_IDENTIFIER + | snmp_tt_variable_list T_COMMA T_IDENTIFIER +; + +/** SNMP MODULE-COMPLIANCE */ +snmp_module_compliance: T_IDENTIFIER T_MACRO_MODULE_COMPLIANCE snmp_mc_attributes { + $$ = $1; + } T_ASSIGN + T_LBRACET obj_constant_list T_RBRACET { + ASN_LOG_DEBUG("snmp_module_compliance: %s end",$1->name().c_str()); + asn1::module *m = get_current_module(); + asn1::node *ids = m->leave_context(); + $$ = $1; +}; + +snmp_mc_attributes: snmp_status + snmp_description + snmp_mc_modules + snmp_mc_compliance_part +; + +snmp_mc_modules: snmp_mc_module + | snmp_mc_module snmp_mc_modules +; + +snmp_mc_module: T_MODULE snmp_mc_module_name + snmp_mc_mandatory_groups +; + +snmp_mc_module_name: /* Empty */ + | T_IDENTIFIER +; + +snmp_mc_mandatory_groups: T_MANDATORY_GROUPS T_LBRACET snmp_mc_mandatories T_RBRACET +; + +snmp_mc_mandatories: T_IDENTIFIER + | snmp_mc_mandatories T_COMMA T_IDENTIFIER +; + + +snmp_mc_compliance_part: /* Can be NULL */ + | snmp_mc_compliances +; + +snmp_mc_compliances: snmp_mc_compliance + | snmp_mc_compliance snmp_mc_compliances +; + +snmp_mc_compliance: snmp_mc_group + | snmp_mc_object +; + +snmp_mc_group: T_GROUP T_IDENTIFIER + T_DESCRIPTION T_QUOTED_STRING +; + +snmp_mc_object: T_OBJECT T_IDENTIFIER + snmp_mc_obj_syntax + snmp_mc_obj_access + snmp_description +; + +/* Need to find out what kind of syntax it is about here */ +snmp_mc_obj_syntax: /**/ + | T_SYNTAX type + | T_SYNTAX T_BITS T_LBRACET constant_list T_RBRACET + | T_WRITE_SYNTAX type_assign_right opt_constraint_def +; + +snmp_mc_obj_access: /* Can be null */ + | T_MIN_ACCESS T_IDENTIFIER { + } +; + +/** SNMP OBJECT-GROUP */ +snmp_object_group: T_IDENTIFIER T_MACRO_OBJECT_GROUP + snmp_og_attributes { + $$ = $1; + } T_ASSIGN + T_LBRACET obj_constant_list T_RBRACET { + ASN_LOG_DEBUG("snmp_module_compliance: %s end",$1->name().c_str()); + asn1::module *m = get_current_module(); + asn1::node *ids = m->leave_context(); + $$ = $1; +}; + +snmp_og_attributes: snmp_objects + snmp_status + snmp_description +; + +snmp_objects: T_OBJECTS T_LBRACET snmp_og_list T_RBRACET +; + +snmp_og_list: T_IDENTIFIER + | snmp_og_list T_COMMA T_IDENTIFIER { +}; + +/** SNMP NOTIFICATION-TYPE */ +snmp_notification_type: T_IDENTIFIER T_MACRO_NOTIFICATION_TYPE + snmp_nt_attributes { + $$ = $1; + } T_ASSIGN + T_LBRACET obj_constant_list T_RBRACET { + ASN_LOG_DEBUG("snmp_module_compliance: %s end",$1->name().c_str()); + asn1::module *m = get_current_module(); + asn1::node *ids = m->leave_context(); + $$ = $1; +}; + +snmp_nt_attributes: snmp_objects + snmp_status + snmp_description { +}; + +/** SNMP NOTIFICATION-GROUP */ +snmp_notification_group: T_IDENTIFIER T_MACRO_NOTIFICATION_GROUP + snmp_ng_attributes { + $$ = $1; + } T_ASSIGN + T_LBRACET obj_constant_list T_RBRACET { + ASN_LOG_DEBUG("snmp_notification_group %s end",$1->name().c_str()); + asn1::module *m = get_current_module(); + asn1::node *ids = m->leave_context(); + $$ = $1; +}; + +snmp_ng_attributes: snmp_ng_notifications + snmp_status + snmp_description { +}; + +snmp_ng_notifications: T_NOTIFICATIONS T_LBRACET snmp_ng_list T_RBRACET { +} +; + +snmp_ng_list: T_IDENTIFIER + | snmp_ng_list T_COMMA T_IDENTIFIER { +}; + +/** SNMP OBJECT-IDENTITY */ +snmp_object_identity: T_IDENTIFIER T_MACRO_OBJECT_IDENTITY + snmp_oi_attributes { + $$ = $1; + } T_ASSIGN + T_LBRACET obj_constant_list T_RBRACET { + ASN_LOG_DEBUG("snmp_notification_group %s end",$1->name().c_str()); + asn1::module *m = get_current_module(); + asn1::node *ids = m->leave_context(); + $$ = $1; +}; + +snmp_oi_attributes: + snmp_status + snmp_description { +}; + /* * */ @@ -3226,6 +3666,10 @@ type_constant: ASN_LOG_DEBUG("type_constant: constant_set_def"); $$ = $1; } + | snmp_assignment { + ASN_LOG_DEBUG("type_constant:snmp_assignment"); + $$ = $1; + } | T_ENCODING_CONTROL T_CAPITALREFERENCE { ASN_LOG_DEBUG("type_constant: encoding control start enable ignored for now"); enable_encoding_control(); diff --git a/libparser/asn1_parser.cpp b/libparser/asn1_parser.cpp index 95cf42a..f8f26a8 100644 --- a/libparser/asn1_parser.cpp +++ b/libparser/asn1_parser.cpp @@ -43,33 +43,38 @@ int _asn1_wrap() // close the current in, and open the new one if ((asn1p->file_mode() ) && _asn1_in != NULL) { - fclose(_asn1_in); - _asn1_in = NULL; + fclose(_asn1_in); + _asn1_in = NULL; } else if (!asn1p->file_mode()) { return 1; } // Only process files if specified if (asn1p->files().size() > 0) - { - if (asn1p->includes().size() > 0) { - std::list::iterator it; - for ( it = asn1p->includes().begin() - ; it != asn1p->includes().end(); ++it) + { + fullname = asn1p->files().back(); + /* Search over includes if can't access */ + if ((asn1p->includes().size() > 0) + && access(fullname.c_str(),F_OK) /* Could not open */ + ) { - fullname = (*it) + asn1p->files().back(); - if (!access(fullname.c_str(),F_OK)) - { - break; + std::list::iterator it; + for ( it = asn1p->includes().begin() + ; it != asn1p->includes().end(); ++it) + { + fullname = (*it) + asn1p->files().back(); + if (!access(fullname.c_str(),F_OK)) + { + break; + } } - } } if (fullname.size() > 0) { _asn1_in = fopen(fullname.c_str(),"r"); if (_asn1_in != NULL) { - std::cout<<"New File : "<files().pop_back(); return 0; } else { diff --git a/libparser/asn1_parser.h b/libparser/asn1_parser.h index 0e418fc..6546f2a 100644 --- a/libparser/asn1_parser.h +++ b/libparser/asn1_parser.h @@ -64,6 +64,12 @@ class parser void got_act_parameter(asn1::node *n); int parse(); + + inline void set_mode(const std::string &_mode) + { m_mode = _mode ; } + + inline bool is_mode_mib() const + { return !m_mode.compare("mib") ; } inline bool debug_console() const { return m_debug_console ; } @@ -77,7 +83,7 @@ class parser { m_file_mode = fm;} private: parser() - : m_file_mode(false) , m_root(NULL) + : m_file_mode(false) , m_root(NULL),m_mode("asn1") {}; parser(const parser &p) {}; @@ -87,7 +93,8 @@ class parser private: modules_type m_modules; static parser *m_instance; - + std::string m_mode; + bool m_first_token; // Will be used to select right grammer protected: bool m_debug_console; node *m_root; diff --git a/libparser/asn1_parser_listener.h b/libparser/asn1_parser_listener.h index 27587d7..0111f6c 100644 --- a/libparser/asn1_parser_listener.h +++ b/libparser/asn1_parser_listener.h @@ -23,5 +23,17 @@ class parser_listener protected: }; +/** + * @brief in addition to the root listener, the mib listener + * recieves notifications regardinf mib objects + */ +class mib_listener : public parser_listener +{ + public: + mib_listener() {} ; + + virtual void onObjectType(void ) {}; +}; + } #endif /*ASN1_PARSER_LISTENER_H*/ diff --git a/main.cpp b/main.cpp index 2746367..8b1eda6 100644 --- a/main.cpp +++ b/main.cpp @@ -32,29 +32,37 @@ enum optionIndex { UNKNOWN, HELP ,UML,ERULE ,FICHIER,OUTPUT,INCLUDE - ,PLANG,COMMENT,CODEC,OPTSPLIT,OPTDBG,OPT_END}; + ,PLANG,OPTMODE,COMMENT,CODEC,OPTSPLIT,OPTDBG,OPT_END}; /*----------------------------------------------------------------------------*/ const option::Descriptor usage[] = { {UNKNOWN, 0, "", "", option::Arg::None,"Welcome to asn1p compiler (c) aeb" " 2016-2018 " BUILD_TYPE " " BUILD_VERSION "\n" "Usage asn1p [options]\n\texample:" " asn1p -e ber -f toto.asn1 -I[path]\n"}, - {HELP, 0, "h", "help",option::Arg::None,"--help,-h \tPrint help and quit."}, - {UML, 0, "u", "uml", option::Arg::Optional,"--uml,-u \tGenerate UML model of asn1 model."}, - {ERULE, 0, "e", "ecoding_rule", option::Arg::Required,"--encoding_rule ,-e \t Encoding rules to use" + {HELP, 0, "h", "help", option::Arg::None,"--help,-h \tPrint help and quit."}, + {UML, 0, "u", "uml" , option::Arg::Optional,"--uml,-u \t" + "Generate UML model of asn1 model."}, + {ERULE, 0, "e", "ecoding_rule", option::Arg::Required,"--encoding_rule ,-e \t" + " Encoding rules to use" " accepted ER: ber,per,oer,jer,xer "}, - {FICHIER, 0, "f", "file", option::Arg::Required,"--file,-f \tAsn1 input file to parse"}, - {OUTPUT, 0, "o", "ouput", option::Arg::Required,"--output,-o \toutput file without extension to be generated"}, - {INCLUDE, 0, "I", "include", option::Arg::Required,"--include,-I\tInclude path to look for other asn1 files."}, + {FICHIER, 0, "f", "file", option::Arg::Required,"--file,-f \t" + "Asn1 or Mib input file to parse"}, + {OUTPUT, 0, "o", "ouput", option::Arg::Required,"--output,-o \t" + "output file without extension to be generated"}, + {INCLUDE, 0, "I", "include", option::Arg::Required,"--include,-I\t" + "Include path to look for other asn1 files."}, {PLANG, 0, "l", "language", option::Arg::Required,"--language,-l\t" - "Programming language cpp, uml, javascript, lds, sql [default: cpp]"}, + "Programming language generated: cpp, uml, javascript, lds, sql [default: cpp]"}, + {OPTMODE, 0, "m", "mode", option::Arg::Required,"--mode,-m \t" + "Parsing mode. asn1 or mib. Default is asn1"}, {COMMENT, 0, "n", "comment", option::Arg::Required,"--comment,-n\t" "(true or ON)/(false or OFF) generate comment in source def true"}, {CODEC, 0, "c", "codec", option::Arg::Required,"--codec,-c\tCodecs" " functions ON or OFF [default: OFF]" }, {OPTSPLIT, 0, "s", "split", option::Arg::None,"--split,-s\t" - " put codec code in separated cpp files. Needed for huge definitions" + " put codec code in separated cpp files." + " Needed for huge definitions" }, {OPTDBG, 0, "d", "debug", option::Arg::Required,"--debug,-d\tconsole=1 " " msg=1 debug messages in code parser=<1-8> parser debug traces"}, @@ -96,6 +104,47 @@ struct language_config bool m_c; }; +/** + * Parse option. Return true if found. + * False otherwise + */ +template +bool retrieveOption(option::Option *_opt,T &_arg,const T _default) +{ + bool _ret = false; + _arg = _default; + if (_opt ) + { + for (option::Option *opts = _opt;opts; opts = opts->next()) { + if (opts->arg) + { + _arg = atoi(opts->arg); + _ret = true; + } + } + } + return _ret; +} + +template<> +bool retrieveOption(option::Option *_opt,std::string &_arg,const std::string _default) +{ + bool _ret = false; + _arg = _default; + if (_opt ) + { + for (option::Option *opts = _opt;opts; opts = opts->next()) { + if (opts->arg) + { + _arg = std::string(opts->arg); + _ret = true; + } + } + } + return _ret; +} + + /** * Main entry point @@ -104,6 +153,7 @@ int main(int argc,char **argv) { std::map module_map; std::string umlname; + std::string mode; asn1::parser::iterator it; asn1::parser *p = asn1::parser::instance(); asn1::generator_config g_config; @@ -133,6 +183,11 @@ int main(int argc,char **argv) p->includes().push_back(std::string(opts->arg)); } } + if (retrieveOption(options[OPTMODE],mode,std::string("asn1"))) + { + p->set_mode(mode); + } + if (options[OPTSPLIT]) { g_config.with_split_cpp(true); @@ -154,9 +209,9 @@ int main(int argc,char **argv) { g_config.with_codec(true); } else - { - std::cerr<<"Wrong argument for CODEC"<