From 4035038a041a93a0d6e34d0a4af88479f84dc08d Mon Sep 17 00:00:00 2001 From: Maxim Mamontov Date: Mon, 30 May 2011 18:09:51 +0300 Subject: [PATCH] SNMP Agent plugin added --- .../stargazer/plugins/other/snmp/Makefile | 59 + .../stargazer/plugins/other/snmp/asn1/ANY.c | 158 ++ .../stargazer/plugins/other/snmp/asn1/ANY.h | 48 + .../other/snmp/asn1/ApplicationSyntax.c | 97 ++ .../other/snmp/asn1/ApplicationSyntax.h | 58 + .../plugins/other/snmp/asn1/AtEntry.c | 81 + .../plugins/other/snmp/asn1/AtEntry.h | 41 + .../plugins/other/snmp/asn1/BIT_STRING.c | 188 ++ .../plugins/other/snmp/asn1/BIT_STRING.h | 33 + .../plugins/other/snmp/asn1/BOOLEAN.c | 284 +++ .../plugins/other/snmp/asn1/BOOLEAN.h | 36 + .../plugins/other/snmp/asn1/ClosePDU.c | 111 ++ .../plugins/other/snmp/asn1/ClosePDU.h | 48 + .../plugins/other/snmp/asn1/Counter.c | 134 ++ .../plugins/other/snmp/asn1/Counter.h | 38 + .../plugins/other/snmp/asn1/DisplayString.c | 110 ++ .../plugins/other/snmp/asn1/DisplayString.h | 38 + .../plugins/other/snmp/asn1/EgpNeighEntry.c | 201 +++ .../plugins/other/snmp/asn1/EgpNeighEntry.h | 53 + .../stargazer/plugins/other/snmp/asn1/Gauge.c | 134 ++ .../stargazer/plugins/other/snmp/asn1/Gauge.h | 38 + .../other/snmp/asn1/GetNextRequest-PDU.c | 111 ++ .../other/snmp/asn1/GetNextRequest-PDU.h | 38 + .../plugins/other/snmp/asn1/GetRequest-PDU.c | 111 ++ .../plugins/other/snmp/asn1/GetRequest-PDU.h | 38 + .../plugins/other/snmp/asn1/GetResponse-PDU.c | 111 ++ .../plugins/other/snmp/asn1/GetResponse-PDU.h | 38 + .../plugins/other/snmp/asn1/INTEGER.c | 835 +++++++++ .../plugins/other/snmp/asn1/INTEGER.h | 65 + .../plugins/other/snmp/asn1/IfEntry.c | 271 +++ .../plugins/other/snmp/asn1/IfEntry.h | 64 + .../plugins/other/snmp/asn1/IpAddrEntry.c | 126 ++ .../plugins/other/snmp/asn1/IpAddrEntry.h | 43 + .../plugins/other/snmp/asn1/IpAddress.c | 129 ++ .../plugins/other/snmp/asn1/IpAddress.h | 38 + .../other/snmp/asn1/IpNetToMediaEntry.c | 91 + .../other/snmp/asn1/IpNetToMediaEntry.h | 42 + .../plugins/other/snmp/asn1/IpRouteEntry.c | 181 ++ .../plugins/other/snmp/asn1/IpRouteEntry.h | 51 + .../plugins/other/snmp/asn1/Makefile | 8 + .../plugins/other/snmp/asn1/Message.c | 80 + .../plugins/other/snmp/asn1/Message.h | 46 + .../stargazer/plugins/other/snmp/asn1/NULL.c | 147 ++ .../stargazer/plugins/other/snmp/asn1/NULL.h | 33 + .../other/snmp/asn1/NativeEnumerated.c | 204 +++ .../other/snmp/asn1/NativeEnumerated.h | 32 + .../plugins/other/snmp/asn1/NativeInteger.c | 314 ++++ .../plugins/other/snmp/asn1/NativeInteger.h | 37 + .../plugins/other/snmp/asn1/NetworkAddress.c | 57 + .../plugins/other/snmp/asn1/NetworkAddress.h | 46 + .../other/snmp/asn1/OBJECT_IDENTIFIER.c | 727 ++++++++ .../other/snmp/asn1/OBJECT_IDENTIFIER.h | 139 ++ .../plugins/other/snmp/asn1/OCTET_STRING.c | 1550 +++++++++++++++++ .../plugins/other/snmp/asn1/OCTET_STRING.h | 80 + .../plugins/other/snmp/asn1/ObjectName.c | 110 ++ .../plugins/other/snmp/asn1/ObjectName.h | 38 + .../plugins/other/snmp/asn1/ObjectSyntax.c | 74 + .../plugins/other/snmp/asn1/ObjectSyntax.h | 49 + .../plugins/other/snmp/asn1/Opaque.c | 111 ++ .../plugins/other/snmp/asn1/Opaque.h | 38 + .../plugins/other/snmp/asn1/OpenPDU.c | 57 + .../plugins/other/snmp/asn1/OpenPDU.h | 46 + .../stargazer/plugins/other/snmp/asn1/PDU.c | 91 + .../stargazer/plugins/other/snmp/asn1/PDU.h | 51 + .../stargazer/plugins/other/snmp/asn1/PDUs.c | 97 ++ .../stargazer/plugins/other/snmp/asn1/PDUs.h | 58 + .../plugins/other/snmp/asn1/PhysAddress.c | 110 ++ .../plugins/other/snmp/asn1/PhysAddress.h | 38 + .../plugins/other/snmp/asn1/RFC1155-SMI.asn1 | 135 ++ .../plugins/other/snmp/asn1/RFC1157-SNMP.asn1 | 143 ++ .../plugins/other/snmp/asn1/RFC1213-MIB.asn1 | 339 ++++ .../plugins/other/snmp/asn1/RReqPDU.c | 107 ++ .../plugins/other/snmp/asn1/RReqPDU.h | 48 + .../plugins/other/snmp/asn1/RRspPDU.c | 111 ++ .../plugins/other/snmp/asn1/RRspPDU.h | 43 + .../plugins/other/snmp/asn1/SMUX-PDUs.c | 111 ++ .../plugins/other/snmp/asn1/SMUX-PDUs.h | 61 + .../plugins/other/snmp/asn1/SMUX.asn1 | 122 ++ .../plugins/other/snmp/asn1/SOutPDU.c | 111 ++ .../plugins/other/snmp/asn1/SOutPDU.h | 44 + .../plugins/other/snmp/asn1/SetRequest-PDU.c | 111 ++ .../plugins/other/snmp/asn1/SetRequest-PDU.h | 38 + .../plugins/other/snmp/asn1/SimpleOpen.c | 92 + .../plugins/other/snmp/asn1/SimpleOpen.h | 48 + .../plugins/other/snmp/asn1/SimpleSyntax.c | 87 + .../plugins/other/snmp/asn1/SimpleSyntax.h | 55 + .../plugins/other/snmp/asn1/TcpConnEntry.c | 151 ++ .../plugins/other/snmp/asn1/TcpConnEntry.h | 43 + .../plugins/other/snmp/asn1/TimeTicks.c | 134 ++ .../plugins/other/snmp/asn1/TimeTicks.h | 38 + .../plugins/other/snmp/asn1/Trap-PDU.c | 112 ++ .../plugins/other/snmp/asn1/Trap-PDU.h | 57 + .../plugins/other/snmp/asn1/UdpEntry.c | 96 + .../plugins/other/snmp/asn1/UdpEntry.h | 39 + .../plugins/other/snmp/asn1/VarBind.c | 79 + .../plugins/other/snmp/asn1/VarBind.h | 39 + .../plugins/other/snmp/asn1/VarBindList.c | 54 + .../plugins/other/snmp/asn1/VarBindList.h | 43 + .../plugins/other/snmp/asn1/asn_SEQUENCE_OF.c | 41 + .../plugins/other/snmp/asn1/asn_SEQUENCE_OF.h | 52 + .../plugins/other/snmp/asn1/asn_SET_OF.c | 88 + .../plugins/other/snmp/asn1/asn_SET_OF.h | 62 + .../plugins/other/snmp/asn1/asn_application.h | 47 + .../plugins/other/snmp/asn1/asn_codecs.h | 109 ++ .../plugins/other/snmp/asn1/asn_codecs_prim.c | 295 ++++ .../plugins/other/snmp/asn1/asn_codecs_prim.h | 53 + .../plugins/other/snmp/asn1/asn_internal.h | 111 ++ .../plugins/other/snmp/asn1/asn_system.h | 104 ++ .../plugins/other/snmp/asn1/ber_decoder.c | 283 +++ .../plugins/other/snmp/asn1/ber_decoder.h | 63 + .../plugins/other/snmp/asn1/ber_tlv_length.c | 178 ++ .../plugins/other/snmp/asn1/ber_tlv_length.h | 50 + .../plugins/other/snmp/asn1/ber_tlv_tag.c | 144 ++ .../plugins/other/snmp/asn1/ber_tlv_tag.h | 60 + .../plugins/other/snmp/asn1/constr_CHOICE.c | 1101 ++++++++++++ .../plugins/other/snmp/asn1/constr_CHOICE.h | 57 + .../plugins/other/snmp/asn1/constr_SEQUENCE.c | 1251 +++++++++++++ .../plugins/other/snmp/asn1/constr_SEQUENCE.h | 60 + .../other/snmp/asn1/constr_SEQUENCE_OF.c | 208 +++ .../other/snmp/asn1/constr_SEQUENCE_OF.h | 33 + .../plugins/other/snmp/asn1/constr_SET_OF.c | 942 ++++++++++ .../plugins/other/snmp/asn1/constr_SET_OF.h | 42 + .../plugins/other/snmp/asn1/constr_TYPE.c | 77 + .../plugins/other/snmp/asn1/constr_TYPE.h | 180 ++ .../plugins/other/snmp/asn1/constraints.c | 93 + .../plugins/other/snmp/asn1/constraints.h | 63 + .../other/snmp/asn1/converter-sample.c | 725 ++++++++ .../plugins/other/snmp/asn1/der_encoder.c | 199 +++ .../plugins/other/snmp/asn1/der_encoder.h | 67 + .../plugins/other/snmp/asn1/per_decoder.c | 55 + .../plugins/other/snmp/asn1/per_decoder.h | 44 + .../plugins/other/snmp/asn1/per_encoder.c | 95 + .../plugins/other/snmp/asn1/per_encoder.h | 49 + .../plugins/other/snmp/asn1/per_support.c | 318 ++++ .../plugins/other/snmp/asn1/per_support.h | 105 ++ .../plugins/other/snmp/asn1/xer_decoder.c | 363 ++++ .../plugins/other/snmp/asn1/xer_decoder.h | 106 ++ .../plugins/other/snmp/asn1/xer_encoder.c | 67 + .../plugins/other/snmp/asn1/xer_encoder.h | 59 + .../plugins/other/snmp/asn1/xer_support.c | 233 +++ .../plugins/other/snmp/asn1/xer_support.h | 55 + .../stargazer/plugins/other/snmp/snmp.cpp | 0 142 files changed, 19917 insertions(+) create mode 100644 projects/stargazer/plugins/other/snmp/Makefile create mode 100644 projects/stargazer/plugins/other/snmp/asn1/ANY.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/ANY.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/ApplicationSyntax.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/ApplicationSyntax.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/AtEntry.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/AtEntry.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/BIT_STRING.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/BIT_STRING.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/BOOLEAN.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/BOOLEAN.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/ClosePDU.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/ClosePDU.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/Counter.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/Counter.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/DisplayString.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/DisplayString.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/EgpNeighEntry.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/EgpNeighEntry.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/Gauge.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/Gauge.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/GetNextRequest-PDU.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/GetNextRequest-PDU.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/GetRequest-PDU.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/GetRequest-PDU.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/GetResponse-PDU.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/GetResponse-PDU.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/INTEGER.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/INTEGER.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/IfEntry.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/IfEntry.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/IpAddrEntry.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/IpAddrEntry.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/IpAddress.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/IpAddress.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/IpNetToMediaEntry.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/IpNetToMediaEntry.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/IpRouteEntry.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/IpRouteEntry.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/Makefile create mode 100644 projects/stargazer/plugins/other/snmp/asn1/Message.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/Message.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/NULL.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/NULL.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/NativeEnumerated.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/NativeEnumerated.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/NativeInteger.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/NativeInteger.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/NetworkAddress.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/NetworkAddress.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/OBJECT_IDENTIFIER.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/OBJECT_IDENTIFIER.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/OCTET_STRING.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/OCTET_STRING.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/ObjectName.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/ObjectName.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/ObjectSyntax.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/ObjectSyntax.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/Opaque.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/Opaque.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/OpenPDU.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/OpenPDU.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/PDU.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/PDU.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/PDUs.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/PDUs.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/PhysAddress.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/PhysAddress.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/RFC1155-SMI.asn1 create mode 100644 projects/stargazer/plugins/other/snmp/asn1/RFC1157-SNMP.asn1 create mode 100644 projects/stargazer/plugins/other/snmp/asn1/RFC1213-MIB.asn1 create mode 100644 projects/stargazer/plugins/other/snmp/asn1/RReqPDU.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/RReqPDU.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/RRspPDU.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/RRspPDU.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/SMUX-PDUs.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/SMUX-PDUs.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/SMUX.asn1 create mode 100644 projects/stargazer/plugins/other/snmp/asn1/SOutPDU.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/SOutPDU.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/SetRequest-PDU.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/SetRequest-PDU.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/SimpleOpen.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/SimpleOpen.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/SimpleSyntax.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/SimpleSyntax.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/TcpConnEntry.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/TcpConnEntry.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/TimeTicks.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/TimeTicks.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/Trap-PDU.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/Trap-PDU.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/UdpEntry.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/UdpEntry.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/VarBind.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/VarBind.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/VarBindList.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/VarBindList.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/asn_SEQUENCE_OF.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/asn_SEQUENCE_OF.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/asn_SET_OF.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/asn_SET_OF.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/asn_application.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/asn_codecs.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/asn_codecs_prim.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/asn_codecs_prim.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/asn_internal.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/asn_system.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/ber_decoder.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/ber_decoder.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/ber_tlv_length.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/ber_tlv_length.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/ber_tlv_tag.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/ber_tlv_tag.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/constr_CHOICE.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/constr_CHOICE.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/constr_SEQUENCE.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/constr_SEQUENCE.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/constr_SEQUENCE_OF.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/constr_SEQUENCE_OF.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/constr_SET_OF.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/constr_SET_OF.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/constr_TYPE.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/constr_TYPE.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/constraints.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/constraints.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/converter-sample.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/der_encoder.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/der_encoder.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/per_decoder.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/per_decoder.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/per_encoder.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/per_encoder.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/per_support.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/per_support.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/xer_decoder.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/xer_decoder.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/xer_encoder.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/xer_encoder.h create mode 100644 projects/stargazer/plugins/other/snmp/asn1/xer_support.c create mode 100644 projects/stargazer/plugins/other/snmp/asn1/xer_support.h create mode 100644 projects/stargazer/plugins/other/snmp/snmp.cpp diff --git a/projects/stargazer/plugins/other/snmp/Makefile b/projects/stargazer/plugins/other/snmp/Makefile new file mode 100644 index 00000000..2f6eeb74 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/Makefile @@ -0,0 +1,59 @@ +############################################################################### +# $Id: Makefile,v 1.11 2008/12/04 17:21:14 faust Exp $ +############################################################################### + +include ../../../../../Makefile.conf + +LIBS += $(LIB_THREAD) + +PROG = mod_snmp_agent.so + +SRCS = snmp.cpp \ + asn1/DisplayString.c \ + asn1/PhysAddress.c \ + asn1/IfEntry.c \ + asn1/AtEntry.c \ + asn1/IpAddrEntry.c \ + asn1/IpRouteEntry.c \ + asn1/IpNetToMediaEntry.c \ + asn1/TcpConnEntry.c \ + asn1/UdpEntry.c \ + asn1/EgpNeighEntry.c \ + asn1/ObjectName.c \ + asn1/ObjectSyntax.c \ + asn1/SimpleSyntax.c \ + asn1/ApplicationSyntax.c \ + asn1/NetworkAddress.c \ + asn1/IpAddress.c \ + asn1/Counter.c \ + asn1/Gauge.c \ + asn1/TimeTicks.c \ + asn1/Opaque.c \ + asn1/Message.c \ + asn1/PDUs.c \ + asn1/GetRequest-PDU.c \ + asn1/GetNextRequest-PDU.c \ + asn1/GetResponse-PDU.c \ + asn1/SetRequest-PDU.c \ + asn1/PDU.c \ + asn1/Trap-PDU.c \ + asn1/VarBind.c \ + asn1/VarBindList.c \ + asn1/SMUX-PDUs.c \ + asn1/OpenPDU.c \ + asn1/SimpleOpen.c \ + asn1/ClosePDU.c \ + asn1/RReqPDU.c \ + asn1/RRspPDU.c \ + asn1/SOutPDU.c + +STGLIBS = -lstgcommon + +CXXFLAGS += -Iasn1 + +include ../../Makefile.in + +.PHONY: asn1 + +asn1: + $(MAKE) -C asn1 asn1 diff --git a/projects/stargazer/plugins/other/snmp/asn1/ANY.c b/projects/stargazer/plugins/other/snmp/asn1/ANY.c new file mode 100644 index 00000000..612238b6 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/ANY.c @@ -0,0 +1,158 @@ +/*- + * Copyright (c) 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include +#include + +static asn_OCTET_STRING_specifics_t asn_DEF_ANY_specs = { + sizeof(ANY_t), + offsetof(ANY_t, _asn_ctx), + 2 /* Special indicator that this is an ANY type */ +}; +asn_TYPE_descriptor_t asn_DEF_ANY = { + "ANY", + "ANY", + OCTET_STRING_free, + OCTET_STRING_print, + asn_generic_no_constraint, + OCTET_STRING_decode_ber, + OCTET_STRING_encode_der, + OCTET_STRING_decode_xer_hex, + ANY_encode_xer, + 0, 0, + 0, /* Use generic outmost tag fetcher */ + 0, 0, 0, 0, + 0, /* No PER visible constraints */ + 0, 0, /* No members */ + &asn_DEF_ANY_specs, +}; + + +asn_enc_rval_t +ANY_encode_xer(asn_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + + if(flags & XER_F_CANONICAL) { + /* + * Canonical XER-encoding of ANY type is not supported. + */ + _ASN_ENCODE_FAILED; + } + + /* Dump as binary */ + return OCTET_STRING_encode_xer(td, sptr, ilevel, flags, cb, app_key); +} + +struct _callback_arg { + uint8_t *buffer; + size_t offset; + size_t size; +}; + +static int ANY__consume_bytes(const void *buffer, size_t size, void *key); + +int +ANY_fromType(ANY_t *st, asn_TYPE_descriptor_t *td, void *sptr) { + struct _callback_arg arg; + asn_enc_rval_t erval; + + if(!st || !td) { + errno = EINVAL; + return -1; + } + + if(!sptr) { + if(st->buf) FREEMEM(st->buf); + st->size = 0; + return 0; + } + + arg.offset = arg.size = 0; + arg.buffer = 0; + + erval = der_encode(td, sptr, ANY__consume_bytes, &arg); + if(erval.encoded == -1) { + if(arg.buffer) FREEMEM(arg.buffer); + return -1; + } + assert((size_t)erval.encoded == arg.offset); + + if(st->buf) FREEMEM(st->buf); + st->buf = arg.buffer; + st->size = arg.offset; + + return 0; +} + +ANY_t * +ANY_new_fromType(asn_TYPE_descriptor_t *td, void *sptr) { + ANY_t tmp; + ANY_t *st; + + if(!td || !sptr) { + errno = EINVAL; + return 0; + } + + memset(&tmp, 0, sizeof(tmp)); + + if(ANY_fromType(&tmp, td, sptr)) return 0; + + st = (ANY_t *)CALLOC(1, sizeof(ANY_t)); + if(st) { + *st = tmp; + return st; + } else { + FREEMEM(tmp.buf); + return 0; + } +} + +int +ANY_to_type(ANY_t *st, asn_TYPE_descriptor_t *td, void **struct_ptr) { + asn_dec_rval_t rval; + void *newst = 0; + + if(!st || !td || !struct_ptr) { + errno = EINVAL; + return -1; + } + + if(st->buf == 0) { + /* Nothing to convert, make it empty. */ + *struct_ptr = (void *)0; + return 0; + } + + rval = ber_decode(0, td, (void **)&newst, st->buf, st->size); + if(rval.code == RC_OK) { + *struct_ptr = newst; + return 0; + } else { + /* Remove possibly partially decoded data. */ + ASN_STRUCT_FREE(*td, newst); + return -1; + } +} + +static int ANY__consume_bytes(const void *buffer, size_t size, void *key) { + struct _callback_arg *arg = (struct _callback_arg *)key; + + if((arg->offset + size) >= arg->size) { + size_t nsize = (arg->size ? arg->size << 2 : 16) + size; + void *p = REALLOC(arg->buffer, nsize); + if(!p) return -1; + arg->buffer = (uint8_t *)p; + arg->size = nsize; + } + + memcpy(arg->buffer + arg->offset, buffer, size); + arg->offset += size; + assert(arg->offset < arg->size); + + return 0; +} + diff --git a/projects/stargazer/plugins/other/snmp/asn1/ANY.h b/projects/stargazer/plugins/other/snmp/asn1/ANY.h new file mode 100644 index 00000000..b7d92fa9 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/ANY.h @@ -0,0 +1,48 @@ +/*- + * Copyright (c) 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef ASN_TYPE_ANY_H +#define ASN_TYPE_ANY_H + +#include /* Implemented via OCTET STRING type */ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct ANY { + uint8_t *buf; /* BER-encoded ANY contents */ + int size; /* Size of the above buffer */ + + asn_struct_ctx_t _asn_ctx; /* Parsing across buffer boundaries */ +} ANY_t; + +extern asn_TYPE_descriptor_t asn_DEF_ANY; + +asn_struct_free_f ANY_free; +asn_struct_print_f ANY_print; +ber_type_decoder_f ANY_decode_ber; +der_type_encoder_f ANY_encode_der; +xer_type_encoder_f ANY_encode_xer; + +/****************************** + * Handy conversion routines. * + ******************************/ + +/* Convert another ASN.1 type into the ANY. This implies DER encoding. */ +int ANY_fromType(ANY_t *, asn_TYPE_descriptor_t *td, void *struct_ptr); +ANY_t *ANY_new_fromType(asn_TYPE_descriptor_t *td, void *struct_ptr); + +/* Convert the contents of the ANY type into the specified type. */ +int ANY_to_type(ANY_t *, asn_TYPE_descriptor_t *td, void **struct_ptr); + +#define ANY_fromBuf(s, buf, size) OCTET_STRING_fromBuf((s), (buf), (size)) +#define ANY_new_fromBuf(buf, size) OCTET_STRING_new_fromBuf( \ + &asn_DEF_ANY, (buf), (size)) + +#ifdef __cplusplus +} +#endif + +#endif /* ASN_TYPE_ANY_H */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/ApplicationSyntax.c b/projects/stargazer/plugins/other/snmp/asn1/ApplicationSyntax.c new file mode 100644 index 00000000..a4f97e2c --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/ApplicationSyntax.c @@ -0,0 +1,97 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "ApplicationSyntax.h" + +static asn_TYPE_member_t asn_MBR_ApplicationSyntax_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct ApplicationSyntax, choice.address), + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_NetworkAddress, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "address" + }, + { ATF_NOFLAGS, 0, offsetof(struct ApplicationSyntax, choice.counter), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "counter" + }, + { ATF_NOFLAGS, 0, offsetof(struct ApplicationSyntax, choice.gauge), + (ASN_TAG_CLASS_APPLICATION | (2 << 2)), + 0, + &asn_DEF_Gauge, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "gauge" + }, + { ATF_NOFLAGS, 0, offsetof(struct ApplicationSyntax, choice.ticks), + (ASN_TAG_CLASS_APPLICATION | (3 << 2)), + 0, + &asn_DEF_TimeTicks, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ticks" + }, + { ATF_NOFLAGS, 0, offsetof(struct ApplicationSyntax, choice.arbitrary), + (ASN_TAG_CLASS_APPLICATION | (4 << 2)), + 0, + &asn_DEF_Opaque, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "arbitrary" + }, +}; +static asn_TYPE_tag2member_t asn_MAP_ApplicationSyntax_tag2el_1[] = { + { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 0, 0, 0 }, /* internet at 113 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 1, 0, 0 }, /* counter at 91 */ + { (ASN_TAG_CLASS_APPLICATION | (2 << 2)), 2, 0, 0 }, /* gauge at 94 */ + { (ASN_TAG_CLASS_APPLICATION | (3 << 2)), 3, 0, 0 }, /* ticks at 97 */ + { (ASN_TAG_CLASS_APPLICATION | (4 << 2)), 4, 0, 0 } /* arbitrary at 104 */ +}; +static asn_CHOICE_specifics_t asn_SPC_ApplicationSyntax_specs_1 = { + sizeof(struct ApplicationSyntax), + offsetof(struct ApplicationSyntax, _asn_ctx), + offsetof(struct ApplicationSyntax, present), + sizeof(((struct ApplicationSyntax *)0)->present), + asn_MAP_ApplicationSyntax_tag2el_1, + 5, /* Count of tags in the map */ + 0, + -1 /* Extensions start */ +}; +asn_TYPE_descriptor_t asn_DEF_ApplicationSyntax = { + "ApplicationSyntax", + "ApplicationSyntax", + CHOICE_free, + CHOICE_print, + CHOICE_constraint, + CHOICE_decode_ber, + CHOICE_encode_der, + CHOICE_decode_xer, + CHOICE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + CHOICE_outmost_tag, + 0, /* No effective tags (pointer) */ + 0, /* No effective tags (count) */ + 0, /* No tags (pointer) */ + 0, /* No tags (count) */ + 0, /* No PER visible constraints */ + asn_MBR_ApplicationSyntax_1, + 5, /* Elements count */ + &asn_SPC_ApplicationSyntax_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/ApplicationSyntax.h b/projects/stargazer/plugins/other/snmp/asn1/ApplicationSyntax.h new file mode 100644 index 00000000..90a87076 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/ApplicationSyntax.h @@ -0,0 +1,58 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _ApplicationSyntax_H_ +#define _ApplicationSyntax_H_ + + +#include + +/* Including external dependencies */ +#include "NetworkAddress.h" +#include "Counter.h" +#include "Gauge.h" +#include "TimeTicks.h" +#include "Opaque.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum ApplicationSyntax_PR { + ApplicationSyntax_PR_NOTHING, /* No components present */ + ApplicationSyntax_PR_address, + ApplicationSyntax_PR_counter, + ApplicationSyntax_PR_gauge, + ApplicationSyntax_PR_ticks, + ApplicationSyntax_PR_arbitrary +} ApplicationSyntax_PR; + +/* ApplicationSyntax */ +typedef struct ApplicationSyntax { + ApplicationSyntax_PR present; + union ApplicationSyntax_u { + NetworkAddress_t address; + Counter_t counter; + Gauge_t gauge; + TimeTicks_t ticks; + Opaque_t arbitrary; + } choice; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} ApplicationSyntax_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_ApplicationSyntax; + +#ifdef __cplusplus +} +#endif + +#endif /* _ApplicationSyntax_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/AtEntry.c b/projects/stargazer/plugins/other/snmp/asn1/AtEntry.c new file mode 100644 index 00000000..bf3b9ba9 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/AtEntry.c @@ -0,0 +1,81 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "AtEntry.h" + +static asn_TYPE_member_t asn_MBR_AtEntry_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct AtEntry, atIfIndex), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "atIfIndex" + }, + { ATF_NOFLAGS, 0, offsetof(struct AtEntry, atPhysAddress), + (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), + 0, + &asn_DEF_PhysAddress, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "atPhysAddress" + }, + { ATF_NOFLAGS, 0, offsetof(struct AtEntry, atNetAddress), + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_NetworkAddress, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "atNetAddress" + }, +}; +static ber_tlv_tag_t asn_DEF_AtEntry_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_AtEntry_tag2el_1[] = { + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* atIfIndex at 154 */ + { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 1, 0, 0 }, /* atPhysAddress at 157 */ + { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 2, 0, 0 } /* internet at 113 */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_AtEntry_specs_1 = { + sizeof(struct AtEntry), + offsetof(struct AtEntry, _asn_ctx), + asn_MAP_AtEntry_tag2el_1, + 3, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* Start extensions */ + -1 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_AtEntry = { + "AtEntry", + "AtEntry", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_AtEntry_tags_1, + sizeof(asn_DEF_AtEntry_tags_1) + /sizeof(asn_DEF_AtEntry_tags_1[0]), /* 1 */ + asn_DEF_AtEntry_tags_1, /* Same as above */ + sizeof(asn_DEF_AtEntry_tags_1) + /sizeof(asn_DEF_AtEntry_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_AtEntry_1, + 3, /* Elements count */ + &asn_SPC_AtEntry_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/AtEntry.h b/projects/stargazer/plugins/other/snmp/asn1/AtEntry.h new file mode 100644 index 00000000..a0aba105 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/AtEntry.h @@ -0,0 +1,41 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _AtEntry_H_ +#define _AtEntry_H_ + + +#include + +/* Including external dependencies */ +#include +#include "PhysAddress.h" +#include "NetworkAddress.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* AtEntry */ +typedef struct AtEntry { + INTEGER_t atIfIndex; + PhysAddress_t atPhysAddress; + NetworkAddress_t atNetAddress; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} AtEntry_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_AtEntry; + +#ifdef __cplusplus +} +#endif + +#endif /* _AtEntry_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/BIT_STRING.c b/projects/stargazer/plugins/other/snmp/asn1/BIT_STRING.c new file mode 100644 index 00000000..6469d4fd --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/BIT_STRING.c @@ -0,0 +1,188 @@ +/*- + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include +#include + +/* + * BIT STRING basic type description. + */ +static ber_tlv_tag_t asn_DEF_BIT_STRING_tags[] = { + (ASN_TAG_CLASS_UNIVERSAL | (3 << 2)) +}; +static asn_OCTET_STRING_specifics_t asn_DEF_BIT_STRING_specs = { + sizeof(BIT_STRING_t), + offsetof(BIT_STRING_t, _asn_ctx), + 1, /* Special indicator that this is a BIT STRING type */ +}; +asn_TYPE_descriptor_t asn_DEF_BIT_STRING = { + "BIT STRING", + "BIT_STRING", + OCTET_STRING_free, /* Implemented in terms of OCTET STRING */ + BIT_STRING_print, + BIT_STRING_constraint, + OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */ + OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */ + OCTET_STRING_decode_xer_binary, + BIT_STRING_encode_xer, + OCTET_STRING_decode_uper, /* Unaligned PER decoder */ + OCTET_STRING_encode_uper, /* Unaligned PER encoder */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_BIT_STRING_tags, + sizeof(asn_DEF_BIT_STRING_tags) + / sizeof(asn_DEF_BIT_STRING_tags[0]), + asn_DEF_BIT_STRING_tags, /* Same as above */ + sizeof(asn_DEF_BIT_STRING_tags) + / sizeof(asn_DEF_BIT_STRING_tags[0]), + 0, /* No PER visible constraints */ + 0, 0, /* No members */ + &asn_DEF_BIT_STRING_specs +}; + +/* + * BIT STRING generic constraint. + */ +int +BIT_STRING_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + const BIT_STRING_t *st = (const BIT_STRING_t *)sptr; + + if(st && st->buf) { + if(st->size == 1 && st->bits_unused) { + _ASN_CTFAIL(app_key, td, + "%s: invalid padding byte (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + } else { + _ASN_CTFAIL(app_key, td, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + return 0; +} + +static char *_bit_pattern[16] = { + "0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", + "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111" +}; + +asn_enc_rval_t +BIT_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + asn_enc_rval_t er; + char scratch[128]; + char *p = scratch; + char *scend = scratch + (sizeof(scratch) - 10); + const BIT_STRING_t *st = (const BIT_STRING_t *)sptr; + int xcan = (flags & XER_F_CANONICAL); + uint8_t *buf; + uint8_t *end; + + if(!st || !st->buf) + _ASN_ENCODE_FAILED; + + er.encoded = 0; + + buf = st->buf; + end = buf + st->size - 1; /* Last byte is special */ + + /* + * Binary dump + */ + for(; buf < end; buf++) { + int v = *buf; + int nline = xcan?0:(((buf - st->buf) % 8) == 0); + if(p >= scend || nline) { + er.encoded += p - scratch; + _ASN_CALLBACK(scratch, p - scratch); + p = scratch; + if(nline) _i_ASN_TEXT_INDENT(1, ilevel); + } + memcpy(p + 0, _bit_pattern[v >> 4], 4); + memcpy(p + 4, _bit_pattern[v & 0x0f], 4); + p += 8; + } + + if(!xcan && ((buf - st->buf) % 8) == 0) + _i_ASN_TEXT_INDENT(1, ilevel); + er.encoded += p - scratch; + _ASN_CALLBACK(scratch, p - scratch); + p = scratch; + + if(buf == end) { + int v = *buf; + int ubits = st->bits_unused; + int i; + for(i = 7; i >= ubits; i--) + *p++ = (v & (1 << i)) ? 0x31 : 0x30; + er.encoded += p - scratch; + _ASN_CALLBACK(scratch, p - scratch); + } + + if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel - 1); + + _ASN_ENCODED_OK(er); +cb_failed: + _ASN_ENCODE_FAILED; +} + + +/* + * BIT STRING specific contents printer. + */ +int +BIT_STRING_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel, + asn_app_consume_bytes_f *cb, void *app_key) { + static const char *h2c = "0123456789ABCDEF"; + char scratch[64]; + const BIT_STRING_t *st = (const BIT_STRING_t *)sptr; + uint8_t *buf; + uint8_t *end; + char *p = scratch; + + (void)td; /* Unused argument */ + + if(!st || !st->buf) + return (cb("", 8, app_key) < 0) ? -1 : 0; + + ilevel++; + buf = st->buf; + end = buf + st->size; + + /* + * Hexadecimal dump. + */ + for(; buf < end; buf++) { + if((buf - st->buf) % 16 == 0 && (st->size > 16) + && buf != st->buf) { + _i_INDENT(1); + /* Dump the string */ + if(cb(scratch, p - scratch, app_key) < 0) return -1; + p = scratch; + } + *p++ = h2c[*buf >> 4]; + *p++ = h2c[*buf & 0x0F]; + *p++ = 0x20; + } + + if(p > scratch) { + p--; /* Eat the tailing space */ + + if((st->size > 16)) { + _i_INDENT(1); + } + + /* Dump the incomplete 16-bytes row */ + if(cb(scratch, p - scratch, app_key) < 0) + return -1; + } + + return 0; +} + diff --git a/projects/stargazer/plugins/other/snmp/asn1/BIT_STRING.h b/projects/stargazer/plugins/other/snmp/asn1/BIT_STRING.h new file mode 100644 index 00000000..732e878b --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/BIT_STRING.h @@ -0,0 +1,33 @@ +/*- + * Copyright (c) 2003 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _BIT_STRING_H_ +#define _BIT_STRING_H_ + +#include /* Some help from OCTET STRING */ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct BIT_STRING_s { + uint8_t *buf; /* BIT STRING body */ + int size; /* Size of the above buffer */ + + int bits_unused;/* Unused trailing bits in the last octet (0..7) */ + + asn_struct_ctx_t _asn_ctx; /* Parsing across buffer boundaries */ +} BIT_STRING_t; + +extern asn_TYPE_descriptor_t asn_DEF_BIT_STRING; + +asn_struct_print_f BIT_STRING_print; /* Human-readable output */ +asn_constr_check_f BIT_STRING_constraint; +xer_type_encoder_f BIT_STRING_encode_xer; + +#ifdef __cplusplus +} +#endif + +#endif /* _BIT_STRING_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/BOOLEAN.c b/projects/stargazer/plugins/other/snmp/asn1/BOOLEAN.c new file mode 100644 index 00000000..bb4697c2 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/BOOLEAN.c @@ -0,0 +1,284 @@ +/*- + * Copyright (c) 2003, 2005 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include +#include + +/* + * BOOLEAN basic type description. + */ +static ber_tlv_tag_t asn_DEF_BOOLEAN_tags[] = { + (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_BOOLEAN = { + "BOOLEAN", + "BOOLEAN", + BOOLEAN_free, + BOOLEAN_print, + asn_generic_no_constraint, + BOOLEAN_decode_ber, + BOOLEAN_encode_der, + BOOLEAN_decode_xer, + BOOLEAN_encode_xer, + BOOLEAN_decode_uper, /* Unaligned PER decoder */ + BOOLEAN_encode_uper, /* Unaligned PER encoder */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_BOOLEAN_tags, + sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]), + asn_DEF_BOOLEAN_tags, /* Same as above */ + sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]), + 0, /* No PER visible constraints */ + 0, 0, /* No members */ + 0 /* No specifics */ +}; + +/* + * Decode BOOLEAN type. + */ +asn_dec_rval_t +BOOLEAN_decode_ber(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *td, + void **bool_value, const void *buf_ptr, size_t size, + int tag_mode) { + BOOLEAN_t *st = (BOOLEAN_t *)*bool_value; + asn_dec_rval_t rval; + ber_tlv_len_t length; + ber_tlv_len_t lidx; + + if(st == NULL) { + st = (BOOLEAN_t *)(*bool_value = CALLOC(1, sizeof(*st))); + if(st == NULL) { + rval.code = RC_FAIL; + rval.consumed = 0; + return rval; + } + } + + ASN_DEBUG("Decoding %s as BOOLEAN (tm=%d)", + td->name, tag_mode); + + /* + * Check tags. + */ + rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size, + tag_mode, 0, &length, 0); + if(rval.code != RC_OK) + return rval; + + ASN_DEBUG("Boolean length is %d bytes", (int)length); + + buf_ptr = ((const char *)buf_ptr) + rval.consumed; + size -= rval.consumed; + if(length > (ber_tlv_len_t)size) { + rval.code = RC_WMORE; + rval.consumed = 0; + return rval; + } + + /* + * Compute boolean value. + */ + for(*st = 0, lidx = 0; + (lidx < length) && *st == 0; lidx++) { + /* + * Very simple approach: read bytes until the end or + * value is already TRUE. + * BOOLEAN is not supposed to contain meaningful data anyway. + */ + *st |= ((const uint8_t *)buf_ptr)[lidx]; + } + + rval.code = RC_OK; + rval.consumed += length; + + ASN_DEBUG("Took %ld/%ld bytes to encode %s, value=%d", + (long)rval.consumed, (long)length, + td->name, *st); + + return rval; +} + +asn_enc_rval_t +BOOLEAN_encode_der(asn_TYPE_descriptor_t *td, void *sptr, + int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + asn_enc_rval_t erval; + BOOLEAN_t *st = (BOOLEAN_t *)sptr; + + erval.encoded = der_write_tags(td, 1, tag_mode, 0, tag, cb, app_key); + if(erval.encoded == -1) { + erval.failed_type = td; + erval.structure_ptr = sptr; + return erval; + } + + if(cb) { + uint8_t bool_value; + + bool_value = *st ? 0xff : 0; /* 0xff mandated by DER */ + + if(cb(&bool_value, 1, app_key) < 0) { + erval.encoded = -1; + erval.failed_type = td; + erval.structure_ptr = sptr; + return erval; + } + } + + erval.encoded += 1; + + _ASN_ENCODED_OK(erval); +} + + +/* + * Decode the chunk of XML text encoding INTEGER. + */ +static enum xer_pbd_rval +BOOLEAN__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) { + BOOLEAN_t *st = (BOOLEAN_t *)sptr; + const char *p = (const char *)chunk_buf; + + (void)td; + + if(chunk_size && p[0] == 0x3c /* '<' */) { + switch(xer_check_tag(chunk_buf, chunk_size, "false")) { + case XCT_BOTH: + /* "" */ + *st = 0; + break; + case XCT_UNKNOWN_BO: + if(xer_check_tag(chunk_buf, chunk_size, "true") + != XCT_BOTH) + return XPBD_BROKEN_ENCODING; + /* "" */ + *st = 1; /* Or 0xff as in DER?.. */ + break; + default: + return XPBD_BROKEN_ENCODING; + } + return XPBD_BODY_CONSUMED; + } else { + if(xer_is_whitespace(chunk_buf, chunk_size)) + return XPBD_NOT_BODY_IGNORE; + else + return XPBD_BROKEN_ENCODING; + } +} + + +asn_dec_rval_t +BOOLEAN_decode_xer(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname, + const void *buf_ptr, size_t size) { + + return xer_decode_primitive(opt_codec_ctx, td, + sptr, sizeof(BOOLEAN_t), opt_mname, buf_ptr, size, + BOOLEAN__xer_body_decode); +} + +asn_enc_rval_t +BOOLEAN_encode_xer(asn_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + const BOOLEAN_t *st = (const BOOLEAN_t *)sptr; + asn_enc_rval_t er; + + (void)ilevel; + (void)flags; + + if(!st) _ASN_ENCODE_FAILED; + + if(*st) { + _ASN_CALLBACK("", 7); + er.encoded = 7; + } else { + _ASN_CALLBACK("", 8); + er.encoded = 8; + } + + _ASN_ENCODED_OK(er); +cb_failed: + _ASN_ENCODE_FAILED; +} + +int +BOOLEAN_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel, + asn_app_consume_bytes_f *cb, void *app_key) { + const BOOLEAN_t *st = (const BOOLEAN_t *)sptr; + const char *buf; + size_t buflen; + + (void)td; /* Unused argument */ + (void)ilevel; /* Unused argument */ + + if(st) { + if(*st) { + buf = "TRUE"; + buflen = 4; + } else { + buf = "FALSE"; + buflen = 5; + } + } else { + buf = ""; + buflen = 8; + } + + return (cb(buf, buflen, app_key) < 0) ? -1 : 0; +} + +void +BOOLEAN_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) { + if(td && ptr && !contents_only) { + FREEMEM(ptr); + } +} + +asn_dec_rval_t +BOOLEAN_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) { + asn_dec_rval_t rv; + BOOLEAN_t *st = (BOOLEAN_t *)*sptr; + + (void)opt_codec_ctx; + (void)constraints; + + if(!st) { + st = (BOOLEAN_t *)(*sptr = MALLOC(sizeof(*st))); + if(!st) _ASN_DECODE_FAILED; + } + + /* + * Extract a single bit + */ + switch(per_get_few_bits(pd, 1)) { + case 1: *st = 1; break; + case 0: *st = 0; break; + case -1: default: _ASN_DECODE_FAILED; + } + + ASN_DEBUG("%s decoded as %s", td->name, *st ? "TRUE" : "FALSE"); + + rv.code = RC_OK; + rv.consumed = 1; + return rv; +} + + +asn_enc_rval_t +BOOLEAN_encode_uper(asn_TYPE_descriptor_t *td, + asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) { + const BOOLEAN_t *st = (const BOOLEAN_t *)sptr; + asn_enc_rval_t er; + + (void)constraints; + + if(!st) _ASN_ENCODE_FAILED; + + per_put_few_bits(po, *st ? 1 : 0, 1); + + _ASN_ENCODED_OK(er); +} diff --git a/projects/stargazer/plugins/other/snmp/asn1/BOOLEAN.h b/projects/stargazer/plugins/other/snmp/asn1/BOOLEAN.h new file mode 100644 index 00000000..217d0f16 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/BOOLEAN.h @@ -0,0 +1,36 @@ +/*- + * Copyright (c) 2003 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _BOOLEAN_H_ +#define _BOOLEAN_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * The underlying integer may contain various values, but everything + * non-zero is capped to 0xff by the DER encoder. The BER decoder may + * yield non-zero values different from 1, beware. + */ +typedef int BOOLEAN_t; + +extern asn_TYPE_descriptor_t asn_DEF_BOOLEAN; + +asn_struct_free_f BOOLEAN_free; +asn_struct_print_f BOOLEAN_print; +ber_type_decoder_f BOOLEAN_decode_ber; +der_type_encoder_f BOOLEAN_encode_der; +xer_type_decoder_f BOOLEAN_decode_xer; +xer_type_encoder_f BOOLEAN_encode_xer; +per_type_decoder_f BOOLEAN_decode_uper; +per_type_encoder_f BOOLEAN_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _BOOLEAN_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/ClosePDU.c b/projects/stargazer/plugins/other/snmp/asn1/ClosePDU.c new file mode 100644 index 00000000..a97e3b45 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/ClosePDU.c @@ -0,0 +1,111 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "SMUX" + * found in "SMUX.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "ClosePDU.h" + +int +ClosePDU_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + /* Replace with underlying type checker */ + td->check_constraints = asn_DEF_INTEGER.check_constraints; + return td->check_constraints(td, sptr, ctfailcb, app_key); +} + +/* + * This type is implemented using INTEGER, + * so here we adjust the DEF accordingly. + */ +static void +ClosePDU_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { + td->free_struct = asn_DEF_INTEGER.free_struct; + td->print_struct = asn_DEF_INTEGER.print_struct; + td->ber_decoder = asn_DEF_INTEGER.ber_decoder; + td->der_encoder = asn_DEF_INTEGER.der_encoder; + td->xer_decoder = asn_DEF_INTEGER.xer_decoder; + td->xer_encoder = asn_DEF_INTEGER.xer_encoder; + td->uper_decoder = asn_DEF_INTEGER.uper_decoder; + td->uper_encoder = asn_DEF_INTEGER.uper_encoder; + if(!td->per_constraints) + td->per_constraints = asn_DEF_INTEGER.per_constraints; + td->elements = asn_DEF_INTEGER.elements; + td->elements_count = asn_DEF_INTEGER.elements_count; + td->specifics = asn_DEF_INTEGER.specifics; +} + +void +ClosePDU_free(asn_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + ClosePDU_1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +ClosePDU_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + ClosePDU_1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + +asn_dec_rval_t +ClosePDU_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const void *bufptr, size_t size, int tag_mode) { + ClosePDU_1_inherit_TYPE_descriptor(td); + return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); +} + +asn_enc_rval_t +ClosePDU_encode_der(asn_TYPE_descriptor_t *td, + void *structure, int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + ClosePDU_1_inherit_TYPE_descriptor(td); + return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); +} + +asn_dec_rval_t +ClosePDU_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const char *opt_mname, const void *bufptr, size_t size) { + ClosePDU_1_inherit_TYPE_descriptor(td); + return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); +} + +asn_enc_rval_t +ClosePDU_encode_xer(asn_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + ClosePDU_1_inherit_TYPE_descriptor(td); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); +} + +static ber_tlv_tag_t asn_DEF_ClosePDU_tags_1[] = { + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_ClosePDU = { + "ClosePDU", + "ClosePDU", + ClosePDU_free, + ClosePDU_print, + ClosePDU_constraint, + ClosePDU_decode_ber, + ClosePDU_encode_der, + ClosePDU_decode_xer, + ClosePDU_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_ClosePDU_tags_1, + sizeof(asn_DEF_ClosePDU_tags_1) + /sizeof(asn_DEF_ClosePDU_tags_1[0]) - 1, /* 1 */ + asn_DEF_ClosePDU_tags_1, /* Same as above */ + sizeof(asn_DEF_ClosePDU_tags_1) + /sizeof(asn_DEF_ClosePDU_tags_1[0]), /* 2 */ + 0, /* No PER visible constraints */ + 0, 0, /* Defined elsewhere */ + 0 /* No specifics */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/ClosePDU.h b/projects/stargazer/plugins/other/snmp/asn1/ClosePDU.h new file mode 100644 index 00000000..a3d1e7a9 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/ClosePDU.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "SMUX" + * found in "SMUX.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _ClosePDU_H_ +#define _ClosePDU_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum ClosePDU { + ClosePDU_goingDown = 0, + ClosePDU_unsupportedVersion = 1, + ClosePDU_packetFormat = 2, + ClosePDU_protocolError = 3, + ClosePDU_internalError = 4, + ClosePDU_authenticationFailure = 5 +} e_ClosePDU; + +/* ClosePDU */ +typedef INTEGER_t ClosePDU_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_ClosePDU; +asn_struct_free_f ClosePDU_free; +asn_struct_print_f ClosePDU_print; +asn_constr_check_f ClosePDU_constraint; +ber_type_decoder_f ClosePDU_decode_ber; +der_type_encoder_f ClosePDU_encode_der; +xer_type_decoder_f ClosePDU_decode_xer; +xer_type_encoder_f ClosePDU_encode_xer; + +#ifdef __cplusplus +} +#endif + +#endif /* _ClosePDU_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/Counter.c b/projects/stargazer/plugins/other/snmp/asn1/Counter.c new file mode 100644 index 00000000..c2389fdb --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/Counter.c @@ -0,0 +1,134 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "Counter.h" + +int +Counter_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + const INTEGER_t *st = (const INTEGER_t *)sptr; + long value; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + if(asn_INTEGER2long(st, &value)) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value too large (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + if((value >= 0 && value <= 4294967295)) { + /* Constraint check succeeded */ + return 0; + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +/* + * This type is implemented using INTEGER, + * so here we adjust the DEF accordingly. + */ +static void +Counter_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { + td->free_struct = asn_DEF_INTEGER.free_struct; + td->print_struct = asn_DEF_INTEGER.print_struct; + td->ber_decoder = asn_DEF_INTEGER.ber_decoder; + td->der_encoder = asn_DEF_INTEGER.der_encoder; + td->xer_decoder = asn_DEF_INTEGER.xer_decoder; + td->xer_encoder = asn_DEF_INTEGER.xer_encoder; + td->uper_decoder = asn_DEF_INTEGER.uper_decoder; + td->uper_encoder = asn_DEF_INTEGER.uper_encoder; + if(!td->per_constraints) + td->per_constraints = asn_DEF_INTEGER.per_constraints; + td->elements = asn_DEF_INTEGER.elements; + td->elements_count = asn_DEF_INTEGER.elements_count; + td->specifics = asn_DEF_INTEGER.specifics; +} + +void +Counter_free(asn_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Counter_1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Counter_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Counter_1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + +asn_dec_rval_t +Counter_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const void *bufptr, size_t size, int tag_mode) { + Counter_1_inherit_TYPE_descriptor(td); + return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); +} + +asn_enc_rval_t +Counter_encode_der(asn_TYPE_descriptor_t *td, + void *structure, int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + Counter_1_inherit_TYPE_descriptor(td); + return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); +} + +asn_dec_rval_t +Counter_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const char *opt_mname, const void *bufptr, size_t size) { + Counter_1_inherit_TYPE_descriptor(td); + return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); +} + +asn_enc_rval_t +Counter_encode_xer(asn_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + Counter_1_inherit_TYPE_descriptor(td); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); +} + +static ber_tlv_tag_t asn_DEF_Counter_tags_1[] = { + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_Counter = { + "Counter", + "Counter", + Counter_free, + Counter_print, + Counter_constraint, + Counter_decode_ber, + Counter_encode_der, + Counter_decode_xer, + Counter_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_Counter_tags_1, + sizeof(asn_DEF_Counter_tags_1) + /sizeof(asn_DEF_Counter_tags_1[0]) - 1, /* 1 */ + asn_DEF_Counter_tags_1, /* Same as above */ + sizeof(asn_DEF_Counter_tags_1) + /sizeof(asn_DEF_Counter_tags_1[0]), /* 2 */ + 0, /* No PER visible constraints */ + 0, 0, /* No members */ + 0 /* No specifics */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/Counter.h b/projects/stargazer/plugins/other/snmp/asn1/Counter.h new file mode 100644 index 00000000..3c770ada --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/Counter.h @@ -0,0 +1,38 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _Counter_H_ +#define _Counter_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Counter */ +typedef INTEGER_t Counter_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_Counter; +asn_struct_free_f Counter_free; +asn_struct_print_f Counter_print; +asn_constr_check_f Counter_constraint; +ber_type_decoder_f Counter_decode_ber; +der_type_encoder_f Counter_encode_der; +xer_type_decoder_f Counter_decode_xer; +xer_type_encoder_f Counter_encode_xer; + +#ifdef __cplusplus +} +#endif + +#endif /* _Counter_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/DisplayString.c b/projects/stargazer/plugins/other/snmp/asn1/DisplayString.c new file mode 100644 index 00000000..f3c57405 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/DisplayString.c @@ -0,0 +1,110 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "DisplayString.h" + +int +DisplayString_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + /* Replace with underlying type checker */ + td->check_constraints = asn_DEF_OCTET_STRING.check_constraints; + return td->check_constraints(td, sptr, ctfailcb, app_key); +} + +/* + * This type is implemented using OCTET_STRING, + * so here we adjust the DEF accordingly. + */ +static void +DisplayString_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { + td->free_struct = asn_DEF_OCTET_STRING.free_struct; + td->print_struct = asn_DEF_OCTET_STRING.print_struct; + td->ber_decoder = asn_DEF_OCTET_STRING.ber_decoder; + td->der_encoder = asn_DEF_OCTET_STRING.der_encoder; + td->xer_decoder = asn_DEF_OCTET_STRING.xer_decoder; + td->xer_encoder = asn_DEF_OCTET_STRING.xer_encoder; + td->uper_decoder = asn_DEF_OCTET_STRING.uper_decoder; + td->uper_encoder = asn_DEF_OCTET_STRING.uper_encoder; + if(!td->per_constraints) + td->per_constraints = asn_DEF_OCTET_STRING.per_constraints; + td->elements = asn_DEF_OCTET_STRING.elements; + td->elements_count = asn_DEF_OCTET_STRING.elements_count; + td->specifics = asn_DEF_OCTET_STRING.specifics; +} + +void +DisplayString_free(asn_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + DisplayString_1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +DisplayString_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + DisplayString_1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + +asn_dec_rval_t +DisplayString_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const void *bufptr, size_t size, int tag_mode) { + DisplayString_1_inherit_TYPE_descriptor(td); + return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); +} + +asn_enc_rval_t +DisplayString_encode_der(asn_TYPE_descriptor_t *td, + void *structure, int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + DisplayString_1_inherit_TYPE_descriptor(td); + return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); +} + +asn_dec_rval_t +DisplayString_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const char *opt_mname, const void *bufptr, size_t size) { + DisplayString_1_inherit_TYPE_descriptor(td); + return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); +} + +asn_enc_rval_t +DisplayString_encode_xer(asn_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + DisplayString_1_inherit_TYPE_descriptor(td); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); +} + +static ber_tlv_tag_t asn_DEF_DisplayString_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_DisplayString = { + "DisplayString", + "DisplayString", + DisplayString_free, + DisplayString_print, + DisplayString_constraint, + DisplayString_decode_ber, + DisplayString_encode_der, + DisplayString_decode_xer, + DisplayString_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_DisplayString_tags_1, + sizeof(asn_DEF_DisplayString_tags_1) + /sizeof(asn_DEF_DisplayString_tags_1[0]), /* 1 */ + asn_DEF_DisplayString_tags_1, /* Same as above */ + sizeof(asn_DEF_DisplayString_tags_1) + /sizeof(asn_DEF_DisplayString_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + 0, 0, /* No members */ + 0 /* No specifics */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/DisplayString.h b/projects/stargazer/plugins/other/snmp/asn1/DisplayString.h new file mode 100644 index 00000000..ac6862c2 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/DisplayString.h @@ -0,0 +1,38 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _DisplayString_H_ +#define _DisplayString_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* DisplayString */ +typedef OCTET_STRING_t DisplayString_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_DisplayString; +asn_struct_free_f DisplayString_free; +asn_struct_print_f DisplayString_print; +asn_constr_check_f DisplayString_constraint; +ber_type_decoder_f DisplayString_decode_ber; +der_type_encoder_f DisplayString_encode_der; +xer_type_decoder_f DisplayString_decode_xer; +xer_type_encoder_f DisplayString_encode_xer; + +#ifdef __cplusplus +} +#endif + +#endif /* _DisplayString_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/EgpNeighEntry.c b/projects/stargazer/plugins/other/snmp/asn1/EgpNeighEntry.c new file mode 100644 index 00000000..07c28afa --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/EgpNeighEntry.c @@ -0,0 +1,201 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "EgpNeighEntry.h" + +static asn_TYPE_member_t asn_MBR_EgpNeighEntry_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighState), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "egpNeighState" + }, + { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighAddr), + (ASN_TAG_CLASS_APPLICATION | (0 << 2)), + 0, + &asn_DEF_IpAddress, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "egpNeighAddr" + }, + { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighAs), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "egpNeighAs" + }, + { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighInMsgs), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "egpNeighInMsgs" + }, + { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighInErrs), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "egpNeighInErrs" + }, + { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighOutMsgs), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "egpNeighOutMsgs" + }, + { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighOutErrs), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "egpNeighOutErrs" + }, + { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighInErrMsgs), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "egpNeighInErrMsgs" + }, + { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighOutErrMsgs), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "egpNeighOutErrMsgs" + }, + { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighStateUps), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "egpNeighStateUps" + }, + { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighStateDowns), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "egpNeighStateDowns" + }, + { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighIntervalHello), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "egpNeighIntervalHello" + }, + { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighIntervalPoll), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "egpNeighIntervalPoll" + }, + { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighMode), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "egpNeighMode" + }, + { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighEventTrigger), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "egpNeighEventTrigger" + }, +}; +static ber_tlv_tag_t asn_DEF_EgpNeighEntry_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_EgpNeighEntry_tag2el_1[] = { + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 5 }, /* egpNeighState at 267 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, -1, 4 }, /* egpNeighAs at 271 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 11, -2, 3 }, /* egpNeighIntervalHello at 290 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 12, -3, 2 }, /* egpNeighIntervalPoll at 292 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 13, -4, 1 }, /* egpNeighMode at 294 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 14, -5, 0 }, /* egpNeighEventTrigger at 297 */ + { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 1, 0, 0 }, /* egpNeighAddr at 269 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 3, 0, 7 }, /* egpNeighInMsgs at 273 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 4, -1, 6 }, /* egpNeighInErrs at 275 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 5, -2, 5 }, /* egpNeighOutMsgs at 277 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 6, -3, 4 }, /* egpNeighOutErrs at 279 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 7, -4, 3 }, /* egpNeighInErrMsgs at 282 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 8, -5, 2 }, /* egpNeighOutErrMsgs at 284 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 9, -6, 1 }, /* egpNeighStateUps at 286 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 10, -7, 0 } /* egpNeighStateDowns at 288 */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_EgpNeighEntry_specs_1 = { + sizeof(struct EgpNeighEntry), + offsetof(struct EgpNeighEntry, _asn_ctx), + asn_MAP_EgpNeighEntry_tag2el_1, + 15, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* Start extensions */ + -1 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_EgpNeighEntry = { + "EgpNeighEntry", + "EgpNeighEntry", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_EgpNeighEntry_tags_1, + sizeof(asn_DEF_EgpNeighEntry_tags_1) + /sizeof(asn_DEF_EgpNeighEntry_tags_1[0]), /* 1 */ + asn_DEF_EgpNeighEntry_tags_1, /* Same as above */ + sizeof(asn_DEF_EgpNeighEntry_tags_1) + /sizeof(asn_DEF_EgpNeighEntry_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_EgpNeighEntry_1, + 15, /* Elements count */ + &asn_SPC_EgpNeighEntry_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/EgpNeighEntry.h b/projects/stargazer/plugins/other/snmp/asn1/EgpNeighEntry.h new file mode 100644 index 00000000..79d3eedd --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/EgpNeighEntry.h @@ -0,0 +1,53 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _EgpNeighEntry_H_ +#define _EgpNeighEntry_H_ + + +#include + +/* Including external dependencies */ +#include +#include "IpAddress.h" +#include "Counter.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* EgpNeighEntry */ +typedef struct EgpNeighEntry { + INTEGER_t egpNeighState; + IpAddress_t egpNeighAddr; + INTEGER_t egpNeighAs; + Counter_t egpNeighInMsgs; + Counter_t egpNeighInErrs; + Counter_t egpNeighOutMsgs; + Counter_t egpNeighOutErrs; + Counter_t egpNeighInErrMsgs; + Counter_t egpNeighOutErrMsgs; + Counter_t egpNeighStateUps; + Counter_t egpNeighStateDowns; + INTEGER_t egpNeighIntervalHello; + INTEGER_t egpNeighIntervalPoll; + INTEGER_t egpNeighMode; + INTEGER_t egpNeighEventTrigger; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} EgpNeighEntry_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_EgpNeighEntry; + +#ifdef __cplusplus +} +#endif + +#endif /* _EgpNeighEntry_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/Gauge.c b/projects/stargazer/plugins/other/snmp/asn1/Gauge.c new file mode 100644 index 00000000..190b91f4 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/Gauge.c @@ -0,0 +1,134 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "Gauge.h" + +int +Gauge_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + const INTEGER_t *st = (const INTEGER_t *)sptr; + long value; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + if(asn_INTEGER2long(st, &value)) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value too large (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + if((value >= 0 && value <= 4294967295)) { + /* Constraint check succeeded */ + return 0; + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +/* + * This type is implemented using INTEGER, + * so here we adjust the DEF accordingly. + */ +static void +Gauge_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { + td->free_struct = asn_DEF_INTEGER.free_struct; + td->print_struct = asn_DEF_INTEGER.print_struct; + td->ber_decoder = asn_DEF_INTEGER.ber_decoder; + td->der_encoder = asn_DEF_INTEGER.der_encoder; + td->xer_decoder = asn_DEF_INTEGER.xer_decoder; + td->xer_encoder = asn_DEF_INTEGER.xer_encoder; + td->uper_decoder = asn_DEF_INTEGER.uper_decoder; + td->uper_encoder = asn_DEF_INTEGER.uper_encoder; + if(!td->per_constraints) + td->per_constraints = asn_DEF_INTEGER.per_constraints; + td->elements = asn_DEF_INTEGER.elements; + td->elements_count = asn_DEF_INTEGER.elements_count; + td->specifics = asn_DEF_INTEGER.specifics; +} + +void +Gauge_free(asn_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Gauge_1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Gauge_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Gauge_1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + +asn_dec_rval_t +Gauge_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const void *bufptr, size_t size, int tag_mode) { + Gauge_1_inherit_TYPE_descriptor(td); + return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); +} + +asn_enc_rval_t +Gauge_encode_der(asn_TYPE_descriptor_t *td, + void *structure, int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + Gauge_1_inherit_TYPE_descriptor(td); + return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); +} + +asn_dec_rval_t +Gauge_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const char *opt_mname, const void *bufptr, size_t size) { + Gauge_1_inherit_TYPE_descriptor(td); + return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); +} + +asn_enc_rval_t +Gauge_encode_xer(asn_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + Gauge_1_inherit_TYPE_descriptor(td); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); +} + +static ber_tlv_tag_t asn_DEF_Gauge_tags_1[] = { + (ASN_TAG_CLASS_APPLICATION | (2 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_Gauge = { + "Gauge", + "Gauge", + Gauge_free, + Gauge_print, + Gauge_constraint, + Gauge_decode_ber, + Gauge_encode_der, + Gauge_decode_xer, + Gauge_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_Gauge_tags_1, + sizeof(asn_DEF_Gauge_tags_1) + /sizeof(asn_DEF_Gauge_tags_1[0]) - 1, /* 1 */ + asn_DEF_Gauge_tags_1, /* Same as above */ + sizeof(asn_DEF_Gauge_tags_1) + /sizeof(asn_DEF_Gauge_tags_1[0]), /* 2 */ + 0, /* No PER visible constraints */ + 0, 0, /* No members */ + 0 /* No specifics */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/Gauge.h b/projects/stargazer/plugins/other/snmp/asn1/Gauge.h new file mode 100644 index 00000000..f3e17c5e --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/Gauge.h @@ -0,0 +1,38 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _Gauge_H_ +#define _Gauge_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Gauge */ +typedef INTEGER_t Gauge_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_Gauge; +asn_struct_free_f Gauge_free; +asn_struct_print_f Gauge_print; +asn_constr_check_f Gauge_constraint; +ber_type_decoder_f Gauge_decode_ber; +der_type_encoder_f Gauge_encode_der; +xer_type_decoder_f Gauge_decode_xer; +xer_type_encoder_f Gauge_encode_xer; + +#ifdef __cplusplus +} +#endif + +#endif /* _Gauge_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/GetNextRequest-PDU.c b/projects/stargazer/plugins/other/snmp/asn1/GetNextRequest-PDU.c new file mode 100644 index 00000000..4ba345e5 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/GetNextRequest-PDU.c @@ -0,0 +1,111 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "GetNextRequest-PDU.h" + +int +GetNextRequest_PDU_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + /* Replace with underlying type checker */ + td->check_constraints = asn_DEF_PDU.check_constraints; + return td->check_constraints(td, sptr, ctfailcb, app_key); +} + +/* + * This type is implemented using PDU, + * so here we adjust the DEF accordingly. + */ +static void +GetNextRequest_PDU_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { + td->free_struct = asn_DEF_PDU.free_struct; + td->print_struct = asn_DEF_PDU.print_struct; + td->ber_decoder = asn_DEF_PDU.ber_decoder; + td->der_encoder = asn_DEF_PDU.der_encoder; + td->xer_decoder = asn_DEF_PDU.xer_decoder; + td->xer_encoder = asn_DEF_PDU.xer_encoder; + td->uper_decoder = asn_DEF_PDU.uper_decoder; + td->uper_encoder = asn_DEF_PDU.uper_encoder; + if(!td->per_constraints) + td->per_constraints = asn_DEF_PDU.per_constraints; + td->elements = asn_DEF_PDU.elements; + td->elements_count = asn_DEF_PDU.elements_count; + td->specifics = asn_DEF_PDU.specifics; +} + +void +GetNextRequest_PDU_free(asn_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + GetNextRequest_PDU_1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +GetNextRequest_PDU_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + GetNextRequest_PDU_1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + +asn_dec_rval_t +GetNextRequest_PDU_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const void *bufptr, size_t size, int tag_mode) { + GetNextRequest_PDU_1_inherit_TYPE_descriptor(td); + return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); +} + +asn_enc_rval_t +GetNextRequest_PDU_encode_der(asn_TYPE_descriptor_t *td, + void *structure, int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + GetNextRequest_PDU_1_inherit_TYPE_descriptor(td); + return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); +} + +asn_dec_rval_t +GetNextRequest_PDU_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const char *opt_mname, const void *bufptr, size_t size) { + GetNextRequest_PDU_1_inherit_TYPE_descriptor(td); + return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); +} + +asn_enc_rval_t +GetNextRequest_PDU_encode_xer(asn_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + GetNextRequest_PDU_1_inherit_TYPE_descriptor(td); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); +} + +static ber_tlv_tag_t asn_DEF_GetNextRequest_PDU_tags_1[] = { + (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_GetNextRequest_PDU = { + "GetNextRequest-PDU", + "GetNextRequest-PDU", + GetNextRequest_PDU_free, + GetNextRequest_PDU_print, + GetNextRequest_PDU_constraint, + GetNextRequest_PDU_decode_ber, + GetNextRequest_PDU_encode_der, + GetNextRequest_PDU_decode_xer, + GetNextRequest_PDU_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_GetNextRequest_PDU_tags_1, + sizeof(asn_DEF_GetNextRequest_PDU_tags_1) + /sizeof(asn_DEF_GetNextRequest_PDU_tags_1[0]) - 1, /* 1 */ + asn_DEF_GetNextRequest_PDU_tags_1, /* Same as above */ + sizeof(asn_DEF_GetNextRequest_PDU_tags_1) + /sizeof(asn_DEF_GetNextRequest_PDU_tags_1[0]), /* 2 */ + 0, /* No PER visible constraints */ + 0, 0, /* Defined elsewhere */ + 0 /* No specifics */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/GetNextRequest-PDU.h b/projects/stargazer/plugins/other/snmp/asn1/GetNextRequest-PDU.h new file mode 100644 index 00000000..f9298ec6 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/GetNextRequest-PDU.h @@ -0,0 +1,38 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _GetNextRequest_PDU_H_ +#define _GetNextRequest_PDU_H_ + + +#include + +/* Including external dependencies */ +#include "PDU.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* GetNextRequest-PDU */ +typedef PDU_t GetNextRequest_PDU_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_GetNextRequest_PDU; +asn_struct_free_f GetNextRequest_PDU_free; +asn_struct_print_f GetNextRequest_PDU_print; +asn_constr_check_f GetNextRequest_PDU_constraint; +ber_type_decoder_f GetNextRequest_PDU_decode_ber; +der_type_encoder_f GetNextRequest_PDU_encode_der; +xer_type_decoder_f GetNextRequest_PDU_decode_xer; +xer_type_encoder_f GetNextRequest_PDU_encode_xer; + +#ifdef __cplusplus +} +#endif + +#endif /* _GetNextRequest_PDU_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/GetRequest-PDU.c b/projects/stargazer/plugins/other/snmp/asn1/GetRequest-PDU.c new file mode 100644 index 00000000..41edc371 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/GetRequest-PDU.c @@ -0,0 +1,111 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "GetRequest-PDU.h" + +int +GetRequest_PDU_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + /* Replace with underlying type checker */ + td->check_constraints = asn_DEF_PDU.check_constraints; + return td->check_constraints(td, sptr, ctfailcb, app_key); +} + +/* + * This type is implemented using PDU, + * so here we adjust the DEF accordingly. + */ +static void +GetRequest_PDU_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { + td->free_struct = asn_DEF_PDU.free_struct; + td->print_struct = asn_DEF_PDU.print_struct; + td->ber_decoder = asn_DEF_PDU.ber_decoder; + td->der_encoder = asn_DEF_PDU.der_encoder; + td->xer_decoder = asn_DEF_PDU.xer_decoder; + td->xer_encoder = asn_DEF_PDU.xer_encoder; + td->uper_decoder = asn_DEF_PDU.uper_decoder; + td->uper_encoder = asn_DEF_PDU.uper_encoder; + if(!td->per_constraints) + td->per_constraints = asn_DEF_PDU.per_constraints; + td->elements = asn_DEF_PDU.elements; + td->elements_count = asn_DEF_PDU.elements_count; + td->specifics = asn_DEF_PDU.specifics; +} + +void +GetRequest_PDU_free(asn_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + GetRequest_PDU_1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +GetRequest_PDU_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + GetRequest_PDU_1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + +asn_dec_rval_t +GetRequest_PDU_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const void *bufptr, size_t size, int tag_mode) { + GetRequest_PDU_1_inherit_TYPE_descriptor(td); + return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); +} + +asn_enc_rval_t +GetRequest_PDU_encode_der(asn_TYPE_descriptor_t *td, + void *structure, int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + GetRequest_PDU_1_inherit_TYPE_descriptor(td); + return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); +} + +asn_dec_rval_t +GetRequest_PDU_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const char *opt_mname, const void *bufptr, size_t size) { + GetRequest_PDU_1_inherit_TYPE_descriptor(td); + return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); +} + +asn_enc_rval_t +GetRequest_PDU_encode_xer(asn_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + GetRequest_PDU_1_inherit_TYPE_descriptor(td); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); +} + +static ber_tlv_tag_t asn_DEF_GetRequest_PDU_tags_1[] = { + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_GetRequest_PDU = { + "GetRequest-PDU", + "GetRequest-PDU", + GetRequest_PDU_free, + GetRequest_PDU_print, + GetRequest_PDU_constraint, + GetRequest_PDU_decode_ber, + GetRequest_PDU_encode_der, + GetRequest_PDU_decode_xer, + GetRequest_PDU_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_GetRequest_PDU_tags_1, + sizeof(asn_DEF_GetRequest_PDU_tags_1) + /sizeof(asn_DEF_GetRequest_PDU_tags_1[0]) - 1, /* 1 */ + asn_DEF_GetRequest_PDU_tags_1, /* Same as above */ + sizeof(asn_DEF_GetRequest_PDU_tags_1) + /sizeof(asn_DEF_GetRequest_PDU_tags_1[0]), /* 2 */ + 0, /* No PER visible constraints */ + 0, 0, /* Defined elsewhere */ + 0 /* No specifics */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/GetRequest-PDU.h b/projects/stargazer/plugins/other/snmp/asn1/GetRequest-PDU.h new file mode 100644 index 00000000..9449451f --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/GetRequest-PDU.h @@ -0,0 +1,38 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _GetRequest_PDU_H_ +#define _GetRequest_PDU_H_ + + +#include + +/* Including external dependencies */ +#include "PDU.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* GetRequest-PDU */ +typedef PDU_t GetRequest_PDU_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_GetRequest_PDU; +asn_struct_free_f GetRequest_PDU_free; +asn_struct_print_f GetRequest_PDU_print; +asn_constr_check_f GetRequest_PDU_constraint; +ber_type_decoder_f GetRequest_PDU_decode_ber; +der_type_encoder_f GetRequest_PDU_encode_der; +xer_type_decoder_f GetRequest_PDU_decode_xer; +xer_type_encoder_f GetRequest_PDU_encode_xer; + +#ifdef __cplusplus +} +#endif + +#endif /* _GetRequest_PDU_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/GetResponse-PDU.c b/projects/stargazer/plugins/other/snmp/asn1/GetResponse-PDU.c new file mode 100644 index 00000000..6dcc845c --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/GetResponse-PDU.c @@ -0,0 +1,111 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "GetResponse-PDU.h" + +int +GetResponse_PDU_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + /* Replace with underlying type checker */ + td->check_constraints = asn_DEF_PDU.check_constraints; + return td->check_constraints(td, sptr, ctfailcb, app_key); +} + +/* + * This type is implemented using PDU, + * so here we adjust the DEF accordingly. + */ +static void +GetResponse_PDU_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { + td->free_struct = asn_DEF_PDU.free_struct; + td->print_struct = asn_DEF_PDU.print_struct; + td->ber_decoder = asn_DEF_PDU.ber_decoder; + td->der_encoder = asn_DEF_PDU.der_encoder; + td->xer_decoder = asn_DEF_PDU.xer_decoder; + td->xer_encoder = asn_DEF_PDU.xer_encoder; + td->uper_decoder = asn_DEF_PDU.uper_decoder; + td->uper_encoder = asn_DEF_PDU.uper_encoder; + if(!td->per_constraints) + td->per_constraints = asn_DEF_PDU.per_constraints; + td->elements = asn_DEF_PDU.elements; + td->elements_count = asn_DEF_PDU.elements_count; + td->specifics = asn_DEF_PDU.specifics; +} + +void +GetResponse_PDU_free(asn_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + GetResponse_PDU_1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +GetResponse_PDU_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + GetResponse_PDU_1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + +asn_dec_rval_t +GetResponse_PDU_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const void *bufptr, size_t size, int tag_mode) { + GetResponse_PDU_1_inherit_TYPE_descriptor(td); + return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); +} + +asn_enc_rval_t +GetResponse_PDU_encode_der(asn_TYPE_descriptor_t *td, + void *structure, int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + GetResponse_PDU_1_inherit_TYPE_descriptor(td); + return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); +} + +asn_dec_rval_t +GetResponse_PDU_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const char *opt_mname, const void *bufptr, size_t size) { + GetResponse_PDU_1_inherit_TYPE_descriptor(td); + return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); +} + +asn_enc_rval_t +GetResponse_PDU_encode_xer(asn_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + GetResponse_PDU_1_inherit_TYPE_descriptor(td); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); +} + +static ber_tlv_tag_t asn_DEF_GetResponse_PDU_tags_1[] = { + (ASN_TAG_CLASS_CONTEXT | (2 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_GetResponse_PDU = { + "GetResponse-PDU", + "GetResponse-PDU", + GetResponse_PDU_free, + GetResponse_PDU_print, + GetResponse_PDU_constraint, + GetResponse_PDU_decode_ber, + GetResponse_PDU_encode_der, + GetResponse_PDU_decode_xer, + GetResponse_PDU_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_GetResponse_PDU_tags_1, + sizeof(asn_DEF_GetResponse_PDU_tags_1) + /sizeof(asn_DEF_GetResponse_PDU_tags_1[0]) - 1, /* 1 */ + asn_DEF_GetResponse_PDU_tags_1, /* Same as above */ + sizeof(asn_DEF_GetResponse_PDU_tags_1) + /sizeof(asn_DEF_GetResponse_PDU_tags_1[0]), /* 2 */ + 0, /* No PER visible constraints */ + 0, 0, /* Defined elsewhere */ + 0 /* No specifics */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/GetResponse-PDU.h b/projects/stargazer/plugins/other/snmp/asn1/GetResponse-PDU.h new file mode 100644 index 00000000..12e3fba1 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/GetResponse-PDU.h @@ -0,0 +1,38 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _GetResponse_PDU_H_ +#define _GetResponse_PDU_H_ + + +#include + +/* Including external dependencies */ +#include "PDU.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* GetResponse-PDU */ +typedef PDU_t GetResponse_PDU_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_GetResponse_PDU; +asn_struct_free_f GetResponse_PDU_free; +asn_struct_print_f GetResponse_PDU_print; +asn_constr_check_f GetResponse_PDU_constraint; +ber_type_decoder_f GetResponse_PDU_decode_ber; +der_type_encoder_f GetResponse_PDU_encode_der; +xer_type_decoder_f GetResponse_PDU_decode_xer; +xer_type_encoder_f GetResponse_PDU_encode_xer; + +#ifdef __cplusplus +} +#endif + +#endif /* _GetResponse_PDU_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/INTEGER.c b/projects/stargazer/plugins/other/snmp/asn1/INTEGER.c new file mode 100644 index 00000000..9c8b9ed3 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/INTEGER.c @@ -0,0 +1,835 @@ +/*- + * Copyright (c) 2003, 2004, 2005, 2006 Lev Walkin . + * All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include +#include /* Encoder and decoder of a primitive type */ +#include + +/* + * INTEGER basic type description. + */ +static ber_tlv_tag_t asn_DEF_INTEGER_tags[] = { + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_INTEGER = { + "INTEGER", + "INTEGER", + ASN__PRIMITIVE_TYPE_free, + INTEGER_print, + asn_generic_no_constraint, + ber_decode_primitive, + INTEGER_encode_der, + INTEGER_decode_xer, + INTEGER_encode_xer, + INTEGER_decode_uper, /* Unaligned PER decoder */ + INTEGER_encode_uper, /* Unaligned PER encoder */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_INTEGER_tags, + sizeof(asn_DEF_INTEGER_tags) / sizeof(asn_DEF_INTEGER_tags[0]), + asn_DEF_INTEGER_tags, /* Same as above */ + sizeof(asn_DEF_INTEGER_tags) / sizeof(asn_DEF_INTEGER_tags[0]), + 0, /* No PER visible constraints */ + 0, 0, /* No members */ + 0 /* No specifics */ +}; + +/* + * Encode INTEGER type using DER. + */ +asn_enc_rval_t +INTEGER_encode_der(asn_TYPE_descriptor_t *td, void *sptr, + int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + INTEGER_t *st = (INTEGER_t *)sptr; + + ASN_DEBUG("%s %s as INTEGER (tm=%d)", + cb?"Encoding":"Estimating", td->name, tag_mode); + + /* + * Canonicalize integer in the buffer. + * (Remove too long sign extension, remove some first 0x00 bytes) + */ + if(st->buf) { + uint8_t *buf = st->buf; + uint8_t *end1 = buf + st->size - 1; + int shift; + + /* Compute the number of superfluous leading bytes */ + for(; buf < end1; buf++) { + /* + * If the contents octets of an integer value encoding + * consist of more than one octet, then the bits of the + * first octet and bit 8 of the second octet: + * a) shall not all be ones; and + * b) shall not all be zero. + */ + switch(*buf) { + case 0x00: if((buf[1] & 0x80) == 0) + continue; + break; + case 0xff: if((buf[1] & 0x80)) + continue; + break; + } + break; + } + + /* Remove leading superfluous bytes from the integer */ + shift = buf - st->buf; + if(shift) { + uint8_t *nb = st->buf; + uint8_t *end; + + st->size -= shift; /* New size, minus bad bytes */ + end = nb + st->size; + + for(; nb < end; nb++, buf++) + *nb = *buf; + } + + } /* if(1) */ + + return der_encode_primitive(td, sptr, tag_mode, tag, cb, app_key); +} + +static const asn_INTEGER_enum_map_t *INTEGER_map_enum2value(asn_INTEGER_specifics_t *specs, const char *lstart, const char *lstop); + +/* + * INTEGER specific human-readable output. + */ +static ssize_t +INTEGER__dump(asn_TYPE_descriptor_t *td, const INTEGER_t *st, asn_app_consume_bytes_f *cb, void *app_key, int plainOrXER) { + asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics; + char scratch[32]; /* Enough for 64-bit integer */ + uint8_t *buf = st->buf; + uint8_t *buf_end = st->buf + st->size; + signed long accum; + ssize_t wrote = 0; + char *p; + int ret; + + /* + * Advance buf pointer until the start of the value's body. + * This will make us able to process large integers using simple case, + * when the actual value is small + * (0x0000000000abcdef would yield a fine 0x00abcdef) + */ + /* Skip the insignificant leading bytes */ + for(; buf < buf_end-1; buf++) { + switch(*buf) { + case 0x00: if((buf[1] & 0x80) == 0) continue; break; + case 0xff: if((buf[1] & 0x80) != 0) continue; break; + } + break; + } + + /* Simple case: the integer size is small */ + if((size_t)(buf_end - buf) <= sizeof(accum)) { + const asn_INTEGER_enum_map_t *el; + size_t scrsize; + char *scr; + + if(buf == buf_end) { + accum = 0; + } else { + accum = (*buf & 0x80) ? -1 : 0; + for(; buf < buf_end; buf++) + accum = (accum << 8) | *buf; + } + + el = INTEGER_map_value2enum(specs, accum); + if(el) { + scrsize = el->enum_len + 32; + scr = (char *)alloca(scrsize); + if(plainOrXER == 0) + ret = snprintf(scr, scrsize, + "%ld (%s)", accum, el->enum_name); + else + ret = snprintf(scr, scrsize, + "<%s/>", el->enum_name); + } else if(plainOrXER && specs && specs->strict_enumeration) { + ASN_DEBUG("ASN.1 forbids dealing with " + "unknown value of ENUMERATED type"); + errno = EPERM; + return -1; + } else { + scrsize = sizeof(scratch); + scr = scratch; + ret = snprintf(scr, scrsize, "%ld", accum); + } + assert(ret > 0 && (size_t)ret < scrsize); + return (cb(scr, ret, app_key) < 0) ? -1 : ret; + } else if(plainOrXER && specs && specs->strict_enumeration) { + /* + * Here and earlier, we cannot encode the ENUMERATED values + * if there is no corresponding identifier. + */ + ASN_DEBUG("ASN.1 forbids dealing with " + "unknown value of ENUMERATED type"); + errno = EPERM; + return -1; + } + + /* Output in the long xx:yy:zz... format */ + /* TODO: replace with generic algorithm (Knuth TAOCP Vol 2, 4.3.1) */ + for(p = scratch; buf < buf_end; buf++) { + static const char *h2c = "0123456789ABCDEF"; + if((p - scratch) >= (ssize_t)(sizeof(scratch) - 4)) { + /* Flush buffer */ + if(cb(scratch, p - scratch, app_key) < 0) + return -1; + wrote += p - scratch; + p = scratch; + } + *p++ = h2c[*buf >> 4]; + *p++ = h2c[*buf & 0x0F]; + *p++ = 0x3a; /* ":" */ + } + if(p != scratch) + p--; /* Remove the last ":" */ + + wrote += p - scratch; + return (cb(scratch, p - scratch, app_key) < 0) ? -1 : wrote; +} + +/* + * INTEGER specific human-readable output. + */ +int +INTEGER_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel, + asn_app_consume_bytes_f *cb, void *app_key) { + const INTEGER_t *st = (const INTEGER_t *)sptr; + ssize_t ret; + + (void)td; + (void)ilevel; + + if(!st || !st->buf) + ret = cb("", 8, app_key); + else + ret = INTEGER__dump(td, st, cb, app_key, 0); + + return (ret < 0) ? -1 : 0; +} + +struct e2v_key { + const char *start; + const char *stop; + asn_INTEGER_enum_map_t *vemap; + unsigned int *evmap; +}; +static int +INTEGER__compar_enum2value(const void *kp, const void *am) { + const struct e2v_key *key = (const struct e2v_key *)kp; + const asn_INTEGER_enum_map_t *el = (const asn_INTEGER_enum_map_t *)am; + const char *ptr, *end, *name; + + /* Remap the element (sort by different criterion) */ + el = key->vemap + key->evmap[el - key->vemap]; + + /* Compare strings */ + for(ptr = key->start, end = key->stop, name = el->enum_name; + ptr < end; ptr++, name++) { + if(*ptr != *name) + return *(const unsigned char *)ptr + - *(const unsigned char *)name; + } + return name[0] ? -1 : 0; +} + +static const asn_INTEGER_enum_map_t * +INTEGER_map_enum2value(asn_INTEGER_specifics_t *specs, const char *lstart, const char *lstop) { + asn_INTEGER_enum_map_t *el_found; + int count = specs ? specs->map_count : 0; + struct e2v_key key; + const char *lp; + + if(!count) return NULL; + + /* Guaranteed: assert(lstart < lstop); */ + /* Figure out the tag name */ + for(lstart++, lp = lstart; lp < lstop; lp++) { + switch(*lp) { + case 9: case 10: case 11: case 12: case 13: case 32: /* WSP */ + case 0x2f: /* '/' */ case 0x3e: /* '>' */ + break; + default: + continue; + } + break; + } + if(lp == lstop) return NULL; /* No tag found */ + lstop = lp; + + key.start = lstart; + key.stop = lstop; + key.vemap = specs->value2enum; + key.evmap = specs->enum2value; + el_found = (asn_INTEGER_enum_map_t *)bsearch(&key, + specs->value2enum, count, sizeof(specs->value2enum[0]), + INTEGER__compar_enum2value); + if(el_found) { + /* Remap enum2value into value2enum */ + el_found = key.vemap + key.evmap[el_found - key.vemap]; + } + return el_found; +} + +static int +INTEGER__compar_value2enum(const void *kp, const void *am) { + long a = *(const long *)kp; + const asn_INTEGER_enum_map_t *el = (const asn_INTEGER_enum_map_t *)am; + long b = el->nat_value; + if(a < b) return -1; + else if(a == b) return 0; + else return 1; +} + +const asn_INTEGER_enum_map_t * +INTEGER_map_value2enum(asn_INTEGER_specifics_t *specs, long value) { + int count = specs ? specs->map_count : 0; + if(!count) return 0; + return (asn_INTEGER_enum_map_t *)bsearch(&value, specs->value2enum, + count, sizeof(specs->value2enum[0]), + INTEGER__compar_value2enum); +} + +static int +INTEGER_st_prealloc(INTEGER_t *st, int min_size) { + void *p = MALLOC(min_size + 1); + if(p) { + void *b = st->buf; + st->size = 0; + st->buf = p; + FREEMEM(b); + return 0; + } else { + return -1; + } +} + +/* + * Decode the chunk of XML text encoding INTEGER. + */ +static enum xer_pbd_rval +INTEGER__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) { + INTEGER_t *st = (INTEGER_t *)sptr; + long sign = 1; + long value; + const char *lp; + const char *lstart = (const char *)chunk_buf; + const char *lstop = lstart + chunk_size; + enum { + ST_SKIPSPACE, + ST_SKIPSPHEX, + ST_WAITDIGITS, + ST_DIGITS, + ST_HEXDIGIT1, + ST_HEXDIGIT2, + ST_HEXCOLON, + ST_EXTRASTUFF + } state = ST_SKIPSPACE; + + if(chunk_size) + ASN_DEBUG("INTEGER body %d 0x%2x..0x%2x", + chunk_size, *lstart, lstop[-1]); + + /* + * We may have received a tag here. It will be processed inline. + * Use strtoul()-like code and serialize the result. + */ + for(value = 0, lp = lstart; lp < lstop; lp++) { + int lv = *lp; + switch(lv) { + case 0x09: case 0x0a: case 0x0d: case 0x20: + switch(state) { + case ST_SKIPSPACE: + case ST_SKIPSPHEX: + continue; + case ST_HEXCOLON: + if(xer_is_whitespace(lp, lstop - lp)) { + lp = lstop - 1; + continue; + } + break; + default: + break; + } + break; + case 0x2d: /* '-' */ + if(state == ST_SKIPSPACE) { + sign = -1; + state = ST_WAITDIGITS; + continue; + } + break; + case 0x2b: /* '+' */ + if(state == ST_SKIPSPACE) { + state = ST_WAITDIGITS; + continue; + } + break; + case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: + case 0x35: case 0x36: case 0x37: case 0x38: case 0x39: + switch(state) { + case ST_DIGITS: break; + case ST_SKIPSPHEX: /* Fall through */ + case ST_HEXDIGIT1: + value = (lv - 0x30) << 4; + state = ST_HEXDIGIT2; + continue; + case ST_HEXDIGIT2: + value += (lv - 0x30); + state = ST_HEXCOLON; + st->buf[st->size++] = value; + continue; + case ST_HEXCOLON: + return XPBD_BROKEN_ENCODING; + default: + state = ST_DIGITS; + break; + } + + { + long new_value = value * 10; + + if(new_value / 10 != value) + /* Overflow */ + return XPBD_DECODER_LIMIT; + + value = new_value + (lv - 0x30); + /* Check for two's complement overflow */ + if(value < 0) { + /* Check whether it is a LONG_MIN */ + if(sign == -1 + && (unsigned long)value + == ~((unsigned long)-1 >> 1)) { + sign = 1; + } else { + /* Overflow */ + return XPBD_DECODER_LIMIT; + } + } + } + continue; + case 0x3c: /* '<' */ + if(state == ST_SKIPSPACE) { + const asn_INTEGER_enum_map_t *el; + el = INTEGER_map_enum2value( + (asn_INTEGER_specifics_t *) + td->specifics, lstart, lstop); + if(el) { + ASN_DEBUG("Found \"%s\" => %ld", + el->enum_name, el->nat_value); + state = ST_DIGITS; + value = el->nat_value; + lp = lstop - 1; + continue; + } + ASN_DEBUG("Unknown identifier for INTEGER"); + } + return XPBD_BROKEN_ENCODING; + case 0x3a: /* ':' */ + if(state == ST_HEXCOLON) { + /* This colon is expected */ + state = ST_HEXDIGIT1; + continue; + } else if(state == ST_DIGITS) { + /* The colon here means that we have + * decoded the first two hexadecimal + * places as a decimal value. + * Switch decoding mode. */ + ASN_DEBUG("INTEGER re-evaluate as hex form"); + if(INTEGER_st_prealloc(st, (chunk_size/3) + 1)) + return XPBD_SYSTEM_FAILURE; + state = ST_SKIPSPHEX; + lp = lstart - 1; + continue; + } else { + ASN_DEBUG("state %d at %d", state, lp - lstart); + break; + } + /* [A-Fa-f] */ + case 0x41:case 0x42:case 0x43:case 0x44:case 0x45:case 0x46: + case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:case 0x66: + switch(state) { + case ST_SKIPSPHEX: + case ST_SKIPSPACE: /* Fall through */ + case ST_HEXDIGIT1: + value = lv - ((lv < 0x61) ? 0x41 : 0x61); + value += 10; + value <<= 4; + state = ST_HEXDIGIT2; + continue; + case ST_HEXDIGIT2: + value += lv - ((lv < 0x61) ? 0x41 : 0x61); + value += 10; + st->buf[st->size++] = value; + state = ST_HEXCOLON; + continue; + case ST_DIGITS: + ASN_DEBUG("INTEGER re-evaluate as hex form"); + if(INTEGER_st_prealloc(st, (chunk_size/3) + 1)) + return XPBD_SYSTEM_FAILURE; + state = ST_SKIPSPHEX; + lp = lstart - 1; + continue; + default: + break; + } + break; + } + + /* Found extra non-numeric stuff */ + ASN_DEBUG("Found non-numeric 0x%2x at %d", + lv, lp - lstart); + state = ST_EXTRASTUFF; + break; + } + + switch(state) { + case ST_DIGITS: + /* Everything is cool */ + break; + case ST_HEXCOLON: + st->buf[st->size] = 0; /* Just in case termination */ + return XPBD_BODY_CONSUMED; + case ST_HEXDIGIT1: + case ST_HEXDIGIT2: + case ST_SKIPSPHEX: + return XPBD_BROKEN_ENCODING; + default: + if(xer_is_whitespace(lp, lstop - lp)) { + if(state != ST_EXTRASTUFF) + return XPBD_NOT_BODY_IGNORE; + break; + } else { + ASN_DEBUG("INTEGER: No useful digits (state %d)", + state); + return XPBD_BROKEN_ENCODING; /* No digits */ + } + break; + } + + value *= sign; /* Change sign, if needed */ + + if(asn_long2INTEGER(st, value)) + return XPBD_SYSTEM_FAILURE; + + return XPBD_BODY_CONSUMED; +} + +asn_dec_rval_t +INTEGER_decode_xer(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname, + const void *buf_ptr, size_t size) { + + return xer_decode_primitive(opt_codec_ctx, td, + sptr, sizeof(INTEGER_t), opt_mname, + buf_ptr, size, INTEGER__xer_body_decode); +} + +asn_enc_rval_t +INTEGER_encode_xer(asn_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + const INTEGER_t *st = (const INTEGER_t *)sptr; + asn_enc_rval_t er; + + (void)ilevel; + (void)flags; + + if(!st || !st->buf) + _ASN_ENCODE_FAILED; + + er.encoded = INTEGER__dump(td, st, cb, app_key, 1); + if(er.encoded < 0) _ASN_ENCODE_FAILED; + + _ASN_ENCODED_OK(er); +} + +asn_dec_rval_t +INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) { + asn_dec_rval_t rval = { RC_OK, 0 }; + INTEGER_t *st = (INTEGER_t *)*sptr; + asn_per_constraint_t *ct; + int repeat; + + (void)opt_codec_ctx; + + if(!st) { + st = (INTEGER_t *)(*sptr = CALLOC(1, sizeof(*st))); + if(!st) _ASN_DECODE_FAILED; + } + + if(!constraints) constraints = td->per_constraints; + ct = constraints ? &constraints->value : 0; + + if(ct && ct->flags & APC_EXTENSIBLE) { + int inext = per_get_few_bits(pd, 1); + if(inext < 0) _ASN_DECODE_STARVED; + if(inext) ct = 0; + } + + FREEMEM(st->buf); + if(ct) { + if(ct->flags & APC_SEMI_CONSTRAINED) { + st->buf = (uint8_t *)CALLOC(1, 2); + if(!st->buf) _ASN_DECODE_FAILED; + st->size = 1; + } else if(ct->flags & APC_CONSTRAINED && ct->range_bits >= 0) { + size_t size = (ct->range_bits + 7) >> 3; + st->buf = (uint8_t *)MALLOC(1 + size + 1); + if(!st->buf) _ASN_DECODE_FAILED; + st->size = size; + } else { + st->size = 0; + } + } else { + st->size = 0; + } + + /* X.691, #12.2.2 */ + if(ct && ct->flags != APC_UNCONSTRAINED) { + /* #10.5.6 */ + ASN_DEBUG("Integer with range %d bits", ct->range_bits); + if(ct->range_bits >= 0) { + long value = per_get_few_bits(pd, ct->range_bits); + if(value < 0) _ASN_DECODE_STARVED; + ASN_DEBUG("Got value %ld + low %ld", + value, ct->lower_bound); + value += ct->lower_bound; + if(asn_long2INTEGER(st, value)) + _ASN_DECODE_FAILED; + return rval; + } + } else { + ASN_DEBUG("Decoding unconstrained integer %s", td->name); + } + + /* X.691, #12.2.3, #12.2.4 */ + do { + ssize_t len; + void *p; + int ret; + + /* Get the PER length */ + len = uper_get_length(pd, -1, &repeat); + if(len < 0) _ASN_DECODE_STARVED; + + p = REALLOC(st->buf, st->size + len + 1); + if(!p) _ASN_DECODE_FAILED; + st->buf = (uint8_t *)p; + + ret = per_get_many_bits(pd, &st->buf[st->size], 0, 8 * len); + if(ret < 0) _ASN_DECODE_STARVED; + st->size += len; + } while(repeat); + st->buf[st->size] = 0; /* JIC */ + + /* #12.2.3 */ + if(ct && ct->lower_bound) { + /* + * TODO: replace by in-place arithmetics. + */ + long value; + if(asn_INTEGER2long(st, &value)) + _ASN_DECODE_FAILED; + if(asn_long2INTEGER(st, value + ct->lower_bound)) + _ASN_DECODE_FAILED; + } + + return rval; +} + +asn_enc_rval_t +INTEGER_encode_uper(asn_TYPE_descriptor_t *td, + asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) { + asn_enc_rval_t er; + INTEGER_t *st = (INTEGER_t *)sptr; + const uint8_t *buf; + const uint8_t *end; + asn_per_constraint_t *ct; + long value = 0; + + if(!st || st->size == 0) _ASN_ENCODE_FAILED; + + if(!constraints) constraints = td->per_constraints; + ct = constraints ? &constraints->value : 0; + + er.encoded = 0; + + if(ct) { + int inext = 0; + if(asn_INTEGER2long(st, &value)) + _ASN_ENCODE_FAILED; + /* Check proper range */ + if(ct->flags & APC_SEMI_CONSTRAINED) { + if(value < ct->lower_bound) + inext = 1; + } else if(ct->range_bits >= 0) { + if(value < ct->lower_bound + || value > ct->upper_bound) + inext = 1; + } + ASN_DEBUG("Value %ld (%02x/%d) lb %ld ub %ld %s", + value, st->buf[0], st->size, + ct->lower_bound, ct->upper_bound, + inext ? "ext" : "fix"); + if(ct->flags & APC_EXTENSIBLE) { + if(per_put_few_bits(po, inext, 1)) + _ASN_ENCODE_FAILED; + if(inext) ct = 0; + } else if(inext) { + _ASN_ENCODE_FAILED; + } + } + + + /* X.691, #12.2.2 */ + if(ct && ct->range_bits >= 0) { + /* #10.5.6 */ + ASN_DEBUG("Encoding integer with range %d bits", + ct->range_bits); + if(per_put_few_bits(po, value - ct->lower_bound, + ct->range_bits)) + _ASN_ENCODE_FAILED; + _ASN_ENCODED_OK(er); + } + + if(ct && ct->lower_bound) { + ASN_DEBUG("Adjust lower bound to %ld", ct->lower_bound); + /* TODO: adjust lower bound */ + _ASN_ENCODE_FAILED; + } + + for(buf = st->buf, end = st->buf + st->size; buf < end;) { + ssize_t mayEncode = uper_put_length(po, end - buf); + if(mayEncode < 0) + _ASN_ENCODE_FAILED; + if(per_put_many_bits(po, buf, 8 * mayEncode)) + _ASN_ENCODE_FAILED; + buf += mayEncode; + } + + _ASN_ENCODED_OK(er); +} + +int +asn_INTEGER2long(const INTEGER_t *iptr, long *lptr) { + uint8_t *b, *end; + size_t size; + long l; + + /* Sanity checking */ + if(!iptr || !iptr->buf || !lptr) { + errno = EINVAL; + return -1; + } + + /* Cache the begin/end of the buffer */ + b = iptr->buf; /* Start of the INTEGER buffer */ + size = iptr->size; + end = b + size; /* Where to stop */ + + if(size > sizeof(long)) { + uint8_t *end1 = end - 1; + /* + * Slightly more advanced processing, + * able to >sizeof(long) bytes, + * when the actual value is small + * (0x0000000000abcdef would yield a fine 0x00abcdef) + */ + /* Skip out the insignificant leading bytes */ + for(; b < end1; b++) { + switch(*b) { + case 0x00: if((b[1] & 0x80) == 0) continue; break; + case 0xff: if((b[1] & 0x80) != 0) continue; break; + } + break; + } + + size = end - b; + if(size > sizeof(long)) { + /* Still cannot fit the long */ + errno = ERANGE; + return -1; + } + } + + /* Shortcut processing of a corner case */ + if(end == b) { + *lptr = 0; + return 0; + } + + /* Perform the sign initialization */ + /* Actually l = -(*b >> 7); gains nothing, yet unreadable! */ + if((*b >> 7)) l = -1; else l = 0; + + /* Conversion engine */ + for(; b < end; b++) + l = (l << 8) | *b; + + *lptr = l; + return 0; +} + +int +asn_long2INTEGER(INTEGER_t *st, long value) { + uint8_t *buf, *bp; + uint8_t *p; + uint8_t *pstart; + uint8_t *pend1; + int littleEndian = 1; /* Run-time detection */ + int add; + + if(!st) { + errno = EINVAL; + return -1; + } + + buf = (uint8_t *)MALLOC(sizeof(value)); + if(!buf) return -1; + + if(*(char *)&littleEndian) { + pstart = (uint8_t *)&value + sizeof(value) - 1; + pend1 = (uint8_t *)&value; + add = -1; + } else { + pstart = (uint8_t *)&value; + pend1 = pstart + sizeof(value) - 1; + add = 1; + } + + /* + * If the contents octet consists of more than one octet, + * then bits of the first octet and bit 8 of the second octet: + * a) shall not all be ones; and + * b) shall not all be zero. + */ + for(p = pstart; p != pend1; p += add) { + switch(*p) { + case 0x00: if((*(p+add) & 0x80) == 0) + continue; + break; + case 0xff: if((*(p+add) & 0x80)) + continue; + break; + } + break; + } + /* Copy the integer body */ + for(pstart = p, bp = buf, pend1 += add; p != pend1; p += add) + *bp++ = *p; + + if(st->buf) FREEMEM(st->buf); + st->buf = buf; + st->size = bp - buf; + + return 0; +} diff --git a/projects/stargazer/plugins/other/snmp/asn1/INTEGER.h b/projects/stargazer/plugins/other/snmp/asn1/INTEGER.h new file mode 100644 index 00000000..62832b12 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/INTEGER.h @@ -0,0 +1,65 @@ +/*- + * Copyright (c) 2003, 2005 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _INTEGER_H_ +#define _INTEGER_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef ASN__PRIMITIVE_TYPE_t INTEGER_t; + +extern asn_TYPE_descriptor_t asn_DEF_INTEGER; + +/* Map with to integer value association */ +typedef struct asn_INTEGER_enum_map_s { + long nat_value; /* associated native integer value */ + size_t enum_len; /* strlen("tag") */ + const char *enum_name; /* "tag" */ +} asn_INTEGER_enum_map_t; + +/* This type describes an enumeration for INTEGER and ENUMERATED types */ +typedef struct asn_INTEGER_specifics_s { + asn_INTEGER_enum_map_t *value2enum; /* N -> "tag"; sorted by N */ + unsigned int *enum2value; /* "tag" => N; sorted by tag */ + int map_count; /* Elements in either map */ + int extension; /* This map is extensible */ + int strict_enumeration; /* Enumeration set is fixed */ +} asn_INTEGER_specifics_t; + +asn_struct_print_f INTEGER_print; +ber_type_decoder_f INTEGER_decode_ber; +der_type_encoder_f INTEGER_encode_der; +xer_type_decoder_f INTEGER_decode_xer; +xer_type_encoder_f INTEGER_encode_xer; +per_type_decoder_f INTEGER_decode_uper; +per_type_encoder_f INTEGER_encode_uper; + +/*********************************** + * Some handy conversion routines. * + ***********************************/ + +/* + * Returns 0 if it was possible to convert, -1 otherwise. + * -1/EINVAL: Mandatory argument missing + * -1/ERANGE: Value encoded is out of range for long representation + * -1/ENOMEM: Memory allocation failed (in asn_long2INTEGER()). + */ +int asn_INTEGER2long(const INTEGER_t *i, long *l); +int asn_long2INTEGER(INTEGER_t *i, long l); + +/* + * Convert the integer value into the corresponding enumeration map entry. + */ +const asn_INTEGER_enum_map_t *INTEGER_map_value2enum(asn_INTEGER_specifics_t *specs, long value); + +#ifdef __cplusplus +} +#endif + +#endif /* _INTEGER_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/IfEntry.c b/projects/stargazer/plugins/other/snmp/asn1/IfEntry.c new file mode 100644 index 00000000..a97b2454 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/IfEntry.c @@ -0,0 +1,271 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "IfEntry.h" + +static asn_TYPE_member_t asn_MBR_IfEntry_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifIndex), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifIndex" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifDescr), + (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), + 0, + &asn_DEF_DisplayString, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifDescr" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifType), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifType" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifMtu), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifMtu" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifSpeed), + (ASN_TAG_CLASS_APPLICATION | (2 << 2)), + 0, + &asn_DEF_Gauge, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifSpeed" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifPhysAddress), + (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), + 0, + &asn_DEF_PhysAddress, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifPhysAddress" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifAdminStatus), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifAdminStatus" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOperStatus), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifOperStatus" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifLastChange), + (ASN_TAG_CLASS_APPLICATION | (3 << 2)), + 0, + &asn_DEF_TimeTicks, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifLastChange" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifInOctets), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifInOctets" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifInUcastPkts), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifInUcastPkts" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifInNUcastPkts), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifInNUcastPkts" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifInDiscards), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifInDiscards" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifInErrors), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifInErrors" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifInUnknownProtos), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifInUnknownProtos" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOutOctets), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifOutOctets" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOutUcastPkts), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifOutUcastPkts" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOutNUcastPkts), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifOutNUcastPkts" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOutDiscards), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifOutDiscards" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOutErrors), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_Counter, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifOutErrors" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOutQLen), + (ASN_TAG_CLASS_APPLICATION | (2 << 2)), + 0, + &asn_DEF_Gauge, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifOutQLen" + }, + { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifSpecific), + (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), + 0, + &asn_DEF_OBJECT_IDENTIFIER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ifSpecific" + }, +}; +static ber_tlv_tag_t asn_DEF_IfEntry_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_IfEntry_tag2el_1[] = { + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 4 }, /* ifIndex at 78 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, -1, 3 }, /* ifType at 83 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 3, -2, 2 }, /* ifMtu at 85 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 6, -3, 1 }, /* ifAdminStatus at 91 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 7, -4, 0 }, /* ifOperStatus at 93 */ + { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 1, 0, 1 }, /* ifDescr at 81 */ + { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 5, -1, 0 }, /* ifPhysAddress at 89 */ + { (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), 21, 0, 0 }, /* ifSpecific at 121 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 9, 0, 10 }, /* ifInOctets at 97 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 10, -1, 9 }, /* ifInUcastPkts at 99 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 11, -2, 8 }, /* ifInNUcastPkts at 101 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 12, -3, 7 }, /* ifInDiscards at 103 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 13, -4, 6 }, /* ifInErrors at 105 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 14, -5, 5 }, /* ifInUnknownProtos at 107 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 15, -6, 4 }, /* ifOutOctets at 109 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 16, -7, 3 }, /* ifOutUcastPkts at 111 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 17, -8, 2 }, /* ifOutNUcastPkts at 113 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 18, -9, 1 }, /* ifOutDiscards at 115 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 19, -10, 0 }, /* ifOutErrors at 117 */ + { (ASN_TAG_CLASS_APPLICATION | (2 << 2)), 4, 0, 1 }, /* ifSpeed at 87 */ + { (ASN_TAG_CLASS_APPLICATION | (2 << 2)), 20, -1, 0 }, /* ifOutQLen at 119 */ + { (ASN_TAG_CLASS_APPLICATION | (3 << 2)), 8, 0, 0 } /* ifLastChange at 95 */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_IfEntry_specs_1 = { + sizeof(struct IfEntry), + offsetof(struct IfEntry, _asn_ctx), + asn_MAP_IfEntry_tag2el_1, + 22, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* Start extensions */ + -1 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_IfEntry = { + "IfEntry", + "IfEntry", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_IfEntry_tags_1, + sizeof(asn_DEF_IfEntry_tags_1) + /sizeof(asn_DEF_IfEntry_tags_1[0]), /* 1 */ + asn_DEF_IfEntry_tags_1, /* Same as above */ + sizeof(asn_DEF_IfEntry_tags_1) + /sizeof(asn_DEF_IfEntry_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_IfEntry_1, + 22, /* Elements count */ + &asn_SPC_IfEntry_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/IfEntry.h b/projects/stargazer/plugins/other/snmp/asn1/IfEntry.h new file mode 100644 index 00000000..eb30717b --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/IfEntry.h @@ -0,0 +1,64 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _IfEntry_H_ +#define _IfEntry_H_ + + +#include + +/* Including external dependencies */ +#include +#include "DisplayString.h" +#include "Gauge.h" +#include "PhysAddress.h" +#include "TimeTicks.h" +#include "Counter.h" +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* IfEntry */ +typedef struct IfEntry { + INTEGER_t ifIndex; + DisplayString_t ifDescr; + INTEGER_t ifType; + INTEGER_t ifMtu; + Gauge_t ifSpeed; + PhysAddress_t ifPhysAddress; + INTEGER_t ifAdminStatus; + INTEGER_t ifOperStatus; + TimeTicks_t ifLastChange; + Counter_t ifInOctets; + Counter_t ifInUcastPkts; + Counter_t ifInNUcastPkts; + Counter_t ifInDiscards; + Counter_t ifInErrors; + Counter_t ifInUnknownProtos; + Counter_t ifOutOctets; + Counter_t ifOutUcastPkts; + Counter_t ifOutNUcastPkts; + Counter_t ifOutDiscards; + Counter_t ifOutErrors; + Gauge_t ifOutQLen; + OBJECT_IDENTIFIER_t ifSpecific; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} IfEntry_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_IfEntry; + +#ifdef __cplusplus +} +#endif + +#endif /* _IfEntry_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/IpAddrEntry.c b/projects/stargazer/plugins/other/snmp/asn1/IpAddrEntry.c new file mode 100644 index 00000000..2cfdd1e0 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/IpAddrEntry.c @@ -0,0 +1,126 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "IpAddrEntry.h" + +static int +memb_ipAdEntReasmMaxSize_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + long value; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + value = *(const long *)sptr; + + if((value >= 0 && value <= 65535)) { + /* Constraint check succeeded */ + return 0; + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_TYPE_member_t asn_MBR_IpAddrEntry_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct IpAddrEntry, ipAdEntAddr), + (ASN_TAG_CLASS_APPLICATION | (0 << 2)), + 0, + &asn_DEF_IpAddress, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipAdEntAddr" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpAddrEntry, ipAdEntIfIndex), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipAdEntIfIndex" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpAddrEntry, ipAdEntNetMask), + (ASN_TAG_CLASS_APPLICATION | (0 << 2)), + 0, + &asn_DEF_IpAddress, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipAdEntNetMask" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpAddrEntry, ipAdEntBcastAddr), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipAdEntBcastAddr" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpAddrEntry, ipAdEntReasmMaxSize), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_NativeInteger, + memb_ipAdEntReasmMaxSize_constraint_1, + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipAdEntReasmMaxSize" + }, +}; +static ber_tlv_tag_t asn_DEF_IpAddrEntry_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_IpAddrEntry_tag2el_1[] = { + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 2 }, /* ipAdEntIfIndex at 177 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 3, -1, 1 }, /* ipAdEntBcastAddr at 181 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 4, -2, 0 }, /* ipAdEntReasmMaxSize at 183 */ + { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 0, 0, 1 }, /* ipAdEntAddr at 175 */ + { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 2, -1, 0 } /* ipAdEntNetMask at 179 */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_IpAddrEntry_specs_1 = { + sizeof(struct IpAddrEntry), + offsetof(struct IpAddrEntry, _asn_ctx), + asn_MAP_IpAddrEntry_tag2el_1, + 5, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* Start extensions */ + -1 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_IpAddrEntry = { + "IpAddrEntry", + "IpAddrEntry", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_IpAddrEntry_tags_1, + sizeof(asn_DEF_IpAddrEntry_tags_1) + /sizeof(asn_DEF_IpAddrEntry_tags_1[0]), /* 1 */ + asn_DEF_IpAddrEntry_tags_1, /* Same as above */ + sizeof(asn_DEF_IpAddrEntry_tags_1) + /sizeof(asn_DEF_IpAddrEntry_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_IpAddrEntry_1, + 5, /* Elements count */ + &asn_SPC_IpAddrEntry_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/IpAddrEntry.h b/projects/stargazer/plugins/other/snmp/asn1/IpAddrEntry.h new file mode 100644 index 00000000..9e36f32a --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/IpAddrEntry.h @@ -0,0 +1,43 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _IpAddrEntry_H_ +#define _IpAddrEntry_H_ + + +#include + +/* Including external dependencies */ +#include "IpAddress.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* IpAddrEntry */ +typedef struct IpAddrEntry { + IpAddress_t ipAdEntAddr; + INTEGER_t ipAdEntIfIndex; + IpAddress_t ipAdEntNetMask; + INTEGER_t ipAdEntBcastAddr; + long ipAdEntReasmMaxSize; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} IpAddrEntry_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_IpAddrEntry; + +#ifdef __cplusplus +} +#endif + +#endif /* _IpAddrEntry_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/IpAddress.c b/projects/stargazer/plugins/other/snmp/asn1/IpAddress.c new file mode 100644 index 00000000..8dbc66b7 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/IpAddress.c @@ -0,0 +1,129 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "IpAddress.h" + +int +IpAddress_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr; + size_t size; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + size = st->size; + + if((size == 4)) { + /* Constraint check succeeded */ + return 0; + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +/* + * This type is implemented using OCTET_STRING, + * so here we adjust the DEF accordingly. + */ +static void +IpAddress_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { + td->free_struct = asn_DEF_OCTET_STRING.free_struct; + td->print_struct = asn_DEF_OCTET_STRING.print_struct; + td->ber_decoder = asn_DEF_OCTET_STRING.ber_decoder; + td->der_encoder = asn_DEF_OCTET_STRING.der_encoder; + td->xer_decoder = asn_DEF_OCTET_STRING.xer_decoder; + td->xer_encoder = asn_DEF_OCTET_STRING.xer_encoder; + td->uper_decoder = asn_DEF_OCTET_STRING.uper_decoder; + td->uper_encoder = asn_DEF_OCTET_STRING.uper_encoder; + if(!td->per_constraints) + td->per_constraints = asn_DEF_OCTET_STRING.per_constraints; + td->elements = asn_DEF_OCTET_STRING.elements; + td->elements_count = asn_DEF_OCTET_STRING.elements_count; + td->specifics = asn_DEF_OCTET_STRING.specifics; +} + +void +IpAddress_free(asn_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + IpAddress_1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +IpAddress_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + IpAddress_1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + +asn_dec_rval_t +IpAddress_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const void *bufptr, size_t size, int tag_mode) { + IpAddress_1_inherit_TYPE_descriptor(td); + return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); +} + +asn_enc_rval_t +IpAddress_encode_der(asn_TYPE_descriptor_t *td, + void *structure, int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + IpAddress_1_inherit_TYPE_descriptor(td); + return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); +} + +asn_dec_rval_t +IpAddress_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const char *opt_mname, const void *bufptr, size_t size) { + IpAddress_1_inherit_TYPE_descriptor(td); + return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); +} + +asn_enc_rval_t +IpAddress_encode_xer(asn_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + IpAddress_1_inherit_TYPE_descriptor(td); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); +} + +static ber_tlv_tag_t asn_DEF_IpAddress_tags_1[] = { + (ASN_TAG_CLASS_APPLICATION | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_IpAddress = { + "IpAddress", + "IpAddress", + IpAddress_free, + IpAddress_print, + IpAddress_constraint, + IpAddress_decode_ber, + IpAddress_encode_der, + IpAddress_decode_xer, + IpAddress_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_IpAddress_tags_1, + sizeof(asn_DEF_IpAddress_tags_1) + /sizeof(asn_DEF_IpAddress_tags_1[0]) - 1, /* 1 */ + asn_DEF_IpAddress_tags_1, /* Same as above */ + sizeof(asn_DEF_IpAddress_tags_1) + /sizeof(asn_DEF_IpAddress_tags_1[0]), /* 2 */ + 0, /* No PER visible constraints */ + 0, 0, /* No members */ + 0 /* No specifics */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/IpAddress.h b/projects/stargazer/plugins/other/snmp/asn1/IpAddress.h new file mode 100644 index 00000000..06c1d4a3 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/IpAddress.h @@ -0,0 +1,38 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _IpAddress_H_ +#define _IpAddress_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* IpAddress */ +typedef OCTET_STRING_t IpAddress_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_IpAddress; +asn_struct_free_f IpAddress_free; +asn_struct_print_f IpAddress_print; +asn_constr_check_f IpAddress_constraint; +ber_type_decoder_f IpAddress_decode_ber; +der_type_encoder_f IpAddress_encode_der; +xer_type_decoder_f IpAddress_decode_xer; +xer_type_encoder_f IpAddress_encode_xer; + +#ifdef __cplusplus +} +#endif + +#endif /* _IpAddress_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/IpNetToMediaEntry.c b/projects/stargazer/plugins/other/snmp/asn1/IpNetToMediaEntry.c new file mode 100644 index 00000000..92a723f4 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/IpNetToMediaEntry.c @@ -0,0 +1,91 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "IpNetToMediaEntry.h" + +static asn_TYPE_member_t asn_MBR_IpNetToMediaEntry_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct IpNetToMediaEntry, ipNetToMediaIfIndex), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipNetToMediaIfIndex" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpNetToMediaEntry, ipNetToMediaPhysAddress), + (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), + 0, + &asn_DEF_PhysAddress, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipNetToMediaPhysAddress" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpNetToMediaEntry, ipNetToMediaNetAddress), + (ASN_TAG_CLASS_APPLICATION | (0 << 2)), + 0, + &asn_DEF_IpAddress, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipNetToMediaNetAddress" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpNetToMediaEntry, ipNetToMediaType), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipNetToMediaType" + }, +}; +static ber_tlv_tag_t asn_DEF_IpNetToMediaEntry_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_IpNetToMediaEntry_tag2el_1[] = { + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 1 }, /* ipNetToMediaIfIndex at 222 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 3, -1, 0 }, /* ipNetToMediaType at 229 */ + { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 1, 0, 0 }, /* ipNetToMediaPhysAddress at 224 */ + { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 2, 0, 0 } /* ipNetToMediaNetAddress at 226 */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_IpNetToMediaEntry_specs_1 = { + sizeof(struct IpNetToMediaEntry), + offsetof(struct IpNetToMediaEntry, _asn_ctx), + asn_MAP_IpNetToMediaEntry_tag2el_1, + 4, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* Start extensions */ + -1 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_IpNetToMediaEntry = { + "IpNetToMediaEntry", + "IpNetToMediaEntry", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_IpNetToMediaEntry_tags_1, + sizeof(asn_DEF_IpNetToMediaEntry_tags_1) + /sizeof(asn_DEF_IpNetToMediaEntry_tags_1[0]), /* 1 */ + asn_DEF_IpNetToMediaEntry_tags_1, /* Same as above */ + sizeof(asn_DEF_IpNetToMediaEntry_tags_1) + /sizeof(asn_DEF_IpNetToMediaEntry_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_IpNetToMediaEntry_1, + 4, /* Elements count */ + &asn_SPC_IpNetToMediaEntry_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/IpNetToMediaEntry.h b/projects/stargazer/plugins/other/snmp/asn1/IpNetToMediaEntry.h new file mode 100644 index 00000000..1eb8124f --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/IpNetToMediaEntry.h @@ -0,0 +1,42 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _IpNetToMediaEntry_H_ +#define _IpNetToMediaEntry_H_ + + +#include + +/* Including external dependencies */ +#include +#include "PhysAddress.h" +#include "IpAddress.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* IpNetToMediaEntry */ +typedef struct IpNetToMediaEntry { + INTEGER_t ipNetToMediaIfIndex; + PhysAddress_t ipNetToMediaPhysAddress; + IpAddress_t ipNetToMediaNetAddress; + INTEGER_t ipNetToMediaType; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} IpNetToMediaEntry_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_IpNetToMediaEntry; + +#ifdef __cplusplus +} +#endif + +#endif /* _IpNetToMediaEntry_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/IpRouteEntry.c b/projects/stargazer/plugins/other/snmp/asn1/IpRouteEntry.c new file mode 100644 index 00000000..190f749e --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/IpRouteEntry.c @@ -0,0 +1,181 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "IpRouteEntry.h" + +static asn_TYPE_member_t asn_MBR_IpRouteEntry_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteDest), + (ASN_TAG_CLASS_APPLICATION | (0 << 2)), + 0, + &asn_DEF_IpAddress, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipRouteDest" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteIfIndex), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipRouteIfIndex" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteMetric1), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipRouteMetric1" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteMetric2), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipRouteMetric2" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteMetric3), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipRouteMetric3" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteMetric4), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipRouteMetric4" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteNextHop), + (ASN_TAG_CLASS_APPLICATION | (0 << 2)), + 0, + &asn_DEF_IpAddress, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipRouteNextHop" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteType), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipRouteType" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteProto), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipRouteProto" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteAge), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipRouteAge" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteMask), + (ASN_TAG_CLASS_APPLICATION | (0 << 2)), + 0, + &asn_DEF_IpAddress, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipRouteMask" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteMetric5), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipRouteMetric5" + }, + { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteInfo), + (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), + 0, + &asn_DEF_OBJECT_IDENTIFIER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "ipRouteInfo" + }, +}; +static ber_tlv_tag_t asn_DEF_IpRouteEntry_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_IpRouteEntry_tag2el_1[] = { + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 8 }, /* ipRouteIfIndex at 192 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, -1, 7 }, /* ipRouteMetric1 at 194 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 3, -2, 6 }, /* ipRouteMetric2 at 196 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 4, -3, 5 }, /* ipRouteMetric3 at 198 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 5, -4, 4 }, /* ipRouteMetric4 at 200 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 7, -5, 3 }, /* ipRouteType at 204 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 8, -6, 2 }, /* ipRouteProto at 206 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 9, -7, 1 }, /* ipRouteAge at 208 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 11, -8, 0 }, /* ipRouteMetric5 at 212 */ + { (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), 12, 0, 0 }, /* ipRouteInfo at 215 */ + { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 0, 0, 2 }, /* ipRouteDest at 190 */ + { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 6, -1, 1 }, /* ipRouteNextHop at 202 */ + { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 10, -2, 0 } /* ipRouteMask at 210 */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_IpRouteEntry_specs_1 = { + sizeof(struct IpRouteEntry), + offsetof(struct IpRouteEntry, _asn_ctx), + asn_MAP_IpRouteEntry_tag2el_1, + 13, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* Start extensions */ + -1 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_IpRouteEntry = { + "IpRouteEntry", + "IpRouteEntry", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_IpRouteEntry_tags_1, + sizeof(asn_DEF_IpRouteEntry_tags_1) + /sizeof(asn_DEF_IpRouteEntry_tags_1[0]), /* 1 */ + asn_DEF_IpRouteEntry_tags_1, /* Same as above */ + sizeof(asn_DEF_IpRouteEntry_tags_1) + /sizeof(asn_DEF_IpRouteEntry_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_IpRouteEntry_1, + 13, /* Elements count */ + &asn_SPC_IpRouteEntry_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/IpRouteEntry.h b/projects/stargazer/plugins/other/snmp/asn1/IpRouteEntry.h new file mode 100644 index 00000000..5651a8fc --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/IpRouteEntry.h @@ -0,0 +1,51 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _IpRouteEntry_H_ +#define _IpRouteEntry_H_ + + +#include + +/* Including external dependencies */ +#include "IpAddress.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* IpRouteEntry */ +typedef struct IpRouteEntry { + IpAddress_t ipRouteDest; + INTEGER_t ipRouteIfIndex; + INTEGER_t ipRouteMetric1; + INTEGER_t ipRouteMetric2; + INTEGER_t ipRouteMetric3; + INTEGER_t ipRouteMetric4; + IpAddress_t ipRouteNextHop; + INTEGER_t ipRouteType; + INTEGER_t ipRouteProto; + INTEGER_t ipRouteAge; + IpAddress_t ipRouteMask; + INTEGER_t ipRouteMetric5; + OBJECT_IDENTIFIER_t ipRouteInfo; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} IpRouteEntry_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_IpRouteEntry; + +#ifdef __cplusplus +} +#endif + +#endif /* _IpRouteEntry_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/Makefile b/projects/stargazer/plugins/other/snmp/asn1/Makefile new file mode 100644 index 00000000..f1f0c87e --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/Makefile @@ -0,0 +1,8 @@ +ASN1_SOURCES = RFC1213-MIB.asn1 \ + RFC1155-SMI.asn1 \ + RFC1157-SNMP.asn1 \ + SMUX.asn1 + +asn1: $(ASN1_SOURCES) + asn1c -fskeletons-copy -fcompound-names $^ + rm Makefile.am.sample diff --git a/projects/stargazer/plugins/other/snmp/asn1/Message.c b/projects/stargazer/plugins/other/snmp/asn1/Message.c new file mode 100644 index 00000000..545b426a --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/Message.c @@ -0,0 +1,80 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "Message.h" + +static asn_TYPE_member_t asn_MBR_Message_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct Message, version), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "version" + }, + { ATF_NOFLAGS, 0, offsetof(struct Message, community), + (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), + 0, + &asn_DEF_OCTET_STRING, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "community" + }, + { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct Message, data), + -1 /* Ambiguous tag (ANY?) */, + 0, + &asn_DEF_ANY, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "data" + }, +}; +static ber_tlv_tag_t asn_DEF_Message_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_Message_tag2el_1[] = { + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* version at 18 */ + { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 1, 0, 0 } /* community at 22 */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_Message_specs_1 = { + sizeof(struct Message), + offsetof(struct Message, _asn_ctx), + asn_MAP_Message_tag2el_1, + 2, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* Start extensions */ + -1 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_Message = { + "Message", + "Message", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_Message_tags_1, + sizeof(asn_DEF_Message_tags_1) + /sizeof(asn_DEF_Message_tags_1[0]), /* 1 */ + asn_DEF_Message_tags_1, /* Same as above */ + sizeof(asn_DEF_Message_tags_1) + /sizeof(asn_DEF_Message_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_Message_1, + 3, /* Elements count */ + &asn_SPC_Message_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/Message.h b/projects/stargazer/plugins/other/snmp/asn1/Message.h new file mode 100644 index 00000000..2621d73c --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/Message.h @@ -0,0 +1,46 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _Message_H_ +#define _Message_H_ + + +#include + +/* Including external dependencies */ +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum Message__version { + Message__version_version_1 = 0 +} e_Message__version; + +/* Message */ +typedef struct Message { + INTEGER_t version; + OCTET_STRING_t community; + ANY_t data; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} Message_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_Message; + +#ifdef __cplusplus +} +#endif + +#endif /* _Message_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/NULL.c b/projects/stargazer/plugins/other/snmp/asn1/NULL.c new file mode 100644 index 00000000..6d3316f1 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/NULL.c @@ -0,0 +1,147 @@ +/*- + * Copyright (c) 2003, 2005 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include +#include +#include /* Implemented in terms of BOOLEAN type */ + +/* + * NULL basic type description. + */ +static ber_tlv_tag_t asn_DEF_NULL_tags[] = { + (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_NULL = { + "NULL", + "NULL", + BOOLEAN_free, + NULL_print, + asn_generic_no_constraint, + BOOLEAN_decode_ber, /* Implemented in terms of BOOLEAN */ + NULL_encode_der, /* Special handling of DER encoding */ + NULL_decode_xer, + NULL_encode_xer, + NULL_decode_uper, /* Unaligned PER decoder */ + NULL_encode_uper, /* Unaligned PER encoder */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_NULL_tags, + sizeof(asn_DEF_NULL_tags) / sizeof(asn_DEF_NULL_tags[0]), + asn_DEF_NULL_tags, /* Same as above */ + sizeof(asn_DEF_NULL_tags) / sizeof(asn_DEF_NULL_tags[0]), + 0, /* No PER visible constraints */ + 0, 0, /* No members */ + 0 /* No specifics */ +}; + +asn_enc_rval_t +NULL_encode_der(asn_TYPE_descriptor_t *td, void *ptr, + int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + asn_enc_rval_t erval; + + erval.encoded = der_write_tags(td, 0, tag_mode, 0, tag, cb, app_key); + if(erval.encoded == -1) { + erval.failed_type = td; + erval.structure_ptr = ptr; + } + + _ASN_ENCODED_OK(erval); +} + +asn_enc_rval_t +NULL_encode_xer(asn_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + asn_enc_rval_t er; + + (void)td; + (void)sptr; + (void)ilevel; + (void)flags; + (void)cb; + (void)app_key; + + /* XMLNullValue is empty */ + er.encoded = 0; + _ASN_ENCODED_OK(er); +} + + +static enum xer_pbd_rval +NULL__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) { + (void)td; + (void)sptr; + + if(xer_is_whitespace(chunk_buf, chunk_size)) + return XPBD_BODY_CONSUMED; + else + return XPBD_BROKEN_ENCODING; +} + +asn_dec_rval_t +NULL_decode_xer(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname, + const void *buf_ptr, size_t size) { + + return xer_decode_primitive(opt_codec_ctx, td, + sptr, sizeof(NULL_t), opt_mname, buf_ptr, size, + NULL__xer_body_decode); +} + +int +NULL_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel, + asn_app_consume_bytes_f *cb, void *app_key) { + + (void)td; /* Unused argument */ + (void)ilevel; /* Unused argument */ + + if(sptr) { + return (cb("", 9, app_key) < 0) ? -1 : 0; + } else { + return (cb("", 8, app_key) < 0) ? -1 : 0; + } +} + +asn_dec_rval_t +NULL_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) { + asn_dec_rval_t rv; + + (void)opt_codec_ctx; + (void)td; + (void)constraints; + (void)pd; + + if(!*sptr) { + *sptr = MALLOC(sizeof(NULL_t)); + if(*sptr) { + *(NULL_t *)*sptr = 0; + } else { + _ASN_DECODE_FAILED; + } + } + + /* + * NULL type does not have content octets. + */ + + rv.code = RC_OK; + rv.consumed = 0; + return rv; +} + +asn_enc_rval_t +NULL_encode_uper(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, + void *sptr, asn_per_outp_t *po) { + asn_enc_rval_t er; + + (void)td; + (void)constraints; + (void)sptr; + (void)po; + + er.encoded = 0; + _ASN_ENCODED_OK(er); +} diff --git a/projects/stargazer/plugins/other/snmp/asn1/NULL.h b/projects/stargazer/plugins/other/snmp/asn1/NULL.h new file mode 100644 index 00000000..131e7759 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/NULL.h @@ -0,0 +1,33 @@ +/*- + * Copyright (c) 2003 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef ASN_TYPE_NULL_H +#define ASN_TYPE_NULL_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * The value of the NULL type is meaningless: see BOOLEAN if you want to + * carry true/false semantics. + */ +typedef int NULL_t; + +extern asn_TYPE_descriptor_t asn_DEF_NULL; + +asn_struct_print_f NULL_print; +der_type_encoder_f NULL_encode_der; +xer_type_decoder_f NULL_decode_xer; +xer_type_encoder_f NULL_encode_xer; +per_type_decoder_f NULL_decode_uper; +per_type_encoder_f NULL_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* NULL_H */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/NativeEnumerated.c b/projects/stargazer/plugins/other/snmp/asn1/NativeEnumerated.c new file mode 100644 index 00000000..e3af1ca4 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/NativeEnumerated.c @@ -0,0 +1,204 @@ +/*- + * Copyright (c) 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +/* + * Read the NativeInteger.h for the explanation wrt. differences between + * INTEGER and NativeInteger. + * Basically, both are decoders and encoders of ASN.1 INTEGER type, but this + * implementation deals with the standard (machine-specific) representation + * of them instead of using the platform-independent buffer. + */ +#include +#include + +/* + * NativeEnumerated basic type description. + */ +static ber_tlv_tag_t asn_DEF_NativeEnumerated_tags[] = { + (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_NativeEnumerated = { + "ENUMERATED", /* The ASN.1 type is still ENUMERATED */ + "ENUMERATED", + NativeInteger_free, + NativeInteger_print, + asn_generic_no_constraint, + NativeInteger_decode_ber, + NativeInteger_encode_der, + NativeInteger_decode_xer, + NativeEnumerated_encode_xer, + NativeEnumerated_decode_uper, + NativeEnumerated_encode_uper, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_NativeEnumerated_tags, + sizeof(asn_DEF_NativeEnumerated_tags) / sizeof(asn_DEF_NativeEnumerated_tags[0]), + asn_DEF_NativeEnumerated_tags, /* Same as above */ + sizeof(asn_DEF_NativeEnumerated_tags) / sizeof(asn_DEF_NativeEnumerated_tags[0]), + 0, /* No PER visible constraints */ + 0, 0, /* No members */ + 0 /* No specifics */ +}; + +asn_enc_rval_t +NativeEnumerated_encode_xer(asn_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics; + asn_enc_rval_t er; + const long *native = (const long *)sptr; + const asn_INTEGER_enum_map_t *el; + + (void)ilevel; + (void)flags; + + if(!native) _ASN_ENCODE_FAILED; + + el = INTEGER_map_value2enum(specs, *native); + if(el) { + size_t srcsize = el->enum_len + 5; + char *src = (char *)alloca(srcsize); + + er.encoded = snprintf(src, srcsize, "<%s/>", el->enum_name); + assert(er.encoded > 0 && (size_t)er.encoded < srcsize); + if(cb(src, er.encoded, app_key) < 0) _ASN_ENCODE_FAILED; + _ASN_ENCODED_OK(er); + } else { + ASN_DEBUG("ASN.1 forbids dealing with " + "unknown value of ENUMERATED type"); + _ASN_ENCODE_FAILED; + } +} + +asn_dec_rval_t +NativeEnumerated_decode_uper(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, + void **sptr, asn_per_data_t *pd) { + asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics; + asn_dec_rval_t rval = { RC_OK, 0 }; + long *native = (long *)*sptr; + asn_per_constraint_t *ct; + long value; + + (void)opt_codec_ctx; + + if(constraints) ct = &constraints->value; + else if(td->per_constraints) ct = &td->per_constraints->value; + else _ASN_DECODE_FAILED; /* Mandatory! */ + if(!specs) _ASN_DECODE_FAILED; + + if(!native) { + native = (long *)(*sptr = CALLOC(1, sizeof(*native))); + if(!native) _ASN_DECODE_FAILED; + } + + ASN_DEBUG("Decoding %s as NativeEnumerated", td->name); + + if(ct->flags & APC_EXTENSIBLE) { + int inext = per_get_few_bits(pd, 1); + if(inext < 0) _ASN_DECODE_STARVED; + if(inext) ct = 0; + } + + if(ct && ct->range_bits >= 0) { + value = per_get_few_bits(pd, ct->range_bits); + if(value < 0) _ASN_DECODE_STARVED; + if(value >= (specs->extension + ? specs->extension - 1 : specs->map_count)) + _ASN_DECODE_FAILED; + } else { + if(!specs->extension) + _ASN_DECODE_FAILED; + /* + * X.691, #10.6: normally small non-negative whole number; + */ + value = uper_get_nsnnwn(pd); + if(value < 0) _ASN_DECODE_STARVED; + value += specs->extension - 1; + if(value >= specs->map_count) + _ASN_DECODE_FAILED; + } + + *native = specs->value2enum[value].nat_value; + ASN_DEBUG("Decoded %s = %ld", td->name, *native); + + return rval; +} + +static int +NativeEnumerated__compar_value2enum(const void *ap, const void *bp) { + const asn_INTEGER_enum_map_t *a = ap; + const asn_INTEGER_enum_map_t *b = bp; + if(a->nat_value == b->nat_value) + return 0; + if(a->nat_value < b->nat_value) + return -1; + return 1; +} + +asn_enc_rval_t +NativeEnumerated_encode_uper(asn_TYPE_descriptor_t *td, + asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) { + asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics; + asn_enc_rval_t er; + long native, value; + asn_per_constraint_t *ct; + int inext = 0; + asn_INTEGER_enum_map_t key; + asn_INTEGER_enum_map_t *kf; + + if(!sptr) _ASN_ENCODE_FAILED; + if(!specs) _ASN_ENCODE_FAILED; + + if(constraints) ct = &constraints->value; + else if(td->per_constraints) ct = &td->per_constraints->value; + else _ASN_ENCODE_FAILED; /* Mandatory! */ + + ASN_DEBUG("Encoding %s as NativeEnumerated", td->name); + + er.encoded = 0; + + native = *(long *)sptr; + if(native < 0) _ASN_ENCODE_FAILED; + + key.nat_value = native; + kf = bsearch(&key, specs->value2enum, specs->map_count, + sizeof(key), NativeEnumerated__compar_value2enum); + if(!kf) { + ASN_DEBUG("No element corresponds to %ld", native); + _ASN_ENCODE_FAILED; + } + value = kf - specs->value2enum; + + if(ct->range_bits >= 0) { + int cmpWith = specs->extension + ? specs->extension - 1 : specs->map_count; + if(value >= cmpWith) + inext = 1; + } + if(ct->flags & APC_EXTENSIBLE) { + if(per_put_few_bits(po, inext, 0)) + _ASN_ENCODE_FAILED; + ct = 0; + } else if(inext) { + _ASN_ENCODE_FAILED; + } + + if(ct && ct->range_bits >= 0) { + if(per_put_few_bits(po, value, ct->range_bits)) + _ASN_ENCODE_FAILED; + _ASN_ENCODED_OK(er); + } + + if(!specs->extension) + _ASN_ENCODE_FAILED; + + /* + * X.691, #10.6: normally small non-negative whole number; + */ + if(uper_put_nsnnwn(po, value - (specs->extension - 1))) + _ASN_ENCODE_FAILED; + + _ASN_ENCODED_OK(er); +} + diff --git a/projects/stargazer/plugins/other/snmp/asn1/NativeEnumerated.h b/projects/stargazer/plugins/other/snmp/asn1/NativeEnumerated.h new file mode 100644 index 00000000..c59bb1ba --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/NativeEnumerated.h @@ -0,0 +1,32 @@ +/*- + * Copyright (c) 2004, 2005, 2006 Lev Walkin . + * All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +/* + * This type differs from the standard ENUMERATED in that it is modelled using + * the fixed machine type (long, int, short), so it can hold only values of + * limited length. There is no type (i.e., NativeEnumerated_t, any integer type + * will do). + * This type may be used when integer range is limited by subtype constraints. + */ +#ifndef _NativeEnumerated_H_ +#define _NativeEnumerated_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +extern asn_TYPE_descriptor_t asn_DEF_NativeEnumerated; + +xer_type_encoder_f NativeEnumerated_encode_xer; +per_type_decoder_f NativeEnumerated_decode_uper; +per_type_encoder_f NativeEnumerated_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _NativeEnumerated_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/NativeInteger.c b/projects/stargazer/plugins/other/snmp/asn1/NativeInteger.c new file mode 100644 index 00000000..34599f61 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/NativeInteger.c @@ -0,0 +1,314 @@ +/*- + * Copyright (c) 2004, 2005, 2006 Lev Walkin . + * All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +/* + * Read the NativeInteger.h for the explanation wrt. differences between + * INTEGER and NativeInteger. + * Basically, both are decoders and encoders of ASN.1 INTEGER type, but this + * implementation deals with the standard (machine-specific) representation + * of them instead of using the platform-independent buffer. + */ +#include +#include + +/* + * NativeInteger basic type description. + */ +static ber_tlv_tag_t asn_DEF_NativeInteger_tags[] = { + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_NativeInteger = { + "INTEGER", /* The ASN.1 type is still INTEGER */ + "INTEGER", + NativeInteger_free, + NativeInteger_print, + asn_generic_no_constraint, + NativeInteger_decode_ber, + NativeInteger_encode_der, + NativeInteger_decode_xer, + NativeInteger_encode_xer, + NativeInteger_decode_uper, /* Unaligned PER decoder */ + NativeInteger_encode_uper, /* Unaligned PER encoder */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_NativeInteger_tags, + sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]), + asn_DEF_NativeInteger_tags, /* Same as above */ + sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]), + 0, /* No PER visible constraints */ + 0, 0, /* No members */ + 0 /* No specifics */ +}; + +/* + * Decode INTEGER type. + */ +asn_dec_rval_t +NativeInteger_decode_ber(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *td, + void **nint_ptr, const void *buf_ptr, size_t size, int tag_mode) { + long *native = (long *)*nint_ptr; + asn_dec_rval_t rval; + ber_tlv_len_t length; + + /* + * If the structure is not there, allocate it. + */ + if(native == NULL) { + native = (long *)(*nint_ptr = CALLOC(1, sizeof(*native))); + if(native == NULL) { + rval.code = RC_FAIL; + rval.consumed = 0; + return rval; + } + } + + ASN_DEBUG("Decoding %s as INTEGER (tm=%d)", + td->name, tag_mode); + + /* + * Check tags. + */ + rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size, + tag_mode, 0, &length, 0); + if(rval.code != RC_OK) + return rval; + + ASN_DEBUG("%s length is %d bytes", td->name, (int)length); + + /* + * Make sure we have this length. + */ + buf_ptr = ((const char *)buf_ptr) + rval.consumed; + size -= rval.consumed; + if(length > (ber_tlv_len_t)size) { + rval.code = RC_WMORE; + rval.consumed = 0; + return rval; + } + + /* + * ASN.1 encoded INTEGER: buf_ptr, length + * Fill the native, at the same time checking for overflow. + * If overflow occured, return with RC_FAIL. + */ + { + INTEGER_t tmp; + union { + const void *constbuf; + void *nonconstbuf; + } unconst_buf; + long l; + + unconst_buf.constbuf = buf_ptr; + tmp.buf = (uint8_t *)unconst_buf.nonconstbuf; + tmp.size = length; + + if(asn_INTEGER2long(&tmp, &l)) { + rval.code = RC_FAIL; + rval.consumed = 0; + return rval; + } + + *native = l; + } + + rval.code = RC_OK; + rval.consumed += length; + + ASN_DEBUG("Took %ld/%ld bytes to encode %s (%ld)", + (long)rval.consumed, (long)length, td->name, (long)*native); + + return rval; +} + +/* + * Encode the NativeInteger using the standard INTEGER type DER encoder. + */ +asn_enc_rval_t +NativeInteger_encode_der(asn_TYPE_descriptor_t *sd, void *ptr, + int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + unsigned long native = *(unsigned long *)ptr; /* Disable sign ext. */ + asn_enc_rval_t erval; + INTEGER_t tmp; + +#ifdef WORDS_BIGENDIAN /* Opportunistic optimization */ + + tmp.buf = (uint8_t *)&native; + tmp.size = sizeof(native); + +#else /* Works even if WORDS_BIGENDIAN is not set where should've been */ + uint8_t buf[sizeof(native)]; + uint8_t *p; + + /* Prepare a fake INTEGER */ + for(p = buf + sizeof(buf) - 1; p >= buf; p--, native >>= 8) + *p = native; + + tmp.buf = buf; + tmp.size = sizeof(buf); +#endif /* WORDS_BIGENDIAN */ + + /* Encode fake INTEGER */ + erval = INTEGER_encode_der(sd, &tmp, tag_mode, tag, cb, app_key); + if(erval.encoded == -1) { + assert(erval.structure_ptr == &tmp); + erval.structure_ptr = ptr; + } + return erval; +} + +/* + * Decode the chunk of XML text encoding INTEGER. + */ +asn_dec_rval_t +NativeInteger_decode_xer(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname, + const void *buf_ptr, size_t size) { + asn_dec_rval_t rval; + INTEGER_t st; + void *st_ptr = (void *)&st; + long *native = (long *)*sptr; + + if(!native) { + native = (long *)(*sptr = CALLOC(1, sizeof(*native))); + if(!native) _ASN_DECODE_FAILED; + } + + memset(&st, 0, sizeof(st)); + rval = INTEGER_decode_xer(opt_codec_ctx, td, &st_ptr, + opt_mname, buf_ptr, size); + if(rval.code == RC_OK) { + long l; + if(asn_INTEGER2long(&st, &l)) { + rval.code = RC_FAIL; + rval.consumed = 0; + } else { + *native = l; + } + } else { + /* + * Cannot restart from the middle; + * there is no place to save state in the native type. + * Request a continuation from the very beginning. + */ + rval.consumed = 0; + } + ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &st); + return rval; +} + + +asn_enc_rval_t +NativeInteger_encode_xer(asn_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + char scratch[32]; /* Enough for 64-bit int */ + asn_enc_rval_t er; + const long *native = (const long *)sptr; + + (void)ilevel; + (void)flags; + + if(!native) _ASN_ENCODE_FAILED; + + er.encoded = snprintf(scratch, sizeof(scratch), "%ld", *native); + if(er.encoded <= 0 || (size_t)er.encoded >= sizeof(scratch) + || cb(scratch, er.encoded, app_key) < 0) + _ASN_ENCODE_FAILED; + + _ASN_ENCODED_OK(er); +} + +asn_dec_rval_t +NativeInteger_decode_uper(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *td, + asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) { + + asn_dec_rval_t rval; + long *native = (long *)*sptr; + INTEGER_t tmpint; + void *tmpintptr = &tmpint; + + (void)opt_codec_ctx; + ASN_DEBUG("Decoding NativeInteger %s (UPER)", td->name); + + if(!native) { + native = (long *)(*sptr = CALLOC(1, sizeof(*native))); + if(!native) _ASN_DECODE_FAILED; + } + + memset(&tmpint, 0, sizeof tmpint); + rval = INTEGER_decode_uper(opt_codec_ctx, td, constraints, + &tmpintptr, pd); + if(rval.code == RC_OK) { + if(asn_INTEGER2long(&tmpint, native)) + rval.code = RC_FAIL; + else + ASN_DEBUG("NativeInteger %s got value %ld", + td->name, *native); + } + ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint); + + return rval; +} + +asn_enc_rval_t +NativeInteger_encode_uper(asn_TYPE_descriptor_t *td, + asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) { + asn_enc_rval_t er; + long native; + INTEGER_t tmpint; + + if(!sptr) _ASN_ENCODE_FAILED; + + native = *(long *)sptr; + + ASN_DEBUG("Encoding NativeInteger %s %ld (UPER)", td->name, native); + + memset(&tmpint, 0, sizeof(tmpint)); + if(asn_long2INTEGER(&tmpint, native)) + _ASN_ENCODE_FAILED; + er = INTEGER_encode_uper(td, constraints, &tmpint, po); + ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint); + return er; +} + +/* + * INTEGER specific human-readable output. + */ +int +NativeInteger_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel, + asn_app_consume_bytes_f *cb, void *app_key) { + const long *native = (const long *)sptr; + char scratch[32]; /* Enough for 64-bit int */ + int ret; + + (void)td; /* Unused argument */ + (void)ilevel; /* Unused argument */ + + if(native) { + ret = snprintf(scratch, sizeof(scratch), "%ld", *native); + assert(ret > 0 && (size_t)ret < sizeof(scratch)); + return (cb(scratch, ret, app_key) < 0) ? -1 : 0; + } else { + return (cb("", 8, app_key) < 0) ? -1 : 0; + } +} + +void +NativeInteger_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) { + + if(!td || !ptr) + return; + + ASN_DEBUG("Freeing %s as INTEGER (%d, %p, Native)", + td->name, contents_only, ptr); + + if(!contents_only) { + FREEMEM(ptr); + } +} + diff --git a/projects/stargazer/plugins/other/snmp/asn1/NativeInteger.h b/projects/stargazer/plugins/other/snmp/asn1/NativeInteger.h new file mode 100644 index 00000000..4e63a835 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/NativeInteger.h @@ -0,0 +1,37 @@ +/*- + * Copyright (c) 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +/* + * This type differs from the standard INTEGER in that it is modelled using + * the fixed machine type (long, int, short), so it can hold only values of + * limited length. There is no type (i.e., NativeInteger_t, any integer type + * will do). + * This type may be used when integer range is limited by subtype constraints. + */ +#ifndef _NativeInteger_H_ +#define _NativeInteger_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +extern asn_TYPE_descriptor_t asn_DEF_NativeInteger; + +asn_struct_free_f NativeInteger_free; +asn_struct_print_f NativeInteger_print; +ber_type_decoder_f NativeInteger_decode_ber; +der_type_encoder_f NativeInteger_encode_der; +xer_type_decoder_f NativeInteger_decode_xer; +xer_type_encoder_f NativeInteger_encode_xer; +per_type_decoder_f NativeInteger_decode_uper; +per_type_encoder_f NativeInteger_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _NativeInteger_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/NetworkAddress.c b/projects/stargazer/plugins/other/snmp/asn1/NetworkAddress.c new file mode 100644 index 00000000..2d167746 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/NetworkAddress.c @@ -0,0 +1,57 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "NetworkAddress.h" + +static asn_TYPE_member_t asn_MBR_NetworkAddress_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct NetworkAddress, choice.internet), + (ASN_TAG_CLASS_APPLICATION | (0 << 2)), + 0, + &asn_DEF_IpAddress, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "internet" + }, +}; +static asn_TYPE_tag2member_t asn_MAP_NetworkAddress_tag2el_1[] = { + { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 0, 0, 0 } /* internet at 113 */ +}; +static asn_CHOICE_specifics_t asn_SPC_NetworkAddress_specs_1 = { + sizeof(struct NetworkAddress), + offsetof(struct NetworkAddress, _asn_ctx), + offsetof(struct NetworkAddress, present), + sizeof(((struct NetworkAddress *)0)->present), + asn_MAP_NetworkAddress_tag2el_1, + 1, /* Count of tags in the map */ + 0, + -1 /* Extensions start */ +}; +asn_TYPE_descriptor_t asn_DEF_NetworkAddress = { + "NetworkAddress", + "NetworkAddress", + CHOICE_free, + CHOICE_print, + CHOICE_constraint, + CHOICE_decode_ber, + CHOICE_encode_der, + CHOICE_decode_xer, + CHOICE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + CHOICE_outmost_tag, + 0, /* No effective tags (pointer) */ + 0, /* No effective tags (count) */ + 0, /* No tags (pointer) */ + 0, /* No tags (count) */ + 0, /* No PER visible constraints */ + asn_MBR_NetworkAddress_1, + 1, /* Elements count */ + &asn_SPC_NetworkAddress_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/NetworkAddress.h b/projects/stargazer/plugins/other/snmp/asn1/NetworkAddress.h new file mode 100644 index 00000000..8c73220b --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/NetworkAddress.h @@ -0,0 +1,46 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _NetworkAddress_H_ +#define _NetworkAddress_H_ + + +#include + +/* Including external dependencies */ +#include "IpAddress.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum NetworkAddress_PR { + NetworkAddress_PR_NOTHING, /* No components present */ + NetworkAddress_PR_internet +} NetworkAddress_PR; + +/* NetworkAddress */ +typedef struct NetworkAddress { + NetworkAddress_PR present; + union NetworkAddress_u { + IpAddress_t internet; + } choice; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} NetworkAddress_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_NetworkAddress; + +#ifdef __cplusplus +} +#endif + +#endif /* _NetworkAddress_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/OBJECT_IDENTIFIER.c b/projects/stargazer/plugins/other/snmp/asn1/OBJECT_IDENTIFIER.c new file mode 100644 index 00000000..b1666dc6 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/OBJECT_IDENTIFIER.c @@ -0,0 +1,727 @@ +/*- + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include +#include /* for CHAR_BIT */ +#include + +/* + * OBJECT IDENTIFIER basic type description. + */ +static ber_tlv_tag_t asn_DEF_OBJECT_IDENTIFIER_tags[] = { + (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_OBJECT_IDENTIFIER = { + "OBJECT IDENTIFIER", + "OBJECT_IDENTIFIER", + ASN__PRIMITIVE_TYPE_free, + OBJECT_IDENTIFIER_print, + OBJECT_IDENTIFIER_constraint, + ber_decode_primitive, + der_encode_primitive, + OBJECT_IDENTIFIER_decode_xer, + OBJECT_IDENTIFIER_encode_xer, + 0, 0, + 0, /* Use generic outmost tag fetcher */ + asn_DEF_OBJECT_IDENTIFIER_tags, + sizeof(asn_DEF_OBJECT_IDENTIFIER_tags) + / sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]), + asn_DEF_OBJECT_IDENTIFIER_tags, /* Same as above */ + sizeof(asn_DEF_OBJECT_IDENTIFIER_tags) + / sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]), + 0, /* No PER visible constraints */ + 0, 0, /* No members */ + 0 /* No specifics */ +}; + + +int +OBJECT_IDENTIFIER_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr; + + if(st && st->buf) { + if(st->size < 1) { + _ASN_CTFAIL(app_key, td, + "%s: at least one numerical value " + "expected (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + } else { + _ASN_CTFAIL(app_key, td, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + return 0; +} + + +int +OBJECT_IDENTIFIER_get_single_arc(uint8_t *arcbuf, unsigned int arclen, signed int add, void *rvbufp, unsigned int rvsize) { + unsigned LE __attribute__ ((unused)) = 1; /* Little endian (x86) */ + uint8_t *arcend = arcbuf + arclen; /* End of arc */ + unsigned int cache = 0; /* No more than 14 significant bits */ + unsigned char *rvbuf = (unsigned char *)rvbufp; + unsigned char *rvstart = rvbuf; /* Original start of the value buffer */ + int inc; /* Return value growth direction */ + + rvsize *= CHAR_BIT; /* bytes to bits */ + arclen *= 7; /* bytes to bits */ + + /* + * The arc has the number of bits + * cannot be represented using supplied return value type. + */ + if(arclen > rvsize) { + if(arclen > (rvsize + CHAR_BIT)) { + errno = ERANGE; /* Overflow */ + return -1; + } else { + /* + * Even if the number of bits in the arc representation + * is higher than the width of supplied * return value + * type, there is still possible to fit it when there + * are few unused high bits in the arc value + * representaion. + * + * Moreover, there is a possibility that the + * number could actually fit the arc space, given + * that add is negative, but we don't handle + * such "temporary lack of precision" situation here. + * May be considered as a bug. + */ + uint8_t mask = (0xff << (7-(arclen - rvsize))) & 0x7f; + if((*arcbuf & mask)) { + errno = ERANGE; /* Overflow */ + return -1; + } + /* Fool the routine computing unused bits */ + arclen -= 7; + cache = *arcbuf & 0x7f; + arcbuf++; + } + } + + /* Faster path for common size */ + if(rvsize == (CHAR_BIT * sizeof(unsigned long))) { + unsigned long accum; + /* Gather all bits into the accumulator */ + for(accum = cache; arcbuf < arcend; arcbuf++) + accum = (accum << 7) | (*arcbuf & ~0x80); + if(accum < (unsigned)-add) { + errno = ERANGE; /* Overflow */ + return -1; + } + *(unsigned long *)rvbuf = accum + add; /* alignment OK! */ + return 0; + } + +#ifndef WORDS_BIGENDIAN + if(*(unsigned char *)&LE) { /* Little endian (x86) */ + /* "Convert" to big endian */ + rvbuf += rvsize / CHAR_BIT - 1; + rvstart--; + inc = -1; /* Descending */ + } else +#endif /* !WORDS_BIGENDIAN */ + inc = +1; /* Big endian is known [at compile time] */ + + { + int bits; /* typically no more than 3-4 bits */ + + /* Clear the high unused bits */ + for(bits = rvsize - arclen; + bits > CHAR_BIT; + rvbuf += inc, bits -= CHAR_BIT) + *rvbuf = 0; + + /* Fill the body of a value */ + for(; arcbuf < arcend; arcbuf++) { + cache = (cache << 7) | (*arcbuf & 0x7f); + bits += 7; + if(bits >= CHAR_BIT) { + bits -= CHAR_BIT; + *rvbuf = (cache >> bits); + rvbuf += inc; + } + } + if(bits) { + *rvbuf = cache; + rvbuf += inc; + } + } + + if(add) { + for(rvbuf -= inc; rvbuf != rvstart; rvbuf -= inc) { + int v = add + *rvbuf; + if(v & (-1 << CHAR_BIT)) { + *rvbuf = (unsigned char)(v + (1 << CHAR_BIT)); + add = -1; + } else { + *rvbuf = v; + break; + } + } + if(rvbuf == rvstart) { + /* No space to carry over */ + errno = ERANGE; /* Overflow */ + return -1; + } + } + + return 0; +} + +ssize_t +OBJECT_IDENTIFIER__dump_arc(uint8_t *arcbuf, int arclen, int add, + asn_app_consume_bytes_f *cb, void *app_key) { + char scratch[64]; /* Conservative estimate */ + unsigned long accum; /* Bits accumulator */ + char *p; /* Position in the scratch buffer */ + + if(OBJECT_IDENTIFIER_get_single_arc(arcbuf, arclen, add, + &accum, sizeof(accum))) + return -1; + + if(accum) { + ssize_t len; + + /* Fill the scratch buffer in reverse. */ + p = scratch + sizeof(scratch); + for(; accum; accum /= 10) + *(--p) = (char)(accum % 10) + 0x30; /* Put a digit */ + + len = sizeof(scratch) - (p - scratch); + if(cb(p, len, app_key) < 0) + return -1; + return len; + } else { + *scratch = 0x30; + if(cb(scratch, 1, app_key) < 0) + return -1; + return 1; + } +} + +int +OBJECT_IDENTIFIER_print_arc(uint8_t *arcbuf, int arclen, int add, + asn_app_consume_bytes_f *cb, void *app_key) { + + if(OBJECT_IDENTIFIER__dump_arc(arcbuf, arclen, add, cb, app_key) < 0) + return -1; + + return 0; +} + +static ssize_t +OBJECT_IDENTIFIER__dump_body(const OBJECT_IDENTIFIER_t *st, asn_app_consume_bytes_f *cb, void *app_key) { + ssize_t wrote_len = 0; + int startn; + int add = 0; + int i; + + for(i = 0, startn = 0; i < st->size; i++) { + uint8_t b = st->buf[i]; + if((b & 0x80)) /* Continuation expected */ + continue; + + if(startn == 0) { + /* + * First two arcs are encoded through the backdoor. + */ + if(i) { + add = -80; + if(cb("2", 1, app_key) < 0) return -1; + } else if(b <= 39) { + add = 0; + if(cb("0", 1, app_key) < 0) return -1; + } else if(b < 79) { + add = -40; + if(cb("1", 1, app_key) < 0) return -1; + } else { + add = -80; + if(cb("2", 1, app_key) < 0) return -1; + } + wrote_len += 1; + } + + if(cb(".", 1, app_key) < 0) /* Separate arcs */ + return -1; + + add = OBJECT_IDENTIFIER__dump_arc(&st->buf[startn], + i - startn + 1, add, cb, app_key); + if(add < 0) return -1; + wrote_len += 1 + add; + startn = i + 1; + add = 0; + } + + return wrote_len; +} + +static enum xer_pbd_rval +OBJECT_IDENTIFIER__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) { + OBJECT_IDENTIFIER_t *st = (OBJECT_IDENTIFIER_t *)sptr; + const char *chunk_end = (const char *)chunk_buf + chunk_size; + const char *endptr; + long s_arcs[10]; + long *arcs = s_arcs; + int arcs_count; + int ret; + + (void)td; + + arcs_count = OBJECT_IDENTIFIER_parse_arcs( + (const char *)chunk_buf, chunk_size, arcs, + sizeof(s_arcs)/sizeof(s_arcs[0]), &endptr); + if(arcs_count <= 0) { + /* Expecting more than zero arcs */ + return XPBD_BROKEN_ENCODING; + } + if(endptr < chunk_end) { + /* We have a tail of unrecognized data. Check its safety. */ + if(!xer_is_whitespace(endptr, chunk_end - endptr)) + return XPBD_BROKEN_ENCODING; + } + + if((size_t)arcs_count > sizeof(s_arcs)/sizeof(s_arcs[0])) { + arcs = (long *)MALLOC(arcs_count * sizeof(long)); + if(!arcs) return XPBD_SYSTEM_FAILURE; + ret = OBJECT_IDENTIFIER_parse_arcs( + (const char *)chunk_buf, chunk_size, + arcs, arcs_count, &endptr); + if(ret != arcs_count) + return XPBD_SYSTEM_FAILURE; /* assert?.. */ + } + + /* + * Convert arcs into BER representation. + */ + ret = OBJECT_IDENTIFIER_set_arcs(st, arcs, sizeof(*arcs), arcs_count); + if(arcs != s_arcs) FREEMEM(arcs); + + return ret ? XPBD_SYSTEM_FAILURE : XPBD_BODY_CONSUMED; +} + +asn_dec_rval_t +OBJECT_IDENTIFIER_decode_xer(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname, + const void *buf_ptr, size_t size) { + + return xer_decode_primitive(opt_codec_ctx, td, + sptr, sizeof(OBJECT_IDENTIFIER_t), opt_mname, + buf_ptr, size, OBJECT_IDENTIFIER__xer_body_decode); +} + +asn_enc_rval_t +OBJECT_IDENTIFIER_encode_xer(asn_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr; + asn_enc_rval_t er; + + (void)ilevel; + (void)flags; + + if(!st || !st->buf) + _ASN_ENCODE_FAILED; + + er.encoded = OBJECT_IDENTIFIER__dump_body(st, cb, app_key); + if(er.encoded < 0) _ASN_ENCODE_FAILED; + + _ASN_ENCODED_OK(er); +} + +int +OBJECT_IDENTIFIER_print(asn_TYPE_descriptor_t *td, const void *sptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr; + + (void)td; /* Unused argument */ + (void)ilevel; /* Unused argument */ + + if(!st || !st->buf) + return (cb("", 8, app_key) < 0) ? -1 : 0; + + /* Dump preamble */ + if(cb("{ ", 2, app_key) < 0) + return -1; + + if(OBJECT_IDENTIFIER__dump_body(st, cb, app_key) < 0) + return -1; + + return (cb(" }", 2, app_key) < 0) ? -1 : 0; +} + +int +OBJECT_IDENTIFIER_get_arcs(OBJECT_IDENTIFIER_t *oid, void *arcs, + unsigned int arc_type_size, unsigned int arc_slots) { + void *arcs_end = (char *)arcs + (arc_type_size * arc_slots); + int num_arcs = 0; + int startn = 0; + int add = 0; + int i; + + if(!oid || !oid->buf || (arc_slots && arc_type_size <= 1)) { + errno = EINVAL; + return -1; + } + + for(i = 0; i < oid->size; i++) { + uint8_t b = oid->buf[i]; + if((b & 0x80)) /* Continuation expected */ + continue; + + if(num_arcs == 0) { + /* + * First two arcs are encoded through the backdoor. + */ + unsigned LE = 1; /* Little endian */ + int first_arc; + num_arcs++; + if(!arc_slots) { num_arcs++; continue; } + + if(i) first_arc = 2; + else if(b <= 39) first_arc = 0; + else if(b < 79) first_arc = 1; + else first_arc = 2; + + add = -40 * first_arc; + memset(arcs, 0, arc_type_size); + *(unsigned char *)((char *)arcs + + ((*(char *)&LE)?0:(arc_type_size - 1))) + = first_arc; + arcs = ((char *)arcs) + arc_type_size; + } + + /* Decode, if has space */ + if(arcs < arcs_end) { + if(OBJECT_IDENTIFIER_get_single_arc(&oid->buf[startn], + i - startn + 1, add, + arcs, arc_type_size)) + return -1; + startn = i + 1; + arcs = ((char *)arcs) + arc_type_size; + add = 0; + } + num_arcs++; + } + + return num_arcs; +} + + +/* + * Save the single value as an object identifier arc. + */ +int +OBJECT_IDENTIFIER_set_single_arc(uint8_t *arcbuf, const void *arcval, unsigned int arcval_size, int prepared_order) { + /* + * The following conditions must hold: + * assert(arcval); + * assert(arcval_size > 0); + * assert(arcval_size <= 16); + * assert(arcbuf); + */ +#ifdef WORDS_BIGENDIAN + const unsigned isLittleEndian = 0; +#else + unsigned LE = 1; + unsigned isLittleEndian = *(char *)&LE; +#endif + const uint8_t *tend, *tp; + unsigned int cache; + uint8_t *bp = arcbuf; + int bits; + uint8_t buffer[16]; + + if(isLittleEndian && !prepared_order) { + const uint8_t *a = (const unsigned char *)arcval + arcval_size - 1; + const uint8_t *aend = (const uint8_t *)arcval; + uint8_t *msb = buffer + arcval_size - 1; + uint8_t *tb; + for(tb = buffer; a >= aend; tb++, a--) + if((*tb = *a) && (tb < msb)) + msb = tb; + tend = &buffer[arcval_size]; + tp = msb; /* Most significant non-zero byte */ + } else { + /* Look for most significant non-zero byte */ + tend = (const unsigned char *)arcval + arcval_size; + for(tp = (const uint8_t *)arcval; tp < tend - 1; tp++) + if(*tp) break; + } + + /* + * Split the value in 7-bits chunks. + */ + bits = ((tend - tp) * CHAR_BIT) % 7; + if(bits) { + cache = *tp >> (CHAR_BIT - bits); + if(cache) { + *bp++ = cache | 0x80; + cache = *tp++; + bits = CHAR_BIT - bits; + } else { + bits = -bits; + } + } else { + cache = 0; + } + for(; tp < tend; tp++) { + cache = (cache << CHAR_BIT) + *tp; + bits += CHAR_BIT; + while(bits >= 7) { + bits -= 7; + *bp++ = 0x80 | (cache >> bits); + } + } + if(bits) *bp++ = cache; + bp[-1] &= 0x7f; /* Clear the last bit */ + + return bp - arcbuf; +} + +int +OBJECT_IDENTIFIER_set_arcs(OBJECT_IDENTIFIER_t *oid, const void *arcs, unsigned int arc_type_size, unsigned int arc_slots) { + uint8_t *buf; + uint8_t *bp; + unsigned LE = 1; /* Little endian (x86) */ + unsigned isLittleEndian = *((char *)&LE); + unsigned int arc0; + unsigned int arc1; + unsigned size; + unsigned i; + + if(!oid || !arcs || arc_type_size < 1 + || arc_type_size > 16 + || arc_slots < 2) { + errno = EINVAL; + return -1; + } + + switch(arc_type_size) { + case sizeof(char): + arc0 = ((const unsigned char *)arcs)[0]; + arc1 = ((const unsigned char *)arcs)[1]; + break; + case sizeof(short): + arc0 = ((const unsigned short *)arcs)[0]; + arc1 = ((const unsigned short *)arcs)[1]; + break; + case sizeof(int): + arc0 = ((const unsigned int *)arcs)[0]; + arc1 = ((const unsigned int *)arcs)[1]; + break; + default: + arc1 = arc0 = 0; + if(isLittleEndian) { /* Little endian (x86) */ + const unsigned char *ps, *pe; + /* If more significant bytes are present, + * make them > 255 quick */ + for(ps = (const unsigned char *)arcs + 1, pe = ps+arc_type_size; + ps < pe; ps++) + arc0 |= *ps, arc1 |= *(ps + arc_type_size); + arc0 <<= CHAR_BIT, arc1 <<= CHAR_BIT; + arc0 = *((const unsigned char *)arcs + 0); + arc1 = *((const unsigned char *)arcs + arc_type_size); + } else { + const unsigned char *ps, *pe; + /* If more significant bytes are present, + * make them > 255 quick */ + for(ps = (const unsigned char *)arcs, pe = ps+arc_type_size - 1; ps < pe; ps++) + arc0 |= *ps, arc1 |= *(ps + arc_type_size); + arc0 = *((const unsigned char *)arcs + arc_type_size - 1); + arc1 = *((const unsigned char *)arcs +(arc_type_size<< 1)-1); + } + } + + /* + * The previous chapter left us with the first and the second arcs. + * The values are not precise (that is, they are valid only if + * they're less than 255), but OK for the purposes of making + * the sanity test below. + */ + if(arc0 <= 1) { + if(arc1 >= 39) { + /* 8.19.4: At most 39 subsequent values (including 0) */ + errno = ERANGE; + return -1; + } + } else if(arc0 > 2) { + /* 8.19.4: Only three values are allocated from the root node */ + errno = ERANGE; + return -1; + } + /* + * After above tests it is known that the value of arc0 is completely + * trustworthy (0..2). However, the arc1's value is still meaningless. + */ + + /* + * Roughly estimate the maximum size necessary to encode these arcs. + * This estimation implicitly takes in account the following facts, + * that cancel each other: + * * the first two arcs are encoded in a single value. + * * the first value may require more space (+1 byte) + * * the value of the first arc which is in range (0..2) + */ + size = ((arc_type_size * CHAR_BIT + 6) / 7) * arc_slots; + bp = buf = (uint8_t *)MALLOC(size + 1); + if(!buf) { + /* ENOMEM */ + return -1; + } + + /* + * Encode the first two arcs. + * These require special treatment. + */ + { + uint8_t *tp; + uint8_t first_value[1 + 16]; /* of two arcs */ + uint8_t *fv = first_value; + + /* + * Simulate first_value = arc0 * 40 + arc1; + */ + /* Copy the second (1'st) arcs[1] into the first_value */ + *fv++ = 0; + arcs = ((const char *)arcs) + arc_type_size; + if(isLittleEndian) { + const uint8_t *aend = (const unsigned char *)arcs - 1; + const uint8_t *a1 = (const unsigned char *)arcs + arc_type_size - 1; + for(; a1 > aend; fv++, a1--) *fv = *a1; + } else { + const uint8_t *a1 = (const uint8_t *)arcs; + const uint8_t *aend = a1 + arc_type_size; + for(; a1 < aend; fv++, a1++) *fv = *a1; + } + /* Increase the first_value by arc0 */ + arc0 *= 40; /* (0..80) */ + for(tp = first_value + arc_type_size; tp >= first_value; tp--) { + unsigned int v = *tp; + v += arc0; + *tp = v; + if(v >= (1 << CHAR_BIT)) arc0 = v >> CHAR_BIT; + else break; + } + + assert(tp >= first_value); + + bp += OBJECT_IDENTIFIER_set_single_arc(bp, first_value, + fv - first_value, 1); + } + + /* + * Save the rest of arcs. + */ + for(arcs = ((const char *)arcs) + arc_type_size, i = 2; + i < arc_slots; + i++, arcs = ((const char *)arcs) + arc_type_size) { + bp += OBJECT_IDENTIFIER_set_single_arc(bp, + arcs, arc_type_size, 0); + } + + assert((unsigned)(bp - buf) <= size); + + /* + * Replace buffer. + */ + oid->size = bp - buf; + bp = oid->buf; + oid->buf = buf; + if(bp) FREEMEM(bp); + + return 0; +} + + +int +OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length, + long *arcs, unsigned int arcs_slots, const char **opt_oid_text_end) { + unsigned int arcs_count = 0; + const char *oid_end; + long value = 0; + enum { + ST_SKIPSPACE, + ST_WAITDIGITS, /* Next character is expected to be a digit */ + ST_DIGITS + } state = ST_SKIPSPACE; + + if(!oid_text || oid_txt_length < -1 || (arcs_slots && !arcs)) { + if(opt_oid_text_end) *opt_oid_text_end = oid_text; + errno = EINVAL; + return -1; + } + + if(oid_txt_length == -1) + oid_txt_length = strlen(oid_text); + + for(oid_end = oid_text + oid_txt_length; oid_text. + * All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _OBJECT_IDENTIFIER_H_ +#define _OBJECT_IDENTIFIER_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef ASN__PRIMITIVE_TYPE_t OBJECT_IDENTIFIER_t; + +extern asn_TYPE_descriptor_t asn_DEF_OBJECT_IDENTIFIER; + +asn_struct_print_f OBJECT_IDENTIFIER_print; +asn_constr_check_f OBJECT_IDENTIFIER_constraint; +der_type_encoder_f OBJECT_IDENTIFIER_encode_der; +xer_type_decoder_f OBJECT_IDENTIFIER_decode_xer; +xer_type_encoder_f OBJECT_IDENTIFIER_encode_xer; + +/********************************** + * Some handy conversion routines * + **********************************/ + +/* + * This function fills an (_arcs) array with OBJECT IDENTIFIER arcs + * up to specified (_arc_slots) elements. + * + * EXAMPLE: + * void print_arcs(OBJECT_IDENTIFIER_t *oid) { + * unsigned long fixed_arcs[10]; // Try with fixed space first + * unsigned long *arcs = fixed_arcs; + * int arc_type_size = sizeof(fixed_arcs[0]); // sizeof(long) + * int arc_slots = sizeof(fixed_arcs)/sizeof(fixed_arcs[0]); // 10 + * int count; // Real number of arcs. + * int i; + * + * count = OBJECT_IDENTIFIER_get_arcs(oid, arcs, + * arc_type_size, arc_slots); + * // If necessary, reallocate arcs array and try again. + * if(count > arc_slots) { + * arc_slots = count; + * arcs = malloc(arc_type_size * arc_slots); + * if(!arcs) return; + * count = OBJECT_IDENTIFIER_get_arcs(oid, arcs, + * arc_type_size, arc_slots); + * assert(count == arc_slots); + * } + * + * // Print the contents of the arcs array. + * for(i = 0; i < count; i++) + * printf("%d\n", arcs[i]); + * + * // Avoid memory leak. + * if(arcs != fixed_arcs) free(arcs); + * } + * + * RETURN VALUES: + * -1/EINVAL: Invalid arguments (oid is missing) + * -1/ERANGE: One or more arcs have value out of array cell type range. + * >=0: Number of arcs contained in the OBJECT IDENTIFIER + * + * WARNING: The function always returns the real number of arcs, + * even if there is no sufficient (_arc_slots) provided. + */ +int OBJECT_IDENTIFIER_get_arcs(OBJECT_IDENTIFIER_t *_oid, + void *_arcs, /* e.g., unsigned int arcs[N] */ + unsigned int _arc_type_size, /* e.g., sizeof(arcs[0]) */ + unsigned int _arc_slots /* e.g., N */); + +/* + * This functions initializes the OBJECT IDENTIFIER object with + * the given set of arcs. + * The minimum of two arcs must be present; some restrictions apply. + * RETURN VALUES: + * -1/EINVAL: Invalid arguments + * -1/ERANGE: The first two arcs do not conform to ASN.1 restrictions. + * -1/ENOMEM: Memory allocation failed + * 0: The object was initialized with new arcs. + */ +int OBJECT_IDENTIFIER_set_arcs(OBJECT_IDENTIFIER_t *_oid, + const void *_arcs, /* e.g., unsigned int arcs[N] */ + unsigned int _arc_type_size, /* e.g., sizeof(arcs[0]) */ + unsigned int _arc_slots /* e.g., N */); + +/* + * Print the specified OBJECT IDENTIFIER arc. + */ +int OBJECT_IDENTIFIER_print_arc(uint8_t *arcbuf, int arclen, + int add, /* Arbitrary offset, required to process the first two arcs */ + asn_app_consume_bytes_f *cb, void *app_key); + +/* Same as above, but returns the number of written digits, instead of 0 */ +ssize_t OBJECT_IDENTIFIER__dump_arc(uint8_t *arcbuf, int arclen, int add, + asn_app_consume_bytes_f *cb, void *app_key); + +/* + * Parse the OBJECT IDENTIFIER textual representation ("1.3.6.1.4.1.9363"). + * No arc can exceed the (0..signed_long_max) range (typically, 0..2G if L32). + * This function is not specific to OBJECT IDENTIFIER, it may be used to parse + * the RELATIVE-OID data, or any other data consisting of dot-separated + * series of numeric values. + * + * If (oid_txt_length == -1), the strlen() will be invoked to determine the + * size of the (oid_text) string. + * + * After return, the optional (opt_oid_text_end) is set to the character after + * the last parsed one. (opt_oid_text_end) is never less than (oid_text). + * + * RETURN VALUES: + * -1: Parse error. + * >= 0: Number of arcs contained in the OBJECT IDENTIFIER. + * + * WARNING: The function always returns the real number of arcs, + * even if there is no sufficient (_arc_slots) provided. + * This is useful for (_arc_slots) value estimation. + */ +int OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length, + long arcs[], unsigned int arcs_slots, const char **opt_oid_text_end); + +/* + * Internal functions. + * Used by RELATIVE-OID implementation in particular. + */ +int OBJECT_IDENTIFIER_get_single_arc(uint8_t *arcbuf, unsigned int arclen, + signed int add, void *value, unsigned int value_size); +int OBJECT_IDENTIFIER_set_single_arc(uint8_t *arcbuf, + const void *arcval, unsigned int arcval_size, int _prepared_order); + +#ifdef __cplusplus +} +#endif + +#endif /* _OBJECT_IDENTIFIER_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/OCTET_STRING.c b/projects/stargazer/plugins/other/snmp/asn1/OCTET_STRING.c new file mode 100644 index 00000000..3a83bd98 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/OCTET_STRING.c @@ -0,0 +1,1550 @@ +/*- + * Copyright (c) 2003, 2004, 2005, 2006 Lev Walkin . + * All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include +#include /* for .bits_unused member */ +#include + +/* + * OCTET STRING basic type description. + */ +static ber_tlv_tag_t asn_DEF_OCTET_STRING_tags[] = { + (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)) +}; +static asn_OCTET_STRING_specifics_t asn_DEF_OCTET_STRING_specs = { + sizeof(OCTET_STRING_t), + offsetof(OCTET_STRING_t, _asn_ctx), + 0 +}; +static asn_per_constraint_t asn_DEF_OCTET_STRING_constraint = { + APC_SEMI_CONSTRAINED, -1, -1, 0, 0 +}; +asn_TYPE_descriptor_t asn_DEF_OCTET_STRING = { + "OCTET STRING", /* Canonical name */ + "OCTET_STRING", /* XML tag name */ + OCTET_STRING_free, + OCTET_STRING_print, /* non-ascii stuff, generally */ + asn_generic_no_constraint, + OCTET_STRING_decode_ber, + OCTET_STRING_encode_der, + OCTET_STRING_decode_xer_hex, + OCTET_STRING_encode_xer, + OCTET_STRING_decode_uper, /* Unaligned PER decoder */ + OCTET_STRING_encode_uper, /* Unaligned PER encoder */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_OCTET_STRING_tags, + sizeof(asn_DEF_OCTET_STRING_tags) + / sizeof(asn_DEF_OCTET_STRING_tags[0]), + asn_DEF_OCTET_STRING_tags, /* Same as above */ + sizeof(asn_DEF_OCTET_STRING_tags) + / sizeof(asn_DEF_OCTET_STRING_tags[0]), + 0, /* No PER visible constraints */ + 0, 0, /* No members */ + &asn_DEF_OCTET_STRING_specs +}; + +#undef _CH_PHASE +#undef NEXT_PHASE +#undef PREV_PHASE +#define _CH_PHASE(ctx, inc) do { \ + if(ctx->phase == 0) \ + ctx->context = 0; \ + ctx->phase += inc; \ + } while(0) +#define NEXT_PHASE(ctx) _CH_PHASE(ctx, +1) +#define PREV_PHASE(ctx) _CH_PHASE(ctx, -1) + +#undef ADVANCE +#define ADVANCE(num_bytes) do { \ + size_t num = (num_bytes); \ + buf_ptr = ((const char *)buf_ptr) + num; \ + size -= num; \ + consumed_myself += num; \ + } while(0) + +#undef RETURN +#define RETURN(_code) do { \ + asn_dec_rval_t tmprval; \ + tmprval.code = _code; \ + tmprval.consumed = consumed_myself; \ + return tmprval; \ + } while(0) + +#undef APPEND +#define APPEND(bufptr, bufsize) do { \ + size_t _bs = (bufsize); /* Append size */ \ + size_t _ns = ctx->context; /* Allocated now */ \ + size_t _es = st->size + _bs; /* Expected size */ \ + /* int is really a typeof(st->size): */ \ + if((int)_es < 0) RETURN(RC_FAIL); \ + if(_ns <= _es) { \ + void *ptr; \ + /* Be nice and round to the memory allocator */ \ + do { _ns = _ns ? _ns << 1 : 16; } \ + while(_ns <= _es); \ + /* int is really a typeof(st->size): */ \ + if((int)_ns < 0) RETURN(RC_FAIL); \ + ptr = REALLOC(st->buf, _ns); \ + if(ptr) { \ + st->buf = (uint8_t *)ptr; \ + ctx->context = _ns; \ + } else { \ + RETURN(RC_FAIL); \ + } \ + ASN_DEBUG("Reallocating into %ld", (long)_ns); \ + } \ + memcpy(st->buf + st->size, bufptr, _bs); \ + /* Convenient nul-termination */ \ + st->buf[_es] = '\0'; \ + st->size = _es; \ + } while(0) + +/* + * Internal variant of the OCTET STRING. + */ +typedef enum OS_type { + _TT_GENERIC = 0, /* Just a random OCTET STRING */ + _TT_BIT_STRING = 1, /* BIT STRING type, a special case */ + _TT_ANY = 2 /* ANY type, a special case too */ +} OS_type_e; + +/* + * The main reason why ASN.1 is still alive is that too much time and effort + * is necessary for learning it more or less adequately, thus creating a gut + * necessity to demonstrate that aquired skill everywhere afterwards. + * No, I am not going to explain what the following stuff is. + */ +struct _stack_el { + ber_tlv_len_t left; /* What's left to read (or -1) */ + ber_tlv_len_t got; /* What was actually processed */ + int cont_level; /* Depth of subcontainment */ + int want_nulls; /* Want null "end of content" octets? */ + int bits_chopped; /* Flag in BIT STRING mode */ + ber_tlv_tag_t tag; /* For debugging purposes */ + struct _stack_el *prev; + struct _stack_el *next; +}; +struct _stack { + struct _stack_el *tail; + struct _stack_el *cur_ptr; +}; + +static struct _stack_el * +OS__add_stack_el(struct _stack *st) { + struct _stack_el *nel; + + /* + * Reuse the old stack frame or allocate a new one. + */ + if(st->cur_ptr && st->cur_ptr->next) { + nel = st->cur_ptr->next; + nel->bits_chopped = 0; + nel->got = 0; + /* Retain the nel->cont_level, it's correct. */ + } else { + nel = (struct _stack_el *)CALLOC(1, sizeof(struct _stack_el)); + if(nel == NULL) + return NULL; + + if(st->tail) { + /* Increase a subcontainment depth */ + nel->cont_level = st->tail->cont_level + 1; + st->tail->next = nel; + } + nel->prev = st->tail; + st->tail = nel; + } + + st->cur_ptr = nel; + + return nel; +} + +static struct _stack * +_new_stack() { + return (struct _stack *)CALLOC(1, sizeof(struct _stack)); +} + +/* + * Decode OCTET STRING type. + */ +asn_dec_rval_t +OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *td, + void **sptr, const void *buf_ptr, size_t size, int tag_mode) { + asn_OCTET_STRING_specifics_t *specs = td->specifics + ? (asn_OCTET_STRING_specifics_t *)td->specifics + : &asn_DEF_OCTET_STRING_specs; + BIT_STRING_t *st = (BIT_STRING_t *)*sptr; + asn_dec_rval_t rval; + asn_struct_ctx_t *ctx; + ssize_t consumed_myself = 0; + struct _stack *stck; /* Expectations stack structure */ + struct _stack_el *sel = 0; /* Stack element */ + int tlv_constr; + OS_type_e type_variant = (OS_type_e)specs->subvariant; + + ASN_DEBUG("Decoding %s as %s (frame %ld)", + td->name, + (type_variant == _TT_GENERIC) ? + "OCTET STRING" : "OS-SpecialCase", + (long)size); + + /* + * Create the string if does not exist. + */ + if(st == NULL) { + st = (BIT_STRING_t *)(*sptr = CALLOC(1, specs->struct_size)); + if(st == NULL) RETURN(RC_FAIL); + } + + /* Restore parsing context */ + ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset); + + switch(ctx->phase) { + case 0: + /* + * Check tags. + */ + rval = ber_check_tags(opt_codec_ctx, td, ctx, + buf_ptr, size, tag_mode, -1, + &ctx->left, &tlv_constr); + if(rval.code != RC_OK) + return rval; + + if(tlv_constr) { + /* + * Complex operation, requires stack of expectations. + */ + ctx->ptr = _new_stack(); + if(ctx->ptr) { + stck = (struct _stack *)ctx->ptr; + } else { + RETURN(RC_FAIL); + } + } else { + /* + * Jump into stackless primitive decoding. + */ + _CH_PHASE(ctx, 3); + if(type_variant == _TT_ANY && tag_mode != 1) + APPEND(buf_ptr, rval.consumed); + ADVANCE(rval.consumed); + goto phase3; + } + + NEXT_PHASE(ctx); + /* Fall through */ + case 1: + phase1: + /* + * Fill the stack with expectations. + */ + stck = (struct _stack *)ctx->ptr; + sel = stck->cur_ptr; + do { + ber_tlv_tag_t tlv_tag; + ber_tlv_len_t tlv_len; + ber_tlv_tag_t expected_tag; + ssize_t tl, ll, tlvl; + /* This one works even if (sel->left == -1) */ + ssize_t Left = ((!sel||(size_t)sel->left >= size) + ?(ssize_t)size:sel->left); + + + ASN_DEBUG("%p, s->l=%ld, s->wn=%ld, s->g=%ld\n", sel, + (long)(sel?sel->left:0), + (long)(sel?sel->want_nulls:0), + (long)(sel?sel->got:0) + ); + if(sel && sel->left <= 0 && sel->want_nulls == 0) { + if(sel->prev) { + struct _stack_el *prev = sel->prev; + if(prev->left != -1) { + if(prev->left < sel->got) + RETURN(RC_FAIL); + prev->left -= sel->got; + } + prev->got += sel->got; + sel = stck->cur_ptr = prev; + if(!sel) break; + tlv_constr = 1; + continue; + } else { + sel = stck->cur_ptr = 0; + break; /* Nothing to wait */ + } + } + + tl = ber_fetch_tag(buf_ptr, Left, &tlv_tag); + ASN_DEBUG("fetch tag(size=%ld,L=%ld), %sstack, left=%ld, wn=%ld, tl=%ld", + (long)size, (long)Left, sel?"":"!", + (long)(sel?sel->left:0), + (long)(sel?sel->want_nulls:0), + (long)tl); + switch(tl) { + case -1: RETURN(RC_FAIL); + case 0: RETURN(RC_WMORE); + } + + tlv_constr = BER_TLV_CONSTRUCTED(buf_ptr); + + ll = ber_fetch_length(tlv_constr, + (const char *)buf_ptr + tl,Left - tl,&tlv_len); + ASN_DEBUG("Got tag=%s, tc=%d, left=%ld, tl=%ld, len=%ld, ll=%ld", + ber_tlv_tag_string(tlv_tag), tlv_constr, + (long)Left, (long)tl, (long)tlv_len, (long)ll); + switch(ll) { + case -1: RETURN(RC_FAIL); + case 0: RETURN(RC_WMORE); + } + + if(sel && sel->want_nulls + && ((const uint8_t *)buf_ptr)[0] == 0 + && ((const uint8_t *)buf_ptr)[1] == 0) + { + + ASN_DEBUG("Eat EOC; wn=%d--", sel->want_nulls); + + if(type_variant == _TT_ANY + && (tag_mode != 1 || sel->cont_level)) + APPEND("\0\0", 2); + + ADVANCE(2); + sel->got += 2; + if(sel->left != -1) { + sel->left -= 2; /* assert(sel->left >= 2) */ + } + + sel->want_nulls--; + if(sel->want_nulls == 0) { + /* Move to the next expectation */ + sel->left = 0; + tlv_constr = 1; + } + + continue; + } + + /* + * Set up expected tags, + * depending on ASN.1 type being decoded. + */ + switch(type_variant) { + case _TT_BIT_STRING: + /* X.690: 8.6.4.1, NOTE 2 */ + /* Fall through */ + case _TT_GENERIC: + default: + if(sel) { + int level = sel->cont_level; + if(level < td->all_tags_count) { + expected_tag = td->all_tags[level]; + break; + } else if(td->all_tags_count) { + expected_tag = td->all_tags + [td->all_tags_count - 1]; + break; + } + /* else, Fall through */ + } + /* Fall through */ + case _TT_ANY: + expected_tag = tlv_tag; + break; + } + + + if(tlv_tag != expected_tag) { + char buf[2][32]; + ber_tlv_tag_snprint(tlv_tag, + buf[0], sizeof(buf[0])); + ber_tlv_tag_snprint(td->tags[td->tags_count-1], + buf[1], sizeof(buf[1])); + ASN_DEBUG("Tag does not match expectation: %s != %s", + buf[0], buf[1]); + RETURN(RC_FAIL); + } + + tlvl = tl + ll; /* Combined length of T and L encoding */ + if((tlv_len + tlvl) < 0) { + /* tlv_len value is too big */ + ASN_DEBUG("TLV encoding + length (%ld) is too big", + (long)tlv_len); + RETURN(RC_FAIL); + } + + /* + * Append a new expectation. + */ + sel = OS__add_stack_el(stck); + if(!sel) RETURN(RC_FAIL); + + sel->tag = tlv_tag; + + sel->want_nulls = (tlv_len==-1); + if(sel->prev && sel->prev->left != -1) { + /* Check that the parent frame is big enough */ + if(sel->prev->left < tlvl + (tlv_len==-1?0:tlv_len)) + RETURN(RC_FAIL); + if(tlv_len == -1) + sel->left = sel->prev->left - tlvl; + else + sel->left = tlv_len; + } else { + sel->left = tlv_len; + } + if(type_variant == _TT_ANY + && (tag_mode != 1 || sel->cont_level)) + APPEND(buf_ptr, tlvl); + sel->got += tlvl; + ADVANCE(tlvl); + + ASN_DEBUG("+EXPECT2 got=%ld left=%ld, wn=%d, clvl=%d", + (long)sel->got, (long)sel->left, + sel->want_nulls, sel->cont_level); + + } while(tlv_constr); + if(sel == NULL) { + /* Finished operation, "phase out" */ + ASN_DEBUG("Phase out"); + _CH_PHASE(ctx, +3); + break; + } + + NEXT_PHASE(ctx); + /* Fall through */ + case 2: + stck = (struct _stack *)ctx->ptr; + sel = stck->cur_ptr; + ASN_DEBUG("Phase 2: Need %ld bytes, size=%ld, alrg=%ld, wn=%d", + (long)sel->left, (long)size, (long)sel->got, + sel->want_nulls); + { + ber_tlv_len_t len; + + assert(sel->left >= 0); + + len = ((ber_tlv_len_t)size < sel->left) + ? (ber_tlv_len_t)size : sel->left; + if(len > 0) { + if(type_variant == _TT_BIT_STRING + && sel->bits_chopped == 0) { + /* Put the unused-bits-octet away */ + st->bits_unused = *(const uint8_t *)buf_ptr; + APPEND(((const char *)buf_ptr+1), (len - 1)); + sel->bits_chopped = 1; + } else { + APPEND(buf_ptr, len); + } + ADVANCE(len); + sel->left -= len; + sel->got += len; + } + + if(sel->left) { + ASN_DEBUG("OS left %ld, size = %ld, wn=%d\n", + (long)sel->left, (long)size, sel->want_nulls); + RETURN(RC_WMORE); + } + + PREV_PHASE(ctx); + goto phase1; + } + break; + case 3: + phase3: + /* + * Primitive form, no stack required. + */ + assert(ctx->left >= 0); + + if(size < (size_t)ctx->left) { + if(!size) RETURN(RC_WMORE); + if(type_variant == _TT_BIT_STRING && !ctx->context) { + st->bits_unused = *(const uint8_t *)buf_ptr; + ctx->left--; + ADVANCE(1); + } + APPEND(buf_ptr, size); + assert(ctx->context > 0); + ctx->left -= size; + ADVANCE(size); + RETURN(RC_WMORE); + } else { + if(type_variant == _TT_BIT_STRING + && !ctx->context && ctx->left) { + st->bits_unused = *(const uint8_t *)buf_ptr; + ctx->left--; + ADVANCE(1); + } + APPEND(buf_ptr, ctx->left); + ADVANCE(ctx->left); + ctx->left = 0; + + NEXT_PHASE(ctx); + } + break; + } + + if(sel) { + ASN_DEBUG("3sel p=%p, wn=%d, l=%ld, g=%ld, size=%ld", + sel->prev, sel->want_nulls, + (long)sel->left, (long)sel->got, (long)size); + if(sel->prev || sel->want_nulls > 1 || sel->left > 0) { + RETURN(RC_WMORE); + } + } + + /* + * BIT STRING-specific processing. + */ + if(type_variant == _TT_BIT_STRING && st->size) { + /* Finalize BIT STRING: zero out unused bits. */ + st->buf[st->size-1] &= 0xff << st->bits_unused; + } + + ASN_DEBUG("Took %ld bytes to encode %s: [%s]:%ld", + (long)consumed_myself, td->name, + (type_variant == _TT_GENERIC) ? (char *)st->buf : "", + (long)st->size); + + + RETURN(RC_OK); +} + +/* + * Encode OCTET STRING type using DER. + */ +asn_enc_rval_t +OCTET_STRING_encode_der(asn_TYPE_descriptor_t *td, void *sptr, + int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + asn_enc_rval_t er; + asn_OCTET_STRING_specifics_t *specs = td->specifics + ? (asn_OCTET_STRING_specifics_t *)td->specifics + : &asn_DEF_OCTET_STRING_specs; + BIT_STRING_t *st = (BIT_STRING_t *)sptr; + OS_type_e type_variant = (OS_type_e)specs->subvariant; + int fix_last_byte = 0; + + ASN_DEBUG("%s %s as OCTET STRING", + cb?"Estimating":"Encoding", td->name); + + /* + * Write tags. + */ + if(type_variant != _TT_ANY || tag_mode == 1) { + er.encoded = der_write_tags(td, + (type_variant == _TT_BIT_STRING) + st->size, + tag_mode, type_variant == _TT_ANY, tag, cb, app_key); + if(er.encoded == -1) { + er.failed_type = td; + er.structure_ptr = sptr; + return er; + } + } else { + /* Disallow: [] IMPLICIT ANY */ + assert(type_variant != _TT_ANY || tag_mode != -1); + er.encoded = 0; + } + + if(!cb) { + er.encoded += (type_variant == _TT_BIT_STRING) + st->size; + _ASN_ENCODED_OK(er); + } + + /* + * Prepare to deal with the last octet of BIT STRING. + */ + if(type_variant == _TT_BIT_STRING) { + uint8_t b = st->bits_unused & 0x07; + if(b && st->size) fix_last_byte = 1; + _ASN_CALLBACK(&b, 1); + er.encoded++; + } + + /* Invoke callback for the main part of the buffer */ + _ASN_CALLBACK(st->buf, st->size - fix_last_byte); + + /* The last octet should be stripped off the unused bits */ + if(fix_last_byte) { + uint8_t b = st->buf[st->size-1] & (0xff << st->bits_unused); + _ASN_CALLBACK(&b, 1); + } + + er.encoded += st->size; + _ASN_ENCODED_OK(er); +cb_failed: + _ASN_ENCODE_FAILED; +} + +asn_enc_rval_t +OCTET_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + static const char *h2c = "0123456789ABCDEF"; + const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr; + asn_enc_rval_t er; + char scratch[16 * 3 + 4]; + char *p = scratch; + uint8_t *buf; + uint8_t *end; + size_t i; + + if(!st || !st->buf) + _ASN_ENCODE_FAILED; + + er.encoded = 0; + + /* + * Dump the contents of the buffer in hexadecimal. + */ + buf = st->buf; + end = buf + st->size; + if(flags & XER_F_CANONICAL) { + char *scend = scratch + (sizeof(scratch) - 2); + for(; buf < end; buf++) { + if(p >= scend) { + _ASN_CALLBACK(scratch, p - scratch); + er.encoded += p - scratch; + p = scratch; + } + *p++ = h2c[(*buf >> 4) & 0x0F]; + *p++ = h2c[*buf & 0x0F]; + } + + _ASN_CALLBACK(scratch, p-scratch); /* Dump the rest */ + er.encoded += p - scratch; + } else { + for(i = 0; buf < end; buf++, i++) { + if(!(i % 16) && (i || st->size > 16)) { + _ASN_CALLBACK(scratch, p-scratch); + er.encoded += (p-scratch); + p = scratch; + _i_ASN_TEXT_INDENT(1, ilevel); + } + *p++ = h2c[(*buf >> 4) & 0x0F]; + *p++ = h2c[*buf & 0x0F]; + *p++ = 0x20; + } + if(p - scratch) { + p--; /* Remove the tail space */ + _ASN_CALLBACK(scratch, p-scratch); /* Dump the rest */ + er.encoded += p - scratch; + if(st->size > 16) + _i_ASN_TEXT_INDENT(1, ilevel-1); + } + } + + _ASN_ENCODED_OK(er); +cb_failed: + _ASN_ENCODE_FAILED; +} + +static struct OCTET_STRING__xer_escape_table_s { + char *string; + int size; +} OCTET_STRING__xer_escape_table[] = { +#define OSXET(s) { s, sizeof(s) - 1 } + OSXET("\074\156\165\154\057\076"), /* */ + OSXET("\074\163\157\150\057\076"), /* */ + OSXET("\074\163\164\170\057\076"), /* */ + OSXET("\074\145\164\170\057\076"), /* */ + OSXET("\074\145\157\164\057\076"), /* */ + OSXET("\074\145\156\161\057\076"), /* */ + OSXET("\074\141\143\153\057\076"), /* */ + OSXET("\074\142\145\154\057\076"), /* */ + OSXET("\074\142\163\057\076"), /* */ + OSXET("\011"), /* \t */ + OSXET("\012"), /* \n */ + OSXET("\074\166\164\057\076"), /* */ + OSXET("\074\146\146\057\076"), /* */ + OSXET("\015"), /* \r */ + OSXET("\074\163\157\057\076"), /* */ + OSXET("\074\163\151\057\076"), /* */ + OSXET("\074\144\154\145\057\076"), /* */ + OSXET("\074\144\143\061\057\076"), /* */ + OSXET("\074\144\143\062\057\076"), /* */ + OSXET("\074\144\143\063\057\076"), /* */ + OSXET("\074\144\143\064\057\076"), /* */ + OSXET("\074\156\141\153\057\076"), /* */ + OSXET("\074\163\171\156\057\076"), /* */ + OSXET("\074\145\164\142\057\076"), /* */ + OSXET("\074\143\141\156\057\076"), /* */ + OSXET("\074\145\155\057\076"), /* */ + OSXET("\074\163\165\142\057\076"), /* */ + OSXET("\074\145\163\143\057\076"), /* */ + OSXET("\074\151\163\064\057\076"), /* */ + OSXET("\074\151\163\063\057\076"), /* */ + OSXET("\074\151\163\062\057\076"), /* */ + OSXET("\074\151\163\061\057\076"), /* */ + { 0, 0 }, /* " " */ + { 0, 0 }, /* ! */ + { 0, 0 }, /* \" */ + { 0, 0 }, /* # */ + { 0, 0 }, /* $ */ + { 0, 0 }, /* % */ + OSXET("\046\141\155\160\073"), /* & */ + { 0, 0 }, /* ' */ + {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, /* ()*+,-./ */ + {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, /* 01234567 */ + {0,0},{0,0},{0,0},{0,0}, /* 89:; */ + OSXET("\046\154\164\073"), /* < */ + { 0, 0 }, /* = */ + OSXET("\046\147\164\073"), /* > */ +}; + +static int +OS__check_escaped_control_char(const void *buf, int size) { + size_t i; + /* + * Inefficient algorithm which translates the escape sequences + * defined above into characters. Returns -1 if not found. + * TODO: replace by a faster algorithm (bsearch(), hash or + * nested table lookups). + */ + for(i = 0; i < 32 /* Don't spend time on the bottom half */; i++) { + struct OCTET_STRING__xer_escape_table_s *el; + el = &OCTET_STRING__xer_escape_table[i]; + if(el->size == size && memcmp(buf, el->string, size) == 0) + return i; + } + return -1; +} + +static int +OCTET_STRING__handle_control_chars(void *struct_ptr, const void *chunk_buf, size_t chunk_size) { + /* + * This might be one of the escape sequences + * for control characters. Check it out. + * #11.15.5 + */ + int control_char = OS__check_escaped_control_char(chunk_buf,chunk_size); + if(control_char >= 0) { + OCTET_STRING_t *st = (OCTET_STRING_t *)struct_ptr; + void *p = REALLOC(st->buf, st->size + 2); + if(p) { + st->buf = (uint8_t *)p; + st->buf[st->size++] = control_char; + st->buf[st->size] = '\0'; /* nul-termination */ + return 0; + } + } + + return -1; /* No, it's not */ +} + +asn_enc_rval_t +OCTET_STRING_encode_xer_utf8(asn_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr; + asn_enc_rval_t er; + uint8_t *buf, *end; + uint8_t *ss; /* Sequence start */ + ssize_t encoded_len = 0; + + (void)ilevel; /* Unused argument */ + (void)flags; /* Unused argument */ + + if(!st || !st->buf) + _ASN_ENCODE_FAILED; + + buf = st->buf; + end = buf + st->size; + for(ss = buf; buf < end; buf++) { + unsigned int ch = *buf; + int s_len; /* Special encoding sequence length */ + + /* + * Escape certain characters: X.680/11.15 + */ + if(ch < sizeof(OCTET_STRING__xer_escape_table) + /sizeof(OCTET_STRING__xer_escape_table[0]) + && (s_len = OCTET_STRING__xer_escape_table[ch].size)) { + if(((buf - ss) && cb(ss, buf - ss, app_key) < 0) + || cb(OCTET_STRING__xer_escape_table[ch].string, s_len, + app_key) < 0) + _ASN_ENCODE_FAILED; + encoded_len += (buf - ss) + s_len; + ss = buf + 1; + } + } + + encoded_len += (buf - ss); + if((buf - ss) && cb(ss, buf - ss, app_key) < 0) + _ASN_ENCODE_FAILED; + + er.encoded = encoded_len; + _ASN_ENCODED_OK(er); +} + +/* + * Convert from hexadecimal format (cstring): "AB CD EF" + */ +static ssize_t OCTET_STRING__convert_hexadecimal(void *sptr, const void *chunk_buf, size_t chunk_size, int have_more) { + OCTET_STRING_t *st = (OCTET_STRING_t *)sptr; + const char *chunk_stop = (const char *)chunk_buf; + const char *p = chunk_stop; + const char *pend = p + chunk_size; + unsigned int clv = 0; + int half = 0; /* Half bit */ + uint8_t *buf; + + /* Reallocate buffer according to high cap estimation */ + ssize_t _ns = st->size + (chunk_size + 1) / 2; + void *nptr = REALLOC(st->buf, _ns + 1); + if(!nptr) return -1; + st->buf = (uint8_t *)nptr; + buf = st->buf + st->size; + + /* + * If something like " a b c " appears here, the " a b":3 will be + * converted, and the rest skipped. That is, unless buf_size is greater + * than chunk_size, then it'll be equivalent to "ABC0". + */ + for(; p < pend; p++) { + int ch = *(const unsigned char *)p; + switch(ch) { + case 0x09: case 0x0a: case 0x0c: case 0x0d: + case 0x20: + /* Ignore whitespace */ + continue; + case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: /*01234*/ + case 0x35: case 0x36: case 0x37: case 0x38: case 0x39: /*56789*/ + clv = (clv << 4) + (ch - 0x30); + break; + case 0x41: case 0x42: case 0x43: /* ABC */ + case 0x44: case 0x45: case 0x46: /* DEF */ + clv = (clv << 4) + (ch - 0x41 + 10); + break; + case 0x61: case 0x62: case 0x63: /* abc */ + case 0x64: case 0x65: case 0x66: /* def */ + clv = (clv << 4) + (ch - 0x61 + 10); + break; + default: + *buf = 0; /* JIC */ + return -1; + } + if(half++) { + half = 0; + *buf++ = clv; + chunk_stop = p + 1; + } + } + + /* + * Check partial decoding. + */ + if(half) { + if(have_more) { + /* + * Partial specification is fine, + * because no more more PXER_TEXT data is available. + */ + *buf++ = clv << 4; + chunk_stop = p; + } + } else { + chunk_stop = p; + } + + st->size = buf - st->buf; /* Adjust the buffer size */ + assert(st->size <= _ns); + st->buf[st->size] = 0; /* Courtesy termination */ + + return (chunk_stop - (const char *)chunk_buf); /* Converted size */ +} + +/* + * Convert from binary format: "00101011101" + */ +static ssize_t OCTET_STRING__convert_binary(void *sptr, const void *chunk_buf, size_t chunk_size, int have_more) { + BIT_STRING_t *st = (BIT_STRING_t *)sptr; + const char *p = (const char *)chunk_buf; + const char *pend = p + chunk_size; + int bits_unused = st->bits_unused & 0x7; + uint8_t *buf; + + /* Reallocate buffer according to high cap estimation */ + ssize_t _ns = st->size + (chunk_size + 7) / 8; + void *nptr = REALLOC(st->buf, _ns + 1); + if(!nptr) return -1; + st->buf = (uint8_t *)nptr; + buf = st->buf + st->size; + + (void)have_more; + + if(bits_unused == 0) + bits_unused = 8; + else if(st->size) + buf--; + + /* + * Convert series of 0 and 1 into the octet string. + */ + for(; p < pend; p++) { + int ch = *(const unsigned char *)p; + switch(ch) { + case 0x09: case 0x0a: case 0x0c: case 0x0d: + case 0x20: + /* Ignore whitespace */ + break; + case 0x30: + case 0x31: + if(bits_unused-- <= 0) { + *++buf = 0; /* Clean the cell */ + bits_unused = 7; + } + *buf |= (ch&1) << bits_unused; + break; + default: + st->bits_unused = bits_unused; + return -1; + } + } + + if(bits_unused == 8) { + st->size = buf - st->buf; + st->bits_unused = 0; + } else { + st->size = buf - st->buf + 1; + st->bits_unused = bits_unused; + } + + assert(st->size <= _ns); + st->buf[st->size] = 0; /* Courtesy termination */ + + return chunk_size; /* Converted in full */ +} + +/* + * Something like strtod(), but with stricter rules. + */ +static int +OS__strtoent(int base, const char *buf, const char *end, int32_t *ret_value) { + int32_t val = 0; + const char *p; + + for(p = buf; p < end; p++) { + int ch = *p; + + /* Strange huge value */ + if((val * base + base) < 0) + return -1; + + switch(ch) { + case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: /*01234*/ + case 0x35: case 0x36: case 0x37: case 0x38: case 0x39: /*56789*/ + val = val * base + (ch - 0x30); + break; + case 0x41: case 0x42: case 0x43: /* ABC */ + case 0x44: case 0x45: case 0x46: /* DEF */ + val = val * base + (ch - 0x41 + 10); + break; + case 0x61: case 0x62: case 0x63: /* abc */ + case 0x64: case 0x65: case 0x66: /* def */ + val = val * base + (ch - 0x61 + 10); + break; + case 0x3b: /* ';' */ + *ret_value = val; + return (p - buf) + 1; + default: + return -1; /* Character set error */ + } + } + + *ret_value = -1; + return (p - buf); +} + +/* + * Convert from the plain UTF-8 format, expanding entity references: "2 < 3" + */ +static ssize_t OCTET_STRING__convert_entrefs(void *sptr, const void *chunk_buf, size_t chunk_size, int have_more) { + OCTET_STRING_t *st = (OCTET_STRING_t *)sptr; + const char *p = (const char *)chunk_buf; + const char *pend = p + chunk_size; + uint8_t *buf; + + /* Reallocate buffer */ + ssize_t _ns = st->size + chunk_size; + void *nptr = REALLOC(st->buf, _ns + 1); + if(!nptr) return -1; + st->buf = (uint8_t *)nptr; + buf = st->buf + st->size; + + /* + * Convert series of 0 and 1 into the octet string. + */ + for(; p < pend; p++) { + int ch = *(const unsigned char *)p; + int len; /* Length of the rest of the chunk */ + + if(ch != 0x26 /* '&' */) { + *buf++ = ch; + continue; /* That was easy... */ + } + + /* + * Process entity reference. + */ + len = chunk_size - (p - (const char *)chunk_buf); + if(len == 1 /* "&" */) goto want_more; + if(p[1] == 0x23 /* '#' */) { + const char *pval; /* Pointer to start of digits */ + int32_t val = 0; /* Entity reference value */ + int base; + + if(len == 2 /* "&#" */) goto want_more; + if(p[2] == 0x78 /* 'x' */) + pval = p + 3, base = 16; + else + pval = p + 2, base = 10; + len = OS__strtoent(base, pval, p + len, &val); + if(len == -1) { + /* Invalid charset. Just copy verbatim. */ + *buf++ = ch; + continue; + } + if(!len || pval[len-1] != 0x3b) goto want_more; + assert(val > 0); + p += (pval - p) + len - 1; /* Advance past entref */ + + if(val < 0x80) { + *buf++ = (char)val; + } else if(val < 0x800) { + *buf++ = 0xc0 | ((val >> 6)); + *buf++ = 0x80 | ((val & 0x3f)); + } else if(val < 0x10000) { + *buf++ = 0xe0 | ((val >> 12)); + *buf++ = 0x80 | ((val >> 6) & 0x3f); + *buf++ = 0x80 | ((val & 0x3f)); + } else if(val < 0x200000) { + *buf++ = 0xf0 | ((val >> 18)); + *buf++ = 0x80 | ((val >> 12) & 0x3f); + *buf++ = 0x80 | ((val >> 6) & 0x3f); + *buf++ = 0x80 | ((val & 0x3f)); + } else if(val < 0x4000000) { + *buf++ = 0xf8 | ((val >> 24)); + *buf++ = 0x80 | ((val >> 18) & 0x3f); + *buf++ = 0x80 | ((val >> 12) & 0x3f); + *buf++ = 0x80 | ((val >> 6) & 0x3f); + *buf++ = 0x80 | ((val & 0x3f)); + } else { + *buf++ = 0xfc | ((val >> 30) & 0x1); + *buf++ = 0x80 | ((val >> 24) & 0x3f); + *buf++ = 0x80 | ((val >> 18) & 0x3f); + *buf++ = 0x80 | ((val >> 12) & 0x3f); + *buf++ = 0x80 | ((val >> 6) & 0x3f); + *buf++ = 0x80 | ((val & 0x3f)); + } + } else { + /* + * Ugly, limited parsing of & > < + */ + char *sc = (char *)memchr(p, 0x3b, len > 5 ? 5 : len); + if(!sc) goto want_more; + if((sc - p) == 4 + && p[1] == 0x61 /* 'a' */ + && p[2] == 0x6d /* 'm' */ + && p[3] == 0x70 /* 'p' */) { + *buf++ = 0x26; + p = sc; + continue; + } + if((sc - p) == 3) { + if(p[1] == 0x6c) { + *buf = 0x3c; /* '<' */ + } else if(p[1] == 0x67) { + *buf = 0x3e; /* '>' */ + } else { + /* Unsupported entity reference */ + *buf++ = ch; + continue; + } + if(p[2] != 0x74) { + /* Unsupported entity reference */ + *buf++ = ch; + continue; + } + buf++; + p = sc; + continue; + } + /* Unsupported entity reference */ + *buf++ = ch; + } + + continue; + want_more: + if(have_more) { + /* + * We know that no more data (of the same type) + * is coming. Copy the rest verbatim. + */ + *buf++ = ch; + continue; + } + chunk_size = (p - (const char *)chunk_buf); + /* Processing stalled: need more data */ + break; + } + + st->size = buf - st->buf; + assert(st->size <= _ns); + st->buf[st->size] = 0; /* Courtesy termination */ + + return chunk_size; /* Converted in full */ +} + +/* + * Decode OCTET STRING from the XML element's body. + */ +static asn_dec_rval_t +OCTET_STRING__decode_xer(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *td, void **sptr, + const char *opt_mname, const void *buf_ptr, size_t size, + int (*opt_unexpected_tag_decoder) + (void *struct_ptr, const void *chunk_buf, size_t chunk_size), + ssize_t (*body_receiver) + (void *struct_ptr, const void *chunk_buf, size_t chunk_size, + int have_more) +) { + OCTET_STRING_t *st = (OCTET_STRING_t *)*sptr; + asn_OCTET_STRING_specifics_t *specs = td->specifics + ? (asn_OCTET_STRING_specifics_t *)td->specifics + : &asn_DEF_OCTET_STRING_specs; + const char *xml_tag = opt_mname ? opt_mname : td->xml_tag; + asn_struct_ctx_t *ctx; /* Per-structure parser context */ + asn_dec_rval_t rval; /* Return value from the decoder */ + int st_allocated; + + /* + * Create the string if does not exist. + */ + if(!st) { + st = (OCTET_STRING_t *)CALLOC(1, specs->struct_size); + *sptr = (void *)st; + if(!st) goto sta_failed; + st_allocated = 1; + } else { + st_allocated = 0; + } + if(!st->buf) { + /* This is separate from above section */ + st->buf = (uint8_t *)CALLOC(1, 1); + if(!st->buf) { + if(st_allocated) { + *sptr = 0; + goto stb_failed; + } else { + goto sta_failed; + } + } + } + + /* Restore parsing context */ + ctx = (asn_struct_ctx_t *)(((char *)*sptr) + specs->ctx_offset); + + return xer_decode_general(opt_codec_ctx, ctx, *sptr, xml_tag, + buf_ptr, size, opt_unexpected_tag_decoder, body_receiver); + +stb_failed: + FREEMEM(st); +sta_failed: + rval.code = RC_FAIL; + rval.consumed = 0; + return rval; +} + +/* + * Decode OCTET STRING from the hexadecimal data. + */ +asn_dec_rval_t +OCTET_STRING_decode_xer_hex(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *td, void **sptr, + const char *opt_mname, const void *buf_ptr, size_t size) { + return OCTET_STRING__decode_xer(opt_codec_ctx, td, sptr, opt_mname, + buf_ptr, size, 0, OCTET_STRING__convert_hexadecimal); +} + +/* + * Decode OCTET STRING from the binary (0/1) data. + */ +asn_dec_rval_t +OCTET_STRING_decode_xer_binary(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *td, void **sptr, + const char *opt_mname, const void *buf_ptr, size_t size) { + return OCTET_STRING__decode_xer(opt_codec_ctx, td, sptr, opt_mname, + buf_ptr, size, 0, OCTET_STRING__convert_binary); +} + +/* + * Decode OCTET STRING from the string (ASCII/UTF-8) data. + */ +asn_dec_rval_t +OCTET_STRING_decode_xer_utf8(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *td, void **sptr, + const char *opt_mname, const void *buf_ptr, size_t size) { + return OCTET_STRING__decode_xer(opt_codec_ctx, td, sptr, opt_mname, + buf_ptr, size, + OCTET_STRING__handle_control_chars, + OCTET_STRING__convert_entrefs); +} + +asn_dec_rval_t +OCTET_STRING_decode_uper(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, + void **sptr, asn_per_data_t *pd) { + + asn_OCTET_STRING_specifics_t *specs = td->specifics + ? (asn_OCTET_STRING_specifics_t *)td->specifics + : &asn_DEF_OCTET_STRING_specs; + asn_per_constraint_t *ct = constraints ? &constraints->size + : (td->per_constraints + ? &td->per_constraints->size + : &asn_DEF_OCTET_STRING_constraint); + asn_dec_rval_t rval = { RC_OK, 0 }; + BIT_STRING_t *st = (BIT_STRING_t *)*sptr; + ssize_t consumed_myself = 0; + int repeat; + int unit_bits = (specs->subvariant != 1) * 7 + 1; + + (void)opt_codec_ctx; + + /* + * Allocate the string. + */ + if(!st) { + st = (BIT_STRING_t *)(*sptr = CALLOC(1, specs->struct_size)); + if(!st) RETURN(RC_FAIL); + } + + ASN_DEBUG("PER Decoding %s %ld .. %ld bits %d", + ct->flags & APC_EXTENSIBLE ? "extensible" : "fixed", + ct->lower_bound, ct->upper_bound, ct->effective_bits); + + if(ct->flags & APC_EXTENSIBLE) { + int inext = per_get_few_bits(pd, 1); + if(inext < 0) RETURN(RC_WMORE); + if(inext) ct = &asn_DEF_OCTET_STRING_constraint; + consumed_myself = 0; + } + + if(ct->effective_bits >= 0 + && (!st->buf || st->size < ct->upper_bound)) { + FREEMEM(st->buf); + if(unit_bits == 1) { + st->size = (ct->upper_bound + 7) >> 3; + } else { + st->size = ct->upper_bound; + } + st->buf = (uint8_t *)MALLOC(st->size + 1); + if(!st->buf) { st->size = 0; RETURN(RC_FAIL); } + } + + /* X.691, #16.5: zero-length encoding */ + /* X.691, #16.6: short fixed length encoding (up to 2 octets) */ + /* X.691, #16.7: long fixed length encoding (up to 64K octets) */ + if(ct->effective_bits == 0) { + int ret = per_get_many_bits(pd, st->buf, 0, + unit_bits * ct->upper_bound); + if(ret < 0) RETURN(RC_WMORE); + consumed_myself += unit_bits * ct->upper_bound; + st->buf[st->size] = 0; + if(unit_bits == 1 && (ct->upper_bound & 0x7)) + st->bits_unused = 8 - (ct->upper_bound & 0x7); + RETURN(RC_OK); + } + + st->size = 0; + do { + ssize_t len_bytes; + ssize_t len_bits; + void *p; + int ret; + + /* Get the PER length */ + len_bits = uper_get_length(pd, ct->effective_bits, &repeat); + if(len_bits < 0) RETURN(RC_WMORE); + len_bits += ct->lower_bound; + + ASN_DEBUG("Got PER length eb %ld, len %ld, %s (%s)", + (long)ct->effective_bits, (long)len_bits, + repeat ? "repeat" : "once", td->name); + if(unit_bits == 1) { + len_bytes = (len_bits + 7) >> 3; + if(len_bits & 0x7) + st->bits_unused = 8 - (len_bits & 0x7); + /* len_bits be multiple of 16K if repeat is set */ + } else { + len_bytes = len_bits; + len_bits = len_bytes << 3; + } + p = REALLOC(st->buf, st->size + len_bytes + 1); + if(!p) RETURN(RC_FAIL); + st->buf = (uint8_t *)p; + + ret = per_get_many_bits(pd, &st->buf[st->size], 0, len_bits); + if(ret < 0) RETURN(RC_WMORE); + st->size += len_bytes; + } while(repeat); + st->buf[st->size] = 0; /* nul-terminate */ + + return rval; +} + +asn_enc_rval_t +OCTET_STRING_encode_uper(asn_TYPE_descriptor_t *td, + asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) { + + asn_OCTET_STRING_specifics_t *specs = td->specifics + ? (asn_OCTET_STRING_specifics_t *)td->specifics + : &asn_DEF_OCTET_STRING_specs; + asn_per_constraint_t *ct = constraints ? &constraints->size + : (td->per_constraints + ? &td->per_constraints->size + : &asn_DEF_OCTET_STRING_constraint); + const BIT_STRING_t *st = (const BIT_STRING_t *)sptr; + int unit_bits = (specs->subvariant != 1) * 7 + 1; + asn_enc_rval_t er; + int ct_extensible = ct->flags & APC_EXTENSIBLE; + int inext = 0; /* Lies not within extension root */ + int sizeinunits = st->size; + const uint8_t *buf; + int ret; + + if(!st || !st->buf) + _ASN_ENCODE_FAILED; + + if(unit_bits == 1) { + ASN_DEBUG("BIT STRING of %d bytes, %d bits unused", + sizeinunits, st->bits_unused); + sizeinunits = sizeinunits * 8 - (st->bits_unused & 0x07); + } + + ASN_DEBUG("Encoding %s into %d units of %d bits" + " (%d..%d, effective %d)%s", + td->name, sizeinunits, unit_bits, + ct->lower_bound, ct->upper_bound, + ct->effective_bits, ct_extensible ? " EXT" : ""); + + /* Figure out wheter size lies within PER visible consrtaint */ + + if(ct->effective_bits >= 0) { + if(sizeinunits < ct->lower_bound + || sizeinunits > ct->upper_bound) { + if(ct_extensible) { + ct = &asn_DEF_OCTET_STRING_constraint; + inext = 1; + } else + _ASN_ENCODE_FAILED; + } + } else { + inext = 0; + } + + if(ct_extensible) { + /* Declare whether length is [not] within extension root */ + if(per_put_few_bits(po, inext, 1)) + _ASN_ENCODE_FAILED; + } + + /* X.691, #16.5: zero-length encoding */ + /* X.691, #16.6: short fixed length encoding (up to 2 octets) */ + /* X.691, #16.7: long fixed length encoding (up to 64K octets) */ + if(ct->effective_bits >= 0) { + ASN_DEBUG("Encoding %d bytes (%ld), length in %d bits", + st->size, sizeinunits - ct->lower_bound, + ct->effective_bits); + ret = per_put_few_bits(po, sizeinunits - ct->lower_bound, + ct->effective_bits); + if(ret) _ASN_ENCODE_FAILED; + ret = per_put_many_bits(po, st->buf, sizeinunits * unit_bits); + if(ret) _ASN_ENCODE_FAILED; + _ASN_ENCODED_OK(er); + } + + ASN_DEBUG("Encoding %d bytes", st->size); + + if(sizeinunits == 0) { + if(uper_put_length(po, 0)) + _ASN_ENCODE_FAILED; + _ASN_ENCODED_OK(er); + } + + buf = st->buf; + while(sizeinunits) { + ssize_t maySave = uper_put_length(po, sizeinunits); + if(maySave < 0) _ASN_ENCODE_FAILED; + + ASN_DEBUG("Encoding %d of %d", maySave, sizeinunits); + + ret = per_put_many_bits(po, buf, maySave * unit_bits); + if(ret) _ASN_ENCODE_FAILED; + + if(unit_bits == 1) + buf += maySave >> 3; + else + buf += maySave; + sizeinunits -= maySave; + assert(!(maySave & 0x07) || !sizeinunits); + } + + _ASN_ENCODED_OK(er); +} + +int +OCTET_STRING_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel, + asn_app_consume_bytes_f *cb, void *app_key) { + static const char *h2c = "0123456789ABCDEF"; + const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr; + char scratch[16 * 3 + 4]; + char *p = scratch; + uint8_t *buf; + uint8_t *end; + size_t i; + + (void)td; /* Unused argument */ + + if(!st || !st->buf) return (cb("", 8, app_key) < 0) ? -1 : 0; + + /* + * Dump the contents of the buffer in hexadecimal. + */ + buf = st->buf; + end = buf + st->size; + for(i = 0; buf < end; buf++, i++) { + if(!(i % 16) && (i || st->size > 16)) { + if(cb(scratch, p - scratch, app_key) < 0) + return -1; + _i_INDENT(1); + p = scratch; + } + *p++ = h2c[(*buf >> 4) & 0x0F]; + *p++ = h2c[*buf & 0x0F]; + *p++ = 0x20; + } + + if(p > scratch) { + p--; /* Remove the tail space */ + if(cb(scratch, p - scratch, app_key) < 0) + return -1; + } + + return 0; +} + +int +OCTET_STRING_print_utf8(asn_TYPE_descriptor_t *td, const void *sptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr; + + (void)td; /* Unused argument */ + (void)ilevel; /* Unused argument */ + + if(st && st->buf) { + return (cb(st->buf, st->size, app_key) < 0) ? -1 : 0; + } else { + return (cb("", 8, app_key) < 0) ? -1 : 0; + } +} + +void +OCTET_STRING_free(asn_TYPE_descriptor_t *td, void *sptr, int contents_only) { + OCTET_STRING_t *st = (OCTET_STRING_t *)sptr; + asn_OCTET_STRING_specifics_t *specs = td->specifics + ? (asn_OCTET_STRING_specifics_t *)td->specifics + : &asn_DEF_OCTET_STRING_specs; + asn_struct_ctx_t *ctx = (asn_struct_ctx_t *) + ((char *)st + specs->ctx_offset); + struct _stack *stck; + + if(!td || !st) + return; + + ASN_DEBUG("Freeing %s as OCTET STRING", td->name); + + if(st->buf) { + FREEMEM(st->buf); + } + + /* + * Remove decode-time stack. + */ + stck = (struct _stack *)ctx->ptr; + if(stck) { + while(stck->tail) { + struct _stack_el *sel = stck->tail; + stck->tail = sel->prev; + FREEMEM(sel); + } + FREEMEM(stck); + } + + if(!contents_only) { + FREEMEM(st); + } +} + +/* + * Conversion routines. + */ +int +OCTET_STRING_fromBuf(OCTET_STRING_t *st, const char *str, int len) { + void *buf; + + if(st == 0 || (str == 0 && len)) { + errno = EINVAL; + return -1; + } + + /* + * Clear the OCTET STRING. + */ + if(str == NULL) { + FREEMEM(st->buf); + st->buf = 0; + st->size = 0; + return 0; + } + + /* Determine the original string size, if not explicitly given */ + if(len < 0) + len = strlen(str); + + /* Allocate and fill the memory */ + buf = MALLOC(len + 1); + if(buf == NULL) + return -1; + + memcpy(buf, str, len); + ((uint8_t *)buf)[len] = '\0'; /* Couldn't use memcpy(len+1)! */ + FREEMEM(st->buf); + st->buf = (uint8_t *)buf; + st->size = len; + + return 0; +} + +OCTET_STRING_t * +OCTET_STRING_new_fromBuf(asn_TYPE_descriptor_t *td, const char *str, int len) { + asn_OCTET_STRING_specifics_t *specs = td->specifics + ? (asn_OCTET_STRING_specifics_t *)td->specifics + : &asn_DEF_OCTET_STRING_specs; + OCTET_STRING_t *st; + + st = (OCTET_STRING_t *)CALLOC(1, specs->struct_size); + if(st && str && OCTET_STRING_fromBuf(st, str, len)) { + FREEMEM(st); + st = NULL; + } + + return st; +} + diff --git a/projects/stargazer/plugins/other/snmp/asn1/OCTET_STRING.h b/projects/stargazer/plugins/other/snmp/asn1/OCTET_STRING.h new file mode 100644 index 00000000..5150161a --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/OCTET_STRING.h @@ -0,0 +1,80 @@ +/*- + * Copyright (c) 2003 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _OCTET_STRING_H_ +#define _OCTET_STRING_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct OCTET_STRING { + uint8_t *buf; /* Buffer with consecutive OCTET_STRING bits */ + int size; /* Size of the buffer */ + + asn_struct_ctx_t _asn_ctx; /* Parsing across buffer boundaries */ +} OCTET_STRING_t; + +extern asn_TYPE_descriptor_t asn_DEF_OCTET_STRING; + +asn_struct_free_f OCTET_STRING_free; +asn_struct_print_f OCTET_STRING_print; +asn_struct_print_f OCTET_STRING_print_utf8; +ber_type_decoder_f OCTET_STRING_decode_ber; +der_type_encoder_f OCTET_STRING_encode_der; +xer_type_decoder_f OCTET_STRING_decode_xer_hex; /* Hexadecimal */ +xer_type_decoder_f OCTET_STRING_decode_xer_binary; /* 01010111010 */ +xer_type_decoder_f OCTET_STRING_decode_xer_utf8; /* ASCII/UTF-8 */ +xer_type_encoder_f OCTET_STRING_encode_xer; +xer_type_encoder_f OCTET_STRING_encode_xer_utf8; +per_type_decoder_f OCTET_STRING_decode_uper; +per_type_encoder_f OCTET_STRING_encode_uper; + +/****************************** + * Handy conversion routines. * + ******************************/ + +/* + * This function clears the previous value of the OCTET STRING (if any) + * and then allocates a new memory with the specified content (str/size). + * If size = -1, the size of the original string will be determined + * using strlen(str). + * If str equals to NULL, the function will silently clear the + * current contents of the OCTET STRING. + * Returns 0 if it was possible to perform operation, -1 otherwise. + */ +int OCTET_STRING_fromBuf(OCTET_STRING_t *s, const char *str, int size); + +/* Handy conversion from the C string into the OCTET STRING. */ +#define OCTET_STRING_fromString(s, str) OCTET_STRING_fromBuf(s, str, -1) + +/* + * Allocate and fill the new OCTET STRING and return a pointer to the newly + * allocated object. NULL is permitted in str: the function will just allocate + * empty OCTET STRING. + */ +OCTET_STRING_t *OCTET_STRING_new_fromBuf(asn_TYPE_descriptor_t *td, + const char *str, int size); + +/**************************** + * Internally useful stuff. * + ****************************/ + +typedef struct asn_OCTET_STRING_specifics_s { + /* + * Target structure description. + */ + int struct_size; /* Size of the structure */ + int ctx_offset; /* Offset of the asn_struct_ctx_t member */ + + int subvariant; /* {0,1,2} for O-S, BIT STRING or ANY */ +} asn_OCTET_STRING_specifics_t; + +#ifdef __cplusplus +} +#endif + +#endif /* _OCTET_STRING_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/ObjectName.c b/projects/stargazer/plugins/other/snmp/asn1/ObjectName.c new file mode 100644 index 00000000..d10f7193 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/ObjectName.c @@ -0,0 +1,110 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "ObjectName.h" + +int +ObjectName_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + /* Replace with underlying type checker */ + td->check_constraints = asn_DEF_OBJECT_IDENTIFIER.check_constraints; + return td->check_constraints(td, sptr, ctfailcb, app_key); +} + +/* + * This type is implemented using OBJECT_IDENTIFIER, + * so here we adjust the DEF accordingly. + */ +static void +ObjectName_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { + td->free_struct = asn_DEF_OBJECT_IDENTIFIER.free_struct; + td->print_struct = asn_DEF_OBJECT_IDENTIFIER.print_struct; + td->ber_decoder = asn_DEF_OBJECT_IDENTIFIER.ber_decoder; + td->der_encoder = asn_DEF_OBJECT_IDENTIFIER.der_encoder; + td->xer_decoder = asn_DEF_OBJECT_IDENTIFIER.xer_decoder; + td->xer_encoder = asn_DEF_OBJECT_IDENTIFIER.xer_encoder; + td->uper_decoder = asn_DEF_OBJECT_IDENTIFIER.uper_decoder; + td->uper_encoder = asn_DEF_OBJECT_IDENTIFIER.uper_encoder; + if(!td->per_constraints) + td->per_constraints = asn_DEF_OBJECT_IDENTIFIER.per_constraints; + td->elements = asn_DEF_OBJECT_IDENTIFIER.elements; + td->elements_count = asn_DEF_OBJECT_IDENTIFIER.elements_count; + td->specifics = asn_DEF_OBJECT_IDENTIFIER.specifics; +} + +void +ObjectName_free(asn_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + ObjectName_1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +ObjectName_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + ObjectName_1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + +asn_dec_rval_t +ObjectName_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const void *bufptr, size_t size, int tag_mode) { + ObjectName_1_inherit_TYPE_descriptor(td); + return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); +} + +asn_enc_rval_t +ObjectName_encode_der(asn_TYPE_descriptor_t *td, + void *structure, int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + ObjectName_1_inherit_TYPE_descriptor(td); + return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); +} + +asn_dec_rval_t +ObjectName_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const char *opt_mname, const void *bufptr, size_t size) { + ObjectName_1_inherit_TYPE_descriptor(td); + return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); +} + +asn_enc_rval_t +ObjectName_encode_xer(asn_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + ObjectName_1_inherit_TYPE_descriptor(td); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); +} + +static ber_tlv_tag_t asn_DEF_ObjectName_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_ObjectName = { + "ObjectName", + "ObjectName", + ObjectName_free, + ObjectName_print, + ObjectName_constraint, + ObjectName_decode_ber, + ObjectName_encode_der, + ObjectName_decode_xer, + ObjectName_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_ObjectName_tags_1, + sizeof(asn_DEF_ObjectName_tags_1) + /sizeof(asn_DEF_ObjectName_tags_1[0]), /* 1 */ + asn_DEF_ObjectName_tags_1, /* Same as above */ + sizeof(asn_DEF_ObjectName_tags_1) + /sizeof(asn_DEF_ObjectName_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + 0, 0, /* No members */ + 0 /* No specifics */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/ObjectName.h b/projects/stargazer/plugins/other/snmp/asn1/ObjectName.h new file mode 100644 index 00000000..256577b3 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/ObjectName.h @@ -0,0 +1,38 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _ObjectName_H_ +#define _ObjectName_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* ObjectName */ +typedef OBJECT_IDENTIFIER_t ObjectName_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_ObjectName; +asn_struct_free_f ObjectName_free; +asn_struct_print_f ObjectName_print; +asn_constr_check_f ObjectName_constraint; +ber_type_decoder_f ObjectName_decode_ber; +der_type_encoder_f ObjectName_encode_der; +xer_type_decoder_f ObjectName_decode_xer; +xer_type_encoder_f ObjectName_encode_xer; + +#ifdef __cplusplus +} +#endif + +#endif /* _ObjectName_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/ObjectSyntax.c b/projects/stargazer/plugins/other/snmp/asn1/ObjectSyntax.c new file mode 100644 index 00000000..b0542d90 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/ObjectSyntax.c @@ -0,0 +1,74 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "ObjectSyntax.h" + +static asn_TYPE_member_t asn_MBR_ObjectSyntax_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct ObjectSyntax, choice.simple), + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_SimpleSyntax, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "simple" + }, + { ATF_NOFLAGS, 0, offsetof(struct ObjectSyntax, choice.application_wide), + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_ApplicationSyntax, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "application-wide" + }, +}; +static asn_TYPE_tag2member_t asn_MAP_ObjectSyntax_tag2el_1[] = { + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* number at 73 */ + { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 0, 0, 0 }, /* string at 76 */ + { (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)), 0, 0, 0 }, /* empty at 82 */ + { (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), 0, 0, 0 }, /* object at 79 */ + { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 1, 0, 0 }, /* internet at 113 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 1, 0, 0 }, /* counter at 91 */ + { (ASN_TAG_CLASS_APPLICATION | (2 << 2)), 1, 0, 0 }, /* gauge at 94 */ + { (ASN_TAG_CLASS_APPLICATION | (3 << 2)), 1, 0, 0 }, /* ticks at 97 */ + { (ASN_TAG_CLASS_APPLICATION | (4 << 2)), 1, 0, 0 } /* arbitrary at 104 */ +}; +static asn_CHOICE_specifics_t asn_SPC_ObjectSyntax_specs_1 = { + sizeof(struct ObjectSyntax), + offsetof(struct ObjectSyntax, _asn_ctx), + offsetof(struct ObjectSyntax, present), + sizeof(((struct ObjectSyntax *)0)->present), + asn_MAP_ObjectSyntax_tag2el_1, + 9, /* Count of tags in the map */ + 0, + -1 /* Extensions start */ +}; +asn_TYPE_descriptor_t asn_DEF_ObjectSyntax = { + "ObjectSyntax", + "ObjectSyntax", + CHOICE_free, + CHOICE_print, + CHOICE_constraint, + CHOICE_decode_ber, + CHOICE_encode_der, + CHOICE_decode_xer, + CHOICE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + CHOICE_outmost_tag, + 0, /* No effective tags (pointer) */ + 0, /* No effective tags (count) */ + 0, /* No tags (pointer) */ + 0, /* No tags (count) */ + 0, /* No PER visible constraints */ + asn_MBR_ObjectSyntax_1, + 2, /* Elements count */ + &asn_SPC_ObjectSyntax_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/ObjectSyntax.h b/projects/stargazer/plugins/other/snmp/asn1/ObjectSyntax.h new file mode 100644 index 00000000..9030accb --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/ObjectSyntax.h @@ -0,0 +1,49 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _ObjectSyntax_H_ +#define _ObjectSyntax_H_ + + +#include + +/* Including external dependencies */ +#include "SimpleSyntax.h" +#include "ApplicationSyntax.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum ObjectSyntax_PR { + ObjectSyntax_PR_NOTHING, /* No components present */ + ObjectSyntax_PR_simple, + ObjectSyntax_PR_application_wide +} ObjectSyntax_PR; + +/* ObjectSyntax */ +typedef struct ObjectSyntax { + ObjectSyntax_PR present; + union ObjectSyntax_u { + SimpleSyntax_t simple; + ApplicationSyntax_t application_wide; + } choice; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} ObjectSyntax_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_ObjectSyntax; + +#ifdef __cplusplus +} +#endif + +#endif /* _ObjectSyntax_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/Opaque.c b/projects/stargazer/plugins/other/snmp/asn1/Opaque.c new file mode 100644 index 00000000..bccff85d --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/Opaque.c @@ -0,0 +1,111 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "Opaque.h" + +int +Opaque_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + /* Replace with underlying type checker */ + td->check_constraints = asn_DEF_OCTET_STRING.check_constraints; + return td->check_constraints(td, sptr, ctfailcb, app_key); +} + +/* + * This type is implemented using OCTET_STRING, + * so here we adjust the DEF accordingly. + */ +static void +Opaque_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { + td->free_struct = asn_DEF_OCTET_STRING.free_struct; + td->print_struct = asn_DEF_OCTET_STRING.print_struct; + td->ber_decoder = asn_DEF_OCTET_STRING.ber_decoder; + td->der_encoder = asn_DEF_OCTET_STRING.der_encoder; + td->xer_decoder = asn_DEF_OCTET_STRING.xer_decoder; + td->xer_encoder = asn_DEF_OCTET_STRING.xer_encoder; + td->uper_decoder = asn_DEF_OCTET_STRING.uper_decoder; + td->uper_encoder = asn_DEF_OCTET_STRING.uper_encoder; + if(!td->per_constraints) + td->per_constraints = asn_DEF_OCTET_STRING.per_constraints; + td->elements = asn_DEF_OCTET_STRING.elements; + td->elements_count = asn_DEF_OCTET_STRING.elements_count; + td->specifics = asn_DEF_OCTET_STRING.specifics; +} + +void +Opaque_free(asn_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Opaque_1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Opaque_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Opaque_1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + +asn_dec_rval_t +Opaque_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const void *bufptr, size_t size, int tag_mode) { + Opaque_1_inherit_TYPE_descriptor(td); + return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); +} + +asn_enc_rval_t +Opaque_encode_der(asn_TYPE_descriptor_t *td, + void *structure, int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + Opaque_1_inherit_TYPE_descriptor(td); + return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); +} + +asn_dec_rval_t +Opaque_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const char *opt_mname, const void *bufptr, size_t size) { + Opaque_1_inherit_TYPE_descriptor(td); + return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); +} + +asn_enc_rval_t +Opaque_encode_xer(asn_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + Opaque_1_inherit_TYPE_descriptor(td); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); +} + +static ber_tlv_tag_t asn_DEF_Opaque_tags_1[] = { + (ASN_TAG_CLASS_APPLICATION | (4 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_Opaque = { + "Opaque", + "Opaque", + Opaque_free, + Opaque_print, + Opaque_constraint, + Opaque_decode_ber, + Opaque_encode_der, + Opaque_decode_xer, + Opaque_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_Opaque_tags_1, + sizeof(asn_DEF_Opaque_tags_1) + /sizeof(asn_DEF_Opaque_tags_1[0]) - 1, /* 1 */ + asn_DEF_Opaque_tags_1, /* Same as above */ + sizeof(asn_DEF_Opaque_tags_1) + /sizeof(asn_DEF_Opaque_tags_1[0]), /* 2 */ + 0, /* No PER visible constraints */ + 0, 0, /* No members */ + 0 /* No specifics */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/Opaque.h b/projects/stargazer/plugins/other/snmp/asn1/Opaque.h new file mode 100644 index 00000000..aa8e2d5f --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/Opaque.h @@ -0,0 +1,38 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _Opaque_H_ +#define _Opaque_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Opaque */ +typedef OCTET_STRING_t Opaque_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_Opaque; +asn_struct_free_f Opaque_free; +asn_struct_print_f Opaque_print; +asn_constr_check_f Opaque_constraint; +ber_type_decoder_f Opaque_decode_ber; +der_type_encoder_f Opaque_encode_der; +xer_type_decoder_f Opaque_decode_xer; +xer_type_encoder_f Opaque_encode_xer; + +#ifdef __cplusplus +} +#endif + +#endif /* _Opaque_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/OpenPDU.c b/projects/stargazer/plugins/other/snmp/asn1/OpenPDU.c new file mode 100644 index 00000000..a841714e --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/OpenPDU.c @@ -0,0 +1,57 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "SMUX" + * found in "SMUX.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "OpenPDU.h" + +static asn_TYPE_member_t asn_MBR_OpenPDU_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct OpenPDU, choice.simple), + (ASN_TAG_CLASS_APPLICATION | (0 << 2)), + 0, + &asn_DEF_SimpleOpen, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "simple" + }, +}; +static asn_TYPE_tag2member_t asn_MAP_OpenPDU_tag2el_1[] = { + { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 0, 0, 0 } /* simple at 52 */ +}; +static asn_CHOICE_specifics_t asn_SPC_OpenPDU_specs_1 = { + sizeof(struct OpenPDU), + offsetof(struct OpenPDU, _asn_ctx), + offsetof(struct OpenPDU, present), + sizeof(((struct OpenPDU *)0)->present), + asn_MAP_OpenPDU_tag2el_1, + 1, /* Count of tags in the map */ + 0, + -1 /* Extensions start */ +}; +asn_TYPE_descriptor_t asn_DEF_OpenPDU = { + "OpenPDU", + "OpenPDU", + CHOICE_free, + CHOICE_print, + CHOICE_constraint, + CHOICE_decode_ber, + CHOICE_encode_der, + CHOICE_decode_xer, + CHOICE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + CHOICE_outmost_tag, + 0, /* No effective tags (pointer) */ + 0, /* No effective tags (count) */ + 0, /* No tags (pointer) */ + 0, /* No tags (count) */ + 0, /* No PER visible constraints */ + asn_MBR_OpenPDU_1, + 1, /* Elements count */ + &asn_SPC_OpenPDU_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/OpenPDU.h b/projects/stargazer/plugins/other/snmp/asn1/OpenPDU.h new file mode 100644 index 00000000..5d7e1da6 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/OpenPDU.h @@ -0,0 +1,46 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "SMUX" + * found in "SMUX.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _OpenPDU_H_ +#define _OpenPDU_H_ + + +#include + +/* Including external dependencies */ +#include "SimpleOpen.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum OpenPDU_PR { + OpenPDU_PR_NOTHING, /* No components present */ + OpenPDU_PR_simple +} OpenPDU_PR; + +/* OpenPDU */ +typedef struct OpenPDU { + OpenPDU_PR present; + union OpenPDU_u { + SimpleOpen_t simple; + } choice; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} OpenPDU_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_OpenPDU; + +#ifdef __cplusplus +} +#endif + +#endif /* _OpenPDU_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/PDU.c b/projects/stargazer/plugins/other/snmp/asn1/PDU.c new file mode 100644 index 00000000..0087d19f --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/PDU.c @@ -0,0 +1,91 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "PDU.h" + +static asn_TYPE_member_t asn_MBR_PDU_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct PDU, request_id), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "request-id" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDU, error_status), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "error-status" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDU, error_index), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "error-index" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDU, variable_bindings), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), + 0, + &asn_DEF_VarBindList, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "variable-bindings" + }, +}; +static ber_tlv_tag_t asn_DEF_PDU_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_PDU_tag2el_1[] = { + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 2 }, /* request-id at 73 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, -1, 1 }, /* error-status at 77 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, -2, 0 }, /* error-index at 86 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, 0, 0 } /* variable-bindings at 90 */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_PDU_specs_1 = { + sizeof(struct PDU), + offsetof(struct PDU, _asn_ctx), + asn_MAP_PDU_tag2el_1, + 4, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* Start extensions */ + -1 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_PDU = { + "PDU", + "PDU", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_PDU_tags_1, + sizeof(asn_DEF_PDU_tags_1) + /sizeof(asn_DEF_PDU_tags_1[0]), /* 1 */ + asn_DEF_PDU_tags_1, /* Same as above */ + sizeof(asn_DEF_PDU_tags_1) + /sizeof(asn_DEF_PDU_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_PDU_1, + 4, /* Elements count */ + &asn_SPC_PDU_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/PDU.h b/projects/stargazer/plugins/other/snmp/asn1/PDU.h new file mode 100644 index 00000000..cbc7e714 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/PDU.h @@ -0,0 +1,51 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _PDU_H_ +#define _PDU_H_ + + +#include + +/* Including external dependencies */ +#include +#include "VarBindList.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum PDU__error_status { + PDU__error_status_noError = 0, + PDU__error_status_tooBig = 1, + PDU__error_status_noSuchName = 2, + PDU__error_status_badValue = 3, + PDU__error_status_readOnly = 4, + PDU__error_status_genErr = 5 +} e_PDU__error_status; + +/* PDU */ +typedef struct PDU { + INTEGER_t request_id; + INTEGER_t error_status; + INTEGER_t error_index; + VarBindList_t variable_bindings; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} PDU_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_PDU; + +#ifdef __cplusplus +} +#endif + +#endif /* _PDU_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/PDUs.c b/projects/stargazer/plugins/other/snmp/asn1/PDUs.c new file mode 100644 index 00000000..162530c0 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/PDUs.c @@ -0,0 +1,97 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "PDUs.h" + +static asn_TYPE_member_t asn_MBR_PDUs_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct PDUs, choice.get_request), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + 0, + &asn_DEF_GetRequest_PDU, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "get-request" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDUs, choice.get_next_request), + (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + 0, + &asn_DEF_GetNextRequest_PDU, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "get-next-request" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDUs, choice.get_response), + (ASN_TAG_CLASS_CONTEXT | (2 << 2)), + 0, + &asn_DEF_GetResponse_PDU, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "get-response" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDUs, choice.set_request), + (ASN_TAG_CLASS_CONTEXT | (3 << 2)), + 0, + &asn_DEF_SetRequest_PDU, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "set-request" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDUs, choice.trap), + (ASN_TAG_CLASS_CONTEXT | (4 << 2)), + 0, + &asn_DEF_Trap_PDU, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "trap" + }, +}; +static asn_TYPE_tag2member_t asn_MAP_PDUs_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* get-request at 34 */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* get-next-request at 37 */ + { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* get-response at 40 */ + { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* set-request at 43 */ + { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* trap at 47 */ +}; +static asn_CHOICE_specifics_t asn_SPC_PDUs_specs_1 = { + sizeof(struct PDUs), + offsetof(struct PDUs, _asn_ctx), + offsetof(struct PDUs, present), + sizeof(((struct PDUs *)0)->present), + asn_MAP_PDUs_tag2el_1, + 5, /* Count of tags in the map */ + 0, + -1 /* Extensions start */ +}; +asn_TYPE_descriptor_t asn_DEF_PDUs = { + "PDUs", + "PDUs", + CHOICE_free, + CHOICE_print, + CHOICE_constraint, + CHOICE_decode_ber, + CHOICE_encode_der, + CHOICE_decode_xer, + CHOICE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + CHOICE_outmost_tag, + 0, /* No effective tags (pointer) */ + 0, /* No effective tags (count) */ + 0, /* No tags (pointer) */ + 0, /* No tags (count) */ + 0, /* No PER visible constraints */ + asn_MBR_PDUs_1, + 5, /* Elements count */ + &asn_SPC_PDUs_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/PDUs.h b/projects/stargazer/plugins/other/snmp/asn1/PDUs.h new file mode 100644 index 00000000..90bb089f --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/PDUs.h @@ -0,0 +1,58 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _PDUs_H_ +#define _PDUs_H_ + + +#include + +/* Including external dependencies */ +#include "GetRequest-PDU.h" +#include "GetNextRequest-PDU.h" +#include "GetResponse-PDU.h" +#include "SetRequest-PDU.h" +#include "Trap-PDU.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum PDUs_PR { + PDUs_PR_NOTHING, /* No components present */ + PDUs_PR_get_request, + PDUs_PR_get_next_request, + PDUs_PR_get_response, + PDUs_PR_set_request, + PDUs_PR_trap +} PDUs_PR; + +/* PDUs */ +typedef struct PDUs { + PDUs_PR present; + union PDUs_u { + GetRequest_PDU_t get_request; + GetNextRequest_PDU_t get_next_request; + GetResponse_PDU_t get_response; + SetRequest_PDU_t set_request; + Trap_PDU_t trap; + } choice; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} PDUs_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_PDUs; + +#ifdef __cplusplus +} +#endif + +#endif /* _PDUs_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/PhysAddress.c b/projects/stargazer/plugins/other/snmp/asn1/PhysAddress.c new file mode 100644 index 00000000..eed47386 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/PhysAddress.c @@ -0,0 +1,110 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "PhysAddress.h" + +int +PhysAddress_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + /* Replace with underlying type checker */ + td->check_constraints = asn_DEF_OCTET_STRING.check_constraints; + return td->check_constraints(td, sptr, ctfailcb, app_key); +} + +/* + * This type is implemented using OCTET_STRING, + * so here we adjust the DEF accordingly. + */ +static void +PhysAddress_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { + td->free_struct = asn_DEF_OCTET_STRING.free_struct; + td->print_struct = asn_DEF_OCTET_STRING.print_struct; + td->ber_decoder = asn_DEF_OCTET_STRING.ber_decoder; + td->der_encoder = asn_DEF_OCTET_STRING.der_encoder; + td->xer_decoder = asn_DEF_OCTET_STRING.xer_decoder; + td->xer_encoder = asn_DEF_OCTET_STRING.xer_encoder; + td->uper_decoder = asn_DEF_OCTET_STRING.uper_decoder; + td->uper_encoder = asn_DEF_OCTET_STRING.uper_encoder; + if(!td->per_constraints) + td->per_constraints = asn_DEF_OCTET_STRING.per_constraints; + td->elements = asn_DEF_OCTET_STRING.elements; + td->elements_count = asn_DEF_OCTET_STRING.elements_count; + td->specifics = asn_DEF_OCTET_STRING.specifics; +} + +void +PhysAddress_free(asn_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + PhysAddress_1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +PhysAddress_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + PhysAddress_1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + +asn_dec_rval_t +PhysAddress_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const void *bufptr, size_t size, int tag_mode) { + PhysAddress_1_inherit_TYPE_descriptor(td); + return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); +} + +asn_enc_rval_t +PhysAddress_encode_der(asn_TYPE_descriptor_t *td, + void *structure, int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + PhysAddress_1_inherit_TYPE_descriptor(td); + return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); +} + +asn_dec_rval_t +PhysAddress_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const char *opt_mname, const void *bufptr, size_t size) { + PhysAddress_1_inherit_TYPE_descriptor(td); + return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); +} + +asn_enc_rval_t +PhysAddress_encode_xer(asn_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + PhysAddress_1_inherit_TYPE_descriptor(td); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); +} + +static ber_tlv_tag_t asn_DEF_PhysAddress_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_PhysAddress = { + "PhysAddress", + "PhysAddress", + PhysAddress_free, + PhysAddress_print, + PhysAddress_constraint, + PhysAddress_decode_ber, + PhysAddress_encode_der, + PhysAddress_decode_xer, + PhysAddress_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_PhysAddress_tags_1, + sizeof(asn_DEF_PhysAddress_tags_1) + /sizeof(asn_DEF_PhysAddress_tags_1[0]), /* 1 */ + asn_DEF_PhysAddress_tags_1, /* Same as above */ + sizeof(asn_DEF_PhysAddress_tags_1) + /sizeof(asn_DEF_PhysAddress_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + 0, 0, /* No members */ + 0 /* No specifics */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/PhysAddress.h b/projects/stargazer/plugins/other/snmp/asn1/PhysAddress.h new file mode 100644 index 00000000..d6c5fa17 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/PhysAddress.h @@ -0,0 +1,38 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _PhysAddress_H_ +#define _PhysAddress_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* PhysAddress */ +typedef OCTET_STRING_t PhysAddress_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_PhysAddress; +asn_struct_free_f PhysAddress_free; +asn_struct_print_f PhysAddress_print; +asn_constr_check_f PhysAddress_constraint; +ber_type_decoder_f PhysAddress_decode_ber; +der_type_encoder_f PhysAddress_encode_der; +xer_type_decoder_f PhysAddress_decode_xer; +xer_type_encoder_f PhysAddress_encode_xer; + +#ifdef __cplusplus +} +#endif + +#endif /* _PhysAddress_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/RFC1155-SMI.asn1 b/projects/stargazer/plugins/other/snmp/asn1/RFC1155-SMI.asn1 new file mode 100644 index 00000000..132e3408 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/RFC1155-SMI.asn1 @@ -0,0 +1,135 @@ + +-- WinAgents MIB Extraction Wizard +-- Extracted from rfc1155.txt 17.03.2005 16:16:50 + +RFC1155-SMI DEFINITIONS ::= BEGIN + +--EXPORTS EVERYTHING +-- internet, directory, mgmt, +-- experimental, private, enterprises, +-- OBJECT-TYPE, ObjectName, ObjectSyntax, SimpleSyntax, +-- ApplicationSyntax, NetworkAddress, IpAddress, +-- Counter, Gauge, TimeTicks, Opaque; + + -- the path to the root + + internet OBJECT IDENTIFIER ::= { iso org(3) dod(6) 1 } + + directory OBJECT IDENTIFIER ::= { internet 1 } + + mgmt OBJECT IDENTIFIER ::= { internet 2 } + + experimental OBJECT IDENTIFIER ::= { internet 3 } + + private OBJECT IDENTIFIER ::= { internet 4 } + enterprises OBJECT IDENTIFIER ::= { private 1 } + + + -- definition of object types + +-- MIB Extraction: All MACRO definitions are predefined by compiler +-- commented by MIB Extraction: OBJECT-TYPE MACRO ::= +-- commented by MIB Extraction: BEGIN +-- commented by MIB Extraction: TYPE NOTATION ::= "SYNTAX" type (TYPE ObjectSyntax) +-- commented by MIB Extraction: "ACCESS" Access +-- commented by MIB Extraction: "STATUS" Status +-- commented by MIB Extraction: VALUE NOTATION ::= value (VALUE ObjectName) +-- commented by MIB Extraction: +-- commented by MIB Extraction: Access ::= "read-only" +-- commented by MIB Extraction: | "read-write" +-- commented by MIB Extraction: | "write-only" +-- commented by MIB Extraction: | "not-accessible" +-- commented by MIB Extraction: Status ::= "mandatory" +-- commented by MIB Extraction: | "optional" +-- commented by MIB Extraction: | "obsolete" +-- commented by MIB Extraction: END + + -- names of objects in the MIB + + ObjectName ::= + OBJECT IDENTIFIER + + + -- syntax of objects in the MIB + + ObjectSyntax ::= + CHOICE { + simple + SimpleSyntax, + + -- note that simple SEQUENCEs are not directly + -- mentioned here to keep things simple (i.e., + -- prevent mis-use). However, application-wide + -- types which are IMPLICITly encoded simple + -- SEQUENCEs may appear in the following CHOICE + + application-wide + ApplicationSyntax + } + + SimpleSyntax ::= + CHOICE { + number + INTEGER, + + string + OCTET STRING, + + object + OBJECT IDENTIFIER, + + empty + NULL + } + + ApplicationSyntax ::= + CHOICE { + address + NetworkAddress, + + counter + Counter, + + gauge + Gauge, + + ticks + TimeTicks, + + arbitrary + Opaque + + -- other application-wide types, as they are + -- defined, will be added here + } + + + -- application-wide types + + NetworkAddress ::= + CHOICE { + internet + IpAddress + } + + IpAddress ::= + [APPLICATION 0] -- in network-byte order + IMPLICIT OCTET STRING (SIZE (4)) + + Counter ::= + [APPLICATION 1] + IMPLICIT INTEGER (0..4294967295) + + Gauge ::= + [APPLICATION 2] + IMPLICIT INTEGER (0..4294967295) + + TimeTicks ::= + [APPLICATION 3] + IMPLICIT INTEGER (0..4294967295) + + Opaque ::= + [APPLICATION 4] -- arbitrary ASN.1 value, + IMPLICIT OCTET STRING -- "double-wrapped" + + END diff --git a/projects/stargazer/plugins/other/snmp/asn1/RFC1157-SNMP.asn1 b/projects/stargazer/plugins/other/snmp/asn1/RFC1157-SNMP.asn1 new file mode 100644 index 00000000..166f7e78 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/RFC1157-SNMP.asn1 @@ -0,0 +1,143 @@ + +-- WinAgents MIB Extraction Wizard +-- Extracted from rfc1157.txt 16.03.2005 20:20:14 + +RFC1157-SNMP DEFINITIONS ::= BEGIN + + IMPORTS + ObjectName, ObjectSyntax, NetworkAddress, IpAddress, TimeTicks + FROM RFC1155-SMI; + + + -- top-level message + + Message ::= + SEQUENCE { + version -- version-1 for this RFC + INTEGER { + version-1(0) + }, + + community -- community name + OCTET STRING, + + data -- e.g., PDUs if trivial + ANY -- authentication is being used + } + + + -- protocol data units + + PDUs ::= + CHOICE { + get-request + GetRequest-PDU, + + get-next-request + GetNextRequest-PDU, + + get-response + GetResponse-PDU, + + set-request + SetRequest-PDU, + + trap + Trap-PDU + } + + + + + -- PDUs + + GetRequest-PDU ::= + [0] + IMPLICIT PDU + + GetNextRequest-PDU ::= + [1] + IMPLICIT PDU + + GetResponse-PDU ::= + [2] + IMPLICIT PDU + + SetRequest-PDU ::= + [3] + IMPLICIT PDU + + PDU ::= + SEQUENCE { + request-id + INTEGER, + + error-status -- sometimes ignored + INTEGER { + noError(0), + tooBig(1), + noSuchName(2), + badValue(3), + readOnly(4), + genErr(5) + }, + + error-index -- sometimes ignored + INTEGER, + + variable-bindings -- values are sometimes ignored + VarBindList + } + + Trap-PDU ::= + [4] + IMPLICIT SEQUENCE { + enterprise -- type of object generating + -- trap, see sysObjectID in [5] + + + OBJECT IDENTIFIER, + + agent-addr -- address of object generating + NetworkAddress, -- trap + + generic-trap -- generic trap type + INTEGER { + coldStart(0), + warmStart(1), + linkDown(2), + linkUp(3), + authenticationFailure(4), + egpNeighborLoss(5), + enterpriseSpecific(6) + }, + + specific-trap -- specific code, present even + INTEGER, -- if generic-trap is not + -- enterpriseSpecific + + time-stamp -- time elapsed between the last + TimeTicks, -- (re)initialization of the network + -- entity and the generation of the trap + + variable-bindings -- "interesting" information + VarBindList + } + + + -- variable bindings + + VarBind ::= + SEQUENCE { + name + ObjectName, + + value + ObjectSyntax + } + + VarBindList ::= + SEQUENCE OF + VarBind + + END \ No newline at end of file diff --git a/projects/stargazer/plugins/other/snmp/asn1/RFC1213-MIB.asn1 b/projects/stargazer/plugins/other/snmp/asn1/RFC1213-MIB.asn1 new file mode 100644 index 00000000..b9b1e857 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/RFC1213-MIB.asn1 @@ -0,0 +1,339 @@ + +-- WinAgents MIB Extraction Wizard +-- Extracted from rfc1213.txt 16.03.2005 20:20:14 + +RFC1213-MIB DEFINITIONS ::= BEGIN + +IMPORTS + mgmt, NetworkAddress, IpAddress, Counter, Gauge, + TimeTicks + FROM RFC1155-SMI + OBJECT-TYPE + FROM RFC-1212; + +-- This MIB module uses the extended OBJECT-TYPE macro as +-- defined in [14]; + + +-- MIB-II (same prefix as MIB-I) + +mib-2 OBJECT IDENTIFIER ::= { mgmt 1 } + +-- textual conventions + +DisplayString ::= + OCTET STRING +-- This data type is used to model textual information taken +-- from the NVT ASCII character set. By convention, objects +-- with this syntax are declared as having + +-- +-- SIZE (0..255) + +PhysAddress ::= + OCTET STRING +-- This data type is used to model media addresses. For many +-- types of media, this will be in a binary representation. +-- For example, an ethernet address would be represented as +-- a string of 6 octets. + + +-- groups in MIB-II + +system OBJECT IDENTIFIER ::= { mib-2 1 } + +interfaces OBJECT IDENTIFIER ::= { mib-2 2 } + +at OBJECT IDENTIFIER ::= { mib-2 3 } + +ip OBJECT IDENTIFIER ::= { mib-2 4 } + +icmp OBJECT IDENTIFIER ::= { mib-2 5 } + +tcp OBJECT IDENTIFIER ::= { mib-2 6 } + +udp OBJECT IDENTIFIER ::= { mib-2 7 } + +egp OBJECT IDENTIFIER ::= { mib-2 8 } + +-- historical (some say hysterical) +-- cmot OBJECT IDENTIFIER ::= { mib-2 9 } + +transmission OBJECT IDENTIFIER ::= { mib-2 10 } + +snmp OBJECT IDENTIFIER ::= { mib-2 11 } + + +-- the System group + +-- Implementation of the System group is mandatory for all +-- systems. If an agent is not configured to have a value +-- for any of these variables, a string of length 0 is +-- returned. + + +IfEntry ::= + SEQUENCE { + ifIndex + INTEGER, + + ifDescr + DisplayString, + ifType + INTEGER, + ifMtu + INTEGER, + ifSpeed + Gauge, + ifPhysAddress + PhysAddress, + ifAdminStatus + INTEGER, + ifOperStatus + INTEGER, + ifLastChange + TimeTicks, + ifInOctets + Counter, + ifInUcastPkts + Counter, + ifInNUcastPkts + Counter, + ifInDiscards + Counter, + ifInErrors + Counter, + ifInUnknownProtos + Counter, + ifOutOctets + Counter, + ifOutUcastPkts + Counter, + ifOutNUcastPkts + Counter, + ifOutDiscards + Counter, + ifOutErrors + Counter, + ifOutQLen + Gauge, + ifSpecific + OBJECT IDENTIFIER + } + + +-- the Address Translation group + +-- Implementation of the Address Translation group is +-- mandatory for all systems. Note however that this group +-- is deprecated by MIB-II. That is, it is being included + +-- solely for compatibility with MIB-I nodes, and will most +-- likely be excluded from MIB-III nodes. From MIB-II and +-- onwards, each network protocol group contains its own +-- address translation tables. + +-- The Address Translation group contains one table which is +-- the union across all interfaces of the translation tables +-- for converting a NetworkAddress (e.g., an IP address) into +-- a subnetwork-specific address. For lack of a better term, +-- this document refers to such a subnetwork-specific address +-- as a `physical' address. + +-- Examples of such translation tables are: for broadcast +-- media where ARP is in use, the translation table is +-- equivalent to the ARP cache; or, on an X.25 network where +-- non-algorithmic translation to X.121 addresses is +-- required, the translation table contains the +-- NetworkAddress to X.121 address equivalences. + + +AtEntry ::= + SEQUENCE { + atIfIndex + INTEGER, + + atPhysAddress + PhysAddress, + atNetAddress + NetworkAddress + } + + + + + +-- the IP address table + +-- The IP address table contains this entity's IP addressing +-- information. + + +IpAddrEntry ::= + SEQUENCE { + ipAdEntAddr + IpAddress, + ipAdEntIfIndex + INTEGER, + ipAdEntNetMask + IpAddress, + ipAdEntBcastAddr + INTEGER, + ipAdEntReasmMaxSize + INTEGER (0..65535) + } + + +IpRouteEntry ::= + SEQUENCE { + ipRouteDest + IpAddress, + ipRouteIfIndex + INTEGER, + ipRouteMetric1 + INTEGER, + ipRouteMetric2 + INTEGER, + ipRouteMetric3 + INTEGER, + ipRouteMetric4 + INTEGER, + ipRouteNextHop + IpAddress, + ipRouteType + INTEGER, + ipRouteProto + INTEGER, + ipRouteAge + INTEGER, + ipRouteMask + IpAddress, + ipRouteMetric5 + INTEGER, + + ipRouteInfo + OBJECT IDENTIFIER + } + + +IpNetToMediaEntry ::= + SEQUENCE { + ipNetToMediaIfIndex + INTEGER, + ipNetToMediaPhysAddress + PhysAddress, + ipNetToMediaNetAddress + IpAddress, + ipNetToMediaType + INTEGER + } + + + +TcpConnEntry ::= + SEQUENCE { + tcpConnState + INTEGER, + tcpConnLocalAddress + IpAddress, + tcpConnLocalPort + INTEGER (0..65535), + tcpConnRemAddress + IpAddress, + tcpConnRemPort + INTEGER (0..65535) + } + + +UdpEntry ::= + SEQUENCE { + udpLocalAddress + IpAddress, + udpLocalPort + INTEGER (0..65535) + } + + + +-- the EGP Neighbor table + +-- The EGP neighbor table contains information about this +-- entity's EGP neighbors. + + +EgpNeighEntry ::= + SEQUENCE { + egpNeighState + INTEGER, + egpNeighAddr + IpAddress, + egpNeighAs + INTEGER, + egpNeighInMsgs + Counter, + egpNeighInErrs + Counter, + egpNeighOutMsgs + Counter, + egpNeighOutErrs + Counter, + + egpNeighInErrMsgs + Counter, + egpNeighOutErrMsgs + Counter, + egpNeighStateUps + Counter, + egpNeighStateDowns + Counter, + egpNeighIntervalHello + INTEGER, + egpNeighIntervalPoll + INTEGER, + egpNeighMode + INTEGER, + egpNeighEventTrigger + INTEGER + } + + + +-- the Transmission group + +-- Based on the transmission media underlying each interface +-- on a system, the corresponding portion of the Transmission +-- group is mandatory for that system. + +-- When Internet-standard definitions for managing +-- transmission media are defined, the transmission group is +-- used to provide a prefix for the names of those objects. + +-- Typically, such definitions reside in the experimental +-- portion of the MIB until they are "proven", then as a +-- part of the Internet standardization process, the +-- definitions are accordingly elevated and a new object +-- identifier, under the transmission group is defined. By +-- convention, the name assigned is: +-- +-- type OBJECT IDENTIFIER ::= { transmission number } +-- +-- where "type" is the symbolic value used for the media in +-- the ifType column of the ifTable object, and "number" is +-- the actual integer value corresponding to the symbol. + + +-- the SNMP group + +-- Implementation of the SNMP group is mandatory for all +-- systems which support an SNMP protocol entity. Some of +-- the objects defined below will be zero-valued in those +-- SNMP implementations that are optimized to support only +-- those functions specific to either a management agent or +-- a management station. In particular, it should be +-- observed that the objects below refer to an SNMP entity, +-- and there may be several SNMP entities residing on a +-- managed node (e.g., if the node is hosting acting as +-- a management station). + + +END diff --git a/projects/stargazer/plugins/other/snmp/asn1/RReqPDU.c b/projects/stargazer/plugins/other/snmp/asn1/RReqPDU.c new file mode 100644 index 00000000..b19c3548 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/RReqPDU.c @@ -0,0 +1,107 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "SMUX" + * found in "SMUX.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "RReqPDU.h" + +static int +memb_priority_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + long value; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + value = *(const long *)sptr; + + if((value >= -1 && value <= 2147483647)) { + /* Constraint check succeeded */ + return 0; + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_TYPE_member_t asn_MBR_RReqPDU_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct RReqPDU, subtree), + (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), + 0, + &asn_DEF_ObjectName, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "subtree" + }, + { ATF_NOFLAGS, 0, offsetof(struct RReqPDU, priority), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_NativeInteger, + memb_priority_constraint_1, + 0, /* PER is not compiled, use -gen-PER */ + 0, + "priority" + }, + { ATF_NOFLAGS, 0, offsetof(struct RReqPDU, operation), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "operation" + }, +}; +static ber_tlv_tag_t asn_DEF_RReqPDU_tags_1[] = { + (ASN_TAG_CLASS_APPLICATION | (2 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_RReqPDU_tag2el_1[] = { + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 1 }, /* priority at 96 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, -1, 0 }, /* operation at 101 */ + { (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), 0, 0, 0 } /* subtree at 93 */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_RReqPDU_specs_1 = { + sizeof(struct RReqPDU), + offsetof(struct RReqPDU, _asn_ctx), + asn_MAP_RReqPDU_tag2el_1, + 3, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* Start extensions */ + -1 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_RReqPDU = { + "RReqPDU", + "RReqPDU", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RReqPDU_tags_1, + sizeof(asn_DEF_RReqPDU_tags_1) + /sizeof(asn_DEF_RReqPDU_tags_1[0]) - 1, /* 1 */ + asn_DEF_RReqPDU_tags_1, /* Same as above */ + sizeof(asn_DEF_RReqPDU_tags_1) + /sizeof(asn_DEF_RReqPDU_tags_1[0]), /* 2 */ + 0, /* No PER visible constraints */ + asn_MBR_RReqPDU_1, + 3, /* Elements count */ + &asn_SPC_RReqPDU_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/RReqPDU.h b/projects/stargazer/plugins/other/snmp/asn1/RReqPDU.h new file mode 100644 index 00000000..17f53094 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/RReqPDU.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "SMUX" + * found in "SMUX.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _RReqPDU_H_ +#define _RReqPDU_H_ + + +#include + +/* Including external dependencies */ +#include "ObjectName.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum RReqPDU__operation { + RReqPDU__operation_delete = 0, + RReqPDU__operation_readOnly = 1, + RReqPDU__operation_readWrite = 2 +} e_RReqPDU__operation; + +/* RReqPDU */ +typedef struct RReqPDU { + ObjectName_t subtree; + long priority; + INTEGER_t operation; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} RReqPDU_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RReqPDU; + +#ifdef __cplusplus +} +#endif + +#endif /* _RReqPDU_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/RRspPDU.c b/projects/stargazer/plugins/other/snmp/asn1/RRspPDU.c new file mode 100644 index 00000000..b80080b1 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/RRspPDU.c @@ -0,0 +1,111 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "SMUX" + * found in "SMUX.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "RRspPDU.h" + +int +RRspPDU_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + /* Replace with underlying type checker */ + td->check_constraints = asn_DEF_INTEGER.check_constraints; + return td->check_constraints(td, sptr, ctfailcb, app_key); +} + +/* + * This type is implemented using INTEGER, + * so here we adjust the DEF accordingly. + */ +static void +RRspPDU_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { + td->free_struct = asn_DEF_INTEGER.free_struct; + td->print_struct = asn_DEF_INTEGER.print_struct; + td->ber_decoder = asn_DEF_INTEGER.ber_decoder; + td->der_encoder = asn_DEF_INTEGER.der_encoder; + td->xer_decoder = asn_DEF_INTEGER.xer_decoder; + td->xer_encoder = asn_DEF_INTEGER.xer_encoder; + td->uper_decoder = asn_DEF_INTEGER.uper_decoder; + td->uper_encoder = asn_DEF_INTEGER.uper_encoder; + if(!td->per_constraints) + td->per_constraints = asn_DEF_INTEGER.per_constraints; + td->elements = asn_DEF_INTEGER.elements; + td->elements_count = asn_DEF_INTEGER.elements_count; + td->specifics = asn_DEF_INTEGER.specifics; +} + +void +RRspPDU_free(asn_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + RRspPDU_1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +RRspPDU_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + RRspPDU_1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + +asn_dec_rval_t +RRspPDU_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const void *bufptr, size_t size, int tag_mode) { + RRspPDU_1_inherit_TYPE_descriptor(td); + return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); +} + +asn_enc_rval_t +RRspPDU_encode_der(asn_TYPE_descriptor_t *td, + void *structure, int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + RRspPDU_1_inherit_TYPE_descriptor(td); + return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); +} + +asn_dec_rval_t +RRspPDU_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const char *opt_mname, const void *bufptr, size_t size) { + RRspPDU_1_inherit_TYPE_descriptor(td); + return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); +} + +asn_enc_rval_t +RRspPDU_encode_xer(asn_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + RRspPDU_1_inherit_TYPE_descriptor(td); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); +} + +static ber_tlv_tag_t asn_DEF_RRspPDU_tags_1[] = { + (ASN_TAG_CLASS_APPLICATION | (3 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_RRspPDU = { + "RRspPDU", + "RRspPDU", + RRspPDU_free, + RRspPDU_print, + RRspPDU_constraint, + RRspPDU_decode_ber, + RRspPDU_encode_der, + RRspPDU_decode_xer, + RRspPDU_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_RRspPDU_tags_1, + sizeof(asn_DEF_RRspPDU_tags_1) + /sizeof(asn_DEF_RRspPDU_tags_1[0]) - 1, /* 1 */ + asn_DEF_RRspPDU_tags_1, /* Same as above */ + sizeof(asn_DEF_RRspPDU_tags_1) + /sizeof(asn_DEF_RRspPDU_tags_1[0]), /* 2 */ + 0, /* No PER visible constraints */ + 0, 0, /* Defined elsewhere */ + 0 /* No specifics */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/RRspPDU.h b/projects/stargazer/plugins/other/snmp/asn1/RRspPDU.h new file mode 100644 index 00000000..0d9681ac --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/RRspPDU.h @@ -0,0 +1,43 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "SMUX" + * found in "SMUX.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _RRspPDU_H_ +#define _RRspPDU_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum RRspPDU { + RRspPDU_failure = -1 +} e_RRspPDU; + +/* RRspPDU */ +typedef INTEGER_t RRspPDU_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_RRspPDU; +asn_struct_free_f RRspPDU_free; +asn_struct_print_f RRspPDU_print; +asn_constr_check_f RRspPDU_constraint; +ber_type_decoder_f RRspPDU_decode_ber; +der_type_encoder_f RRspPDU_encode_der; +xer_type_decoder_f RRspPDU_decode_xer; +xer_type_encoder_f RRspPDU_encode_xer; + +#ifdef __cplusplus +} +#endif + +#endif /* _RRspPDU_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/SMUX-PDUs.c b/projects/stargazer/plugins/other/snmp/asn1/SMUX-PDUs.c new file mode 100644 index 00000000..9942f998 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/SMUX-PDUs.c @@ -0,0 +1,111 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "SMUX" + * found in "SMUX.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "SMUX-PDUs.h" + +static asn_TYPE_member_t asn_MBR_SMUX_PDUs_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct SMUX_PDUs, choice.open), + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_OpenPDU, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "open" + }, + { ATF_NOFLAGS, 0, offsetof(struct SMUX_PDUs, choice.close), + (ASN_TAG_CLASS_APPLICATION | (1 << 2)), + 0, + &asn_DEF_ClosePDU, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "close" + }, + { ATF_NOFLAGS, 0, offsetof(struct SMUX_PDUs, choice.registerRequest), + (ASN_TAG_CLASS_APPLICATION | (2 << 2)), + 0, + &asn_DEF_RReqPDU, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "registerRequest" + }, + { ATF_NOFLAGS, 0, offsetof(struct SMUX_PDUs, choice.registerResponse), + (ASN_TAG_CLASS_APPLICATION | (3 << 2)), + 0, + &asn_DEF_RRspPDU, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "registerResponse" + }, + { ATF_NOFLAGS, 0, offsetof(struct SMUX_PDUs, choice.pdus), + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_PDUs, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "pdus" + }, + { ATF_NOFLAGS, 0, offsetof(struct SMUX_PDUs, choice.commitOrRollback), + (ASN_TAG_CLASS_APPLICATION | (4 << 2)), + 0, + &asn_DEF_SOutPDU, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "commitOrRollback" + }, +}; +static asn_TYPE_tag2member_t asn_MAP_SMUX_PDUs_tag2el_1[] = { + { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 0, 0, 0 }, /* simple at 52 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 1, 0, 0 }, /* close at 27 */ + { (ASN_TAG_CLASS_APPLICATION | (2 << 2)), 2, 0, 0 }, /* registerRequest at 30 */ + { (ASN_TAG_CLASS_APPLICATION | (3 << 2)), 3, 0, 0 }, /* registerResponse at 33 */ + { (ASN_TAG_CLASS_APPLICATION | (4 << 2)), 5, 0, 0 }, /* commitOrRollback at 41 */ + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 4, 0, 0 }, /* get-request at 34 */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 4, 0, 0 }, /* get-next-request at 37 */ + { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 4, 0, 0 }, /* get-response at 40 */ + { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 4, 0, 0 }, /* set-request at 43 */ + { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* trap at 47 */ +}; +static asn_CHOICE_specifics_t asn_SPC_SMUX_PDUs_specs_1 = { + sizeof(struct SMUX_PDUs), + offsetof(struct SMUX_PDUs, _asn_ctx), + offsetof(struct SMUX_PDUs, present), + sizeof(((struct SMUX_PDUs *)0)->present), + asn_MAP_SMUX_PDUs_tag2el_1, + 10, /* Count of tags in the map */ + 0, + -1 /* Extensions start */ +}; +asn_TYPE_descriptor_t asn_DEF_SMUX_PDUs = { + "SMUX-PDUs", + "SMUX-PDUs", + CHOICE_free, + CHOICE_print, + CHOICE_constraint, + CHOICE_decode_ber, + CHOICE_encode_der, + CHOICE_decode_xer, + CHOICE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + CHOICE_outmost_tag, + 0, /* No effective tags (pointer) */ + 0, /* No effective tags (count) */ + 0, /* No tags (pointer) */ + 0, /* No tags (count) */ + 0, /* No PER visible constraints */ + asn_MBR_SMUX_PDUs_1, + 6, /* Elements count */ + &asn_SPC_SMUX_PDUs_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/SMUX-PDUs.h b/projects/stargazer/plugins/other/snmp/asn1/SMUX-PDUs.h new file mode 100644 index 00000000..84893249 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/SMUX-PDUs.h @@ -0,0 +1,61 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "SMUX" + * found in "SMUX.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _SMUX_PDUs_H_ +#define _SMUX_PDUs_H_ + + +#include + +/* Including external dependencies */ +#include "OpenPDU.h" +#include "ClosePDU.h" +#include "RReqPDU.h" +#include "RRspPDU.h" +#include "PDUs.h" +#include "SOutPDU.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum SMUX_PDUs_PR { + SMUX_PDUs_PR_NOTHING, /* No components present */ + SMUX_PDUs_PR_open, + SMUX_PDUs_PR_close, + SMUX_PDUs_PR_registerRequest, + SMUX_PDUs_PR_registerResponse, + SMUX_PDUs_PR_pdus, + SMUX_PDUs_PR_commitOrRollback +} SMUX_PDUs_PR; + +/* SMUX-PDUs */ +typedef struct SMUX_PDUs { + SMUX_PDUs_PR present; + union SMUX_PDUs_u { + OpenPDU_t open; + ClosePDU_t close; + RReqPDU_t registerRequest; + RRspPDU_t registerResponse; + PDUs_t pdus; + SOutPDU_t commitOrRollback; + } choice; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} SMUX_PDUs_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_SMUX_PDUs; + +#ifdef __cplusplus +} +#endif + +#endif /* _SMUX_PDUs_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/SMUX.asn1 b/projects/stargazer/plugins/other/snmp/asn1/SMUX.asn1 new file mode 100644 index 00000000..af7748fd --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/SMUX.asn1 @@ -0,0 +1,122 @@ + +-- WinAgents MIB Extraction Wizard +-- Extracted from rfc1227.txt 16.03.2005 20:20:14 + +SMUX DEFINITIONS ::= BEGIN + +IMPORTS + ObjectName + FROM RFC1155-SMI + DisplayString + FROM RFC1213-MIB + + PDUs + FROM RFC1157-SNMP; + + +-- tags for SMUX-specific PDUs are application-wide to +-- avoid conflict with tags for current (and future) +-- SNMP-generic PDUs + +SMUX-PDUs ::= + CHOICE { + open -- SMUX peer uses + OpenPDU, -- immediately after TCP open + + close -- either uses immediately before TCP close + ClosePDU, + + registerRequest -- SMUX peer uses + RReqPDU, + + registerResponse -- SNMP agent uses + RRspPDU, + + PDUs, -- note that roles are reversed: + -- SNMP agent does get/get-next/set + -- SMUX peer does get-response/trap + + commitOrRollback -- SNMP agent uses + SOutPDU + } + + +-- open PDU +-- currently only simple authentication + +OpenPDU ::= + CHOICE { + simple + + SimpleOpen + } + +SimpleOpen ::= + [APPLICATION 0] IMPLICIT + SEQUENCE { + version -- of SMUX protocol + INTEGER { + version-1(0) + }, + + identity -- of SMUX peer, authoritative + OBJECT IDENTIFIER, + + description -- of SMUX peer, implementation-specific + DisplayString, + + password -- zero length indicates no authentication + OCTET STRING + } + + +-- close PDU + +ClosePDU ::= + [APPLICATION 1] IMPLICIT + INTEGER { + goingDown(0), + unsupportedVersion(1), + packetFormat(2), + protocolError(3), + internalError(4), + authenticationFailure(5) + } + + +-- insert PDU + +RReqPDU ::= + [APPLICATION 2] IMPLICIT + SEQUENCE { + subtree + ObjectName, + + priority -- the lower the better, "-1" means default + INTEGER (-1..2147483647), + + operation + + INTEGER { + delete(0), -- remove registration + readOnly(1), -- add registration, objects are RO + readWrite(2) -- .., objects are RW + } + } + +RRspPDU ::= + [APPLICATION 3] IMPLICIT + INTEGER { + failure(-1) + + -- on success the non-negative priority is returned + } + +SOutPDU ::= + [APPLICATION 4] IMPLICIT + INTEGER { + commit(0), + rollback(1) + } + +END \ No newline at end of file diff --git a/projects/stargazer/plugins/other/snmp/asn1/SOutPDU.c b/projects/stargazer/plugins/other/snmp/asn1/SOutPDU.c new file mode 100644 index 00000000..6d3521bf --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/SOutPDU.c @@ -0,0 +1,111 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "SMUX" + * found in "SMUX.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "SOutPDU.h" + +int +SOutPDU_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + /* Replace with underlying type checker */ + td->check_constraints = asn_DEF_INTEGER.check_constraints; + return td->check_constraints(td, sptr, ctfailcb, app_key); +} + +/* + * This type is implemented using INTEGER, + * so here we adjust the DEF accordingly. + */ +static void +SOutPDU_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { + td->free_struct = asn_DEF_INTEGER.free_struct; + td->print_struct = asn_DEF_INTEGER.print_struct; + td->ber_decoder = asn_DEF_INTEGER.ber_decoder; + td->der_encoder = asn_DEF_INTEGER.der_encoder; + td->xer_decoder = asn_DEF_INTEGER.xer_decoder; + td->xer_encoder = asn_DEF_INTEGER.xer_encoder; + td->uper_decoder = asn_DEF_INTEGER.uper_decoder; + td->uper_encoder = asn_DEF_INTEGER.uper_encoder; + if(!td->per_constraints) + td->per_constraints = asn_DEF_INTEGER.per_constraints; + td->elements = asn_DEF_INTEGER.elements; + td->elements_count = asn_DEF_INTEGER.elements_count; + td->specifics = asn_DEF_INTEGER.specifics; +} + +void +SOutPDU_free(asn_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + SOutPDU_1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +SOutPDU_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + SOutPDU_1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + +asn_dec_rval_t +SOutPDU_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const void *bufptr, size_t size, int tag_mode) { + SOutPDU_1_inherit_TYPE_descriptor(td); + return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); +} + +asn_enc_rval_t +SOutPDU_encode_der(asn_TYPE_descriptor_t *td, + void *structure, int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + SOutPDU_1_inherit_TYPE_descriptor(td); + return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); +} + +asn_dec_rval_t +SOutPDU_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const char *opt_mname, const void *bufptr, size_t size) { + SOutPDU_1_inherit_TYPE_descriptor(td); + return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); +} + +asn_enc_rval_t +SOutPDU_encode_xer(asn_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + SOutPDU_1_inherit_TYPE_descriptor(td); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); +} + +static ber_tlv_tag_t asn_DEF_SOutPDU_tags_1[] = { + (ASN_TAG_CLASS_APPLICATION | (4 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_SOutPDU = { + "SOutPDU", + "SOutPDU", + SOutPDU_free, + SOutPDU_print, + SOutPDU_constraint, + SOutPDU_decode_ber, + SOutPDU_encode_der, + SOutPDU_decode_xer, + SOutPDU_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_SOutPDU_tags_1, + sizeof(asn_DEF_SOutPDU_tags_1) + /sizeof(asn_DEF_SOutPDU_tags_1[0]) - 1, /* 1 */ + asn_DEF_SOutPDU_tags_1, /* Same as above */ + sizeof(asn_DEF_SOutPDU_tags_1) + /sizeof(asn_DEF_SOutPDU_tags_1[0]), /* 2 */ + 0, /* No PER visible constraints */ + 0, 0, /* Defined elsewhere */ + 0 /* No specifics */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/SOutPDU.h b/projects/stargazer/plugins/other/snmp/asn1/SOutPDU.h new file mode 100644 index 00000000..55e76185 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/SOutPDU.h @@ -0,0 +1,44 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "SMUX" + * found in "SMUX.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _SOutPDU_H_ +#define _SOutPDU_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum SOutPDU { + SOutPDU_commit = 0, + SOutPDU_rollback = 1 +} e_SOutPDU; + +/* SOutPDU */ +typedef INTEGER_t SOutPDU_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_SOutPDU; +asn_struct_free_f SOutPDU_free; +asn_struct_print_f SOutPDU_print; +asn_constr_check_f SOutPDU_constraint; +ber_type_decoder_f SOutPDU_decode_ber; +der_type_encoder_f SOutPDU_encode_der; +xer_type_decoder_f SOutPDU_decode_xer; +xer_type_encoder_f SOutPDU_encode_xer; + +#ifdef __cplusplus +} +#endif + +#endif /* _SOutPDU_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/SetRequest-PDU.c b/projects/stargazer/plugins/other/snmp/asn1/SetRequest-PDU.c new file mode 100644 index 00000000..08d30387 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/SetRequest-PDU.c @@ -0,0 +1,111 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "SetRequest-PDU.h" + +int +SetRequest_PDU_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + /* Replace with underlying type checker */ + td->check_constraints = asn_DEF_PDU.check_constraints; + return td->check_constraints(td, sptr, ctfailcb, app_key); +} + +/* + * This type is implemented using PDU, + * so here we adjust the DEF accordingly. + */ +static void +SetRequest_PDU_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { + td->free_struct = asn_DEF_PDU.free_struct; + td->print_struct = asn_DEF_PDU.print_struct; + td->ber_decoder = asn_DEF_PDU.ber_decoder; + td->der_encoder = asn_DEF_PDU.der_encoder; + td->xer_decoder = asn_DEF_PDU.xer_decoder; + td->xer_encoder = asn_DEF_PDU.xer_encoder; + td->uper_decoder = asn_DEF_PDU.uper_decoder; + td->uper_encoder = asn_DEF_PDU.uper_encoder; + if(!td->per_constraints) + td->per_constraints = asn_DEF_PDU.per_constraints; + td->elements = asn_DEF_PDU.elements; + td->elements_count = asn_DEF_PDU.elements_count; + td->specifics = asn_DEF_PDU.specifics; +} + +void +SetRequest_PDU_free(asn_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + SetRequest_PDU_1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +SetRequest_PDU_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + SetRequest_PDU_1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + +asn_dec_rval_t +SetRequest_PDU_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const void *bufptr, size_t size, int tag_mode) { + SetRequest_PDU_1_inherit_TYPE_descriptor(td); + return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); +} + +asn_enc_rval_t +SetRequest_PDU_encode_der(asn_TYPE_descriptor_t *td, + void *structure, int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + SetRequest_PDU_1_inherit_TYPE_descriptor(td); + return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); +} + +asn_dec_rval_t +SetRequest_PDU_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const char *opt_mname, const void *bufptr, size_t size) { + SetRequest_PDU_1_inherit_TYPE_descriptor(td); + return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); +} + +asn_enc_rval_t +SetRequest_PDU_encode_xer(asn_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + SetRequest_PDU_1_inherit_TYPE_descriptor(td); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); +} + +static ber_tlv_tag_t asn_DEF_SetRequest_PDU_tags_1[] = { + (ASN_TAG_CLASS_CONTEXT | (3 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_SetRequest_PDU = { + "SetRequest-PDU", + "SetRequest-PDU", + SetRequest_PDU_free, + SetRequest_PDU_print, + SetRequest_PDU_constraint, + SetRequest_PDU_decode_ber, + SetRequest_PDU_encode_der, + SetRequest_PDU_decode_xer, + SetRequest_PDU_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_SetRequest_PDU_tags_1, + sizeof(asn_DEF_SetRequest_PDU_tags_1) + /sizeof(asn_DEF_SetRequest_PDU_tags_1[0]) - 1, /* 1 */ + asn_DEF_SetRequest_PDU_tags_1, /* Same as above */ + sizeof(asn_DEF_SetRequest_PDU_tags_1) + /sizeof(asn_DEF_SetRequest_PDU_tags_1[0]), /* 2 */ + 0, /* No PER visible constraints */ + 0, 0, /* Defined elsewhere */ + 0 /* No specifics */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/SetRequest-PDU.h b/projects/stargazer/plugins/other/snmp/asn1/SetRequest-PDU.h new file mode 100644 index 00000000..8854574c --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/SetRequest-PDU.h @@ -0,0 +1,38 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _SetRequest_PDU_H_ +#define _SetRequest_PDU_H_ + + +#include + +/* Including external dependencies */ +#include "PDU.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* SetRequest-PDU */ +typedef PDU_t SetRequest_PDU_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_SetRequest_PDU; +asn_struct_free_f SetRequest_PDU_free; +asn_struct_print_f SetRequest_PDU_print; +asn_constr_check_f SetRequest_PDU_constraint; +ber_type_decoder_f SetRequest_PDU_decode_ber; +der_type_encoder_f SetRequest_PDU_encode_der; +xer_type_decoder_f SetRequest_PDU_decode_xer; +xer_type_encoder_f SetRequest_PDU_encode_xer; + +#ifdef __cplusplus +} +#endif + +#endif /* _SetRequest_PDU_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/SimpleOpen.c b/projects/stargazer/plugins/other/snmp/asn1/SimpleOpen.c new file mode 100644 index 00000000..ec267687 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/SimpleOpen.c @@ -0,0 +1,92 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "SMUX" + * found in "SMUX.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "SimpleOpen.h" + +static asn_TYPE_member_t asn_MBR_SimpleOpen_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct SimpleOpen, version), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "version" + }, + { ATF_NOFLAGS, 0, offsetof(struct SimpleOpen, identity), + (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), + 0, + &asn_DEF_OBJECT_IDENTIFIER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "identity" + }, + { ATF_NOFLAGS, 0, offsetof(struct SimpleOpen, description), + (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), + 0, + &asn_DEF_DisplayString, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "description" + }, + { ATF_NOFLAGS, 0, offsetof(struct SimpleOpen, password), + (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), + 0, + &asn_DEF_OCTET_STRING, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "password" + }, +}; +static ber_tlv_tag_t asn_DEF_SimpleOpen_tags_1[] = { + (ASN_TAG_CLASS_APPLICATION | (0 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_SimpleOpen_tag2el_1[] = { + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* version at 59 */ + { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 2, 0, 1 }, /* description at 66 */ + { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 3, -1, 0 }, /* password at 69 */ + { (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), 1, 0, 0 } /* identity at 63 */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_SimpleOpen_specs_1 = { + sizeof(struct SimpleOpen), + offsetof(struct SimpleOpen, _asn_ctx), + asn_MAP_SimpleOpen_tag2el_1, + 4, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* Start extensions */ + -1 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_SimpleOpen = { + "SimpleOpen", + "SimpleOpen", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_SimpleOpen_tags_1, + sizeof(asn_DEF_SimpleOpen_tags_1) + /sizeof(asn_DEF_SimpleOpen_tags_1[0]) - 1, /* 1 */ + asn_DEF_SimpleOpen_tags_1, /* Same as above */ + sizeof(asn_DEF_SimpleOpen_tags_1) + /sizeof(asn_DEF_SimpleOpen_tags_1[0]), /* 2 */ + 0, /* No PER visible constraints */ + asn_MBR_SimpleOpen_1, + 4, /* Elements count */ + &asn_SPC_SimpleOpen_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/SimpleOpen.h b/projects/stargazer/plugins/other/snmp/asn1/SimpleOpen.h new file mode 100644 index 00000000..5950a6c1 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/SimpleOpen.h @@ -0,0 +1,48 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "SMUX" + * found in "SMUX.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _SimpleOpen_H_ +#define _SimpleOpen_H_ + + +#include + +/* Including external dependencies */ +#include +#include +#include "DisplayString.h" +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum SimpleOpen__version { + SimpleOpen__version_version_1 = 0 +} e_SimpleOpen__version; + +/* SimpleOpen */ +typedef struct SimpleOpen { + INTEGER_t version; + OBJECT_IDENTIFIER_t identity; + DisplayString_t description; + OCTET_STRING_t password; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} SimpleOpen_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_SimpleOpen; + +#ifdef __cplusplus +} +#endif + +#endif /* _SimpleOpen_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/SimpleSyntax.c b/projects/stargazer/plugins/other/snmp/asn1/SimpleSyntax.c new file mode 100644 index 00000000..72a11c0a --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/SimpleSyntax.c @@ -0,0 +1,87 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "SimpleSyntax.h" + +static asn_TYPE_member_t asn_MBR_SimpleSyntax_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct SimpleSyntax, choice.number), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "number" + }, + { ATF_NOFLAGS, 0, offsetof(struct SimpleSyntax, choice.string), + (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), + 0, + &asn_DEF_OCTET_STRING, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "string" + }, + { ATF_NOFLAGS, 0, offsetof(struct SimpleSyntax, choice.object), + (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), + 0, + &asn_DEF_OBJECT_IDENTIFIER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "object" + }, + { ATF_NOFLAGS, 0, offsetof(struct SimpleSyntax, choice.empty), + (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)), + 0, + &asn_DEF_NULL, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "empty" + }, +}; +static asn_TYPE_tag2member_t asn_MAP_SimpleSyntax_tag2el_1[] = { + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* number at 73 */ + { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 1, 0, 0 }, /* string at 76 */ + { (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)), 3, 0, 0 }, /* empty at 82 */ + { (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), 2, 0, 0 } /* object at 79 */ +}; +static asn_CHOICE_specifics_t asn_SPC_SimpleSyntax_specs_1 = { + sizeof(struct SimpleSyntax), + offsetof(struct SimpleSyntax, _asn_ctx), + offsetof(struct SimpleSyntax, present), + sizeof(((struct SimpleSyntax *)0)->present), + asn_MAP_SimpleSyntax_tag2el_1, + 4, /* Count of tags in the map */ + 0, + -1 /* Extensions start */ +}; +asn_TYPE_descriptor_t asn_DEF_SimpleSyntax = { + "SimpleSyntax", + "SimpleSyntax", + CHOICE_free, + CHOICE_print, + CHOICE_constraint, + CHOICE_decode_ber, + CHOICE_encode_der, + CHOICE_decode_xer, + CHOICE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + CHOICE_outmost_tag, + 0, /* No effective tags (pointer) */ + 0, /* No effective tags (count) */ + 0, /* No tags (pointer) */ + 0, /* No tags (count) */ + 0, /* No PER visible constraints */ + asn_MBR_SimpleSyntax_1, + 4, /* Elements count */ + &asn_SPC_SimpleSyntax_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/SimpleSyntax.h b/projects/stargazer/plugins/other/snmp/asn1/SimpleSyntax.h new file mode 100644 index 00000000..c04f3ab2 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/SimpleSyntax.h @@ -0,0 +1,55 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _SimpleSyntax_H_ +#define _SimpleSyntax_H_ + + +#include + +/* Including external dependencies */ +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum SimpleSyntax_PR { + SimpleSyntax_PR_NOTHING, /* No components present */ + SimpleSyntax_PR_number, + SimpleSyntax_PR_string, + SimpleSyntax_PR_object, + SimpleSyntax_PR_empty +} SimpleSyntax_PR; + +/* SimpleSyntax */ +typedef struct SimpleSyntax { + SimpleSyntax_PR present; + union SimpleSyntax_u { + INTEGER_t number; + OCTET_STRING_t string; + OBJECT_IDENTIFIER_t object; + NULL_t empty; + } choice; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} SimpleSyntax_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_SimpleSyntax; + +#ifdef __cplusplus +} +#endif + +#endif /* _SimpleSyntax_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/TcpConnEntry.c b/projects/stargazer/plugins/other/snmp/asn1/TcpConnEntry.c new file mode 100644 index 00000000..1a1c903b --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/TcpConnEntry.c @@ -0,0 +1,151 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "TcpConnEntry.h" + +static int +memb_tcpConnLocalPort_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + long value; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + value = *(const long *)sptr; + + if((value >= 0 && value <= 65535)) { + /* Constraint check succeeded */ + return 0; + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static int +memb_tcpConnRemPort_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + long value; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + value = *(const long *)sptr; + + if((value >= 0 && value <= 65535)) { + /* Constraint check succeeded */ + return 0; + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_TYPE_member_t asn_MBR_TcpConnEntry_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct TcpConnEntry, tcpConnState), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "tcpConnState" + }, + { ATF_NOFLAGS, 0, offsetof(struct TcpConnEntry, tcpConnLocalAddress), + (ASN_TAG_CLASS_APPLICATION | (0 << 2)), + 0, + &asn_DEF_IpAddress, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "tcpConnLocalAddress" + }, + { ATF_NOFLAGS, 0, offsetof(struct TcpConnEntry, tcpConnLocalPort), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_NativeInteger, + memb_tcpConnLocalPort_constraint_1, + 0, /* PER is not compiled, use -gen-PER */ + 0, + "tcpConnLocalPort" + }, + { ATF_NOFLAGS, 0, offsetof(struct TcpConnEntry, tcpConnRemAddress), + (ASN_TAG_CLASS_APPLICATION | (0 << 2)), + 0, + &asn_DEF_IpAddress, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "tcpConnRemAddress" + }, + { ATF_NOFLAGS, 0, offsetof(struct TcpConnEntry, tcpConnRemPort), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_NativeInteger, + memb_tcpConnRemPort_constraint_1, + 0, /* PER is not compiled, use -gen-PER */ + 0, + "tcpConnRemPort" + }, +}; +static ber_tlv_tag_t asn_DEF_TcpConnEntry_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_TcpConnEntry_tag2el_1[] = { + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 2 }, /* tcpConnState at 236 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, -1, 1 }, /* tcpConnLocalPort at 240 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 4, -2, 0 }, /* tcpConnRemPort at 244 */ + { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 1, 0, 1 }, /* tcpConnLocalAddress at 238 */ + { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 3, -1, 0 } /* tcpConnRemAddress at 242 */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_TcpConnEntry_specs_1 = { + sizeof(struct TcpConnEntry), + offsetof(struct TcpConnEntry, _asn_ctx), + asn_MAP_TcpConnEntry_tag2el_1, + 5, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* Start extensions */ + -1 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_TcpConnEntry = { + "TcpConnEntry", + "TcpConnEntry", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_TcpConnEntry_tags_1, + sizeof(asn_DEF_TcpConnEntry_tags_1) + /sizeof(asn_DEF_TcpConnEntry_tags_1[0]), /* 1 */ + asn_DEF_TcpConnEntry_tags_1, /* Same as above */ + sizeof(asn_DEF_TcpConnEntry_tags_1) + /sizeof(asn_DEF_TcpConnEntry_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_TcpConnEntry_1, + 5, /* Elements count */ + &asn_SPC_TcpConnEntry_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/TcpConnEntry.h b/projects/stargazer/plugins/other/snmp/asn1/TcpConnEntry.h new file mode 100644 index 00000000..3160e31f --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/TcpConnEntry.h @@ -0,0 +1,43 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _TcpConnEntry_H_ +#define _TcpConnEntry_H_ + + +#include + +/* Including external dependencies */ +#include +#include "IpAddress.h" +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* TcpConnEntry */ +typedef struct TcpConnEntry { + INTEGER_t tcpConnState; + IpAddress_t tcpConnLocalAddress; + long tcpConnLocalPort; + IpAddress_t tcpConnRemAddress; + long tcpConnRemPort; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} TcpConnEntry_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_TcpConnEntry; + +#ifdef __cplusplus +} +#endif + +#endif /* _TcpConnEntry_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/TimeTicks.c b/projects/stargazer/plugins/other/snmp/asn1/TimeTicks.c new file mode 100644 index 00000000..fad39691 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/TimeTicks.c @@ -0,0 +1,134 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "TimeTicks.h" + +int +TimeTicks_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + const INTEGER_t *st = (const INTEGER_t *)sptr; + long value; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + if(asn_INTEGER2long(st, &value)) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value too large (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + if((value >= 0 && value <= 4294967295)) { + /* Constraint check succeeded */ + return 0; + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +/* + * This type is implemented using INTEGER, + * so here we adjust the DEF accordingly. + */ +static void +TimeTicks_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { + td->free_struct = asn_DEF_INTEGER.free_struct; + td->print_struct = asn_DEF_INTEGER.print_struct; + td->ber_decoder = asn_DEF_INTEGER.ber_decoder; + td->der_encoder = asn_DEF_INTEGER.der_encoder; + td->xer_decoder = asn_DEF_INTEGER.xer_decoder; + td->xer_encoder = asn_DEF_INTEGER.xer_encoder; + td->uper_decoder = asn_DEF_INTEGER.uper_decoder; + td->uper_encoder = asn_DEF_INTEGER.uper_encoder; + if(!td->per_constraints) + td->per_constraints = asn_DEF_INTEGER.per_constraints; + td->elements = asn_DEF_INTEGER.elements; + td->elements_count = asn_DEF_INTEGER.elements_count; + td->specifics = asn_DEF_INTEGER.specifics; +} + +void +TimeTicks_free(asn_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + TimeTicks_1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +TimeTicks_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + TimeTicks_1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + +asn_dec_rval_t +TimeTicks_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const void *bufptr, size_t size, int tag_mode) { + TimeTicks_1_inherit_TYPE_descriptor(td); + return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); +} + +asn_enc_rval_t +TimeTicks_encode_der(asn_TYPE_descriptor_t *td, + void *structure, int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + TimeTicks_1_inherit_TYPE_descriptor(td); + return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); +} + +asn_dec_rval_t +TimeTicks_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **structure, const char *opt_mname, const void *bufptr, size_t size) { + TimeTicks_1_inherit_TYPE_descriptor(td); + return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); +} + +asn_enc_rval_t +TimeTicks_encode_xer(asn_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + TimeTicks_1_inherit_TYPE_descriptor(td); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); +} + +static ber_tlv_tag_t asn_DEF_TimeTicks_tags_1[] = { + (ASN_TAG_CLASS_APPLICATION | (3 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_TimeTicks = { + "TimeTicks", + "TimeTicks", + TimeTicks_free, + TimeTicks_print, + TimeTicks_constraint, + TimeTicks_decode_ber, + TimeTicks_encode_der, + TimeTicks_decode_xer, + TimeTicks_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_TimeTicks_tags_1, + sizeof(asn_DEF_TimeTicks_tags_1) + /sizeof(asn_DEF_TimeTicks_tags_1[0]) - 1, /* 1 */ + asn_DEF_TimeTicks_tags_1, /* Same as above */ + sizeof(asn_DEF_TimeTicks_tags_1) + /sizeof(asn_DEF_TimeTicks_tags_1[0]), /* 2 */ + 0, /* No PER visible constraints */ + 0, 0, /* No members */ + 0 /* No specifics */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/TimeTicks.h b/projects/stargazer/plugins/other/snmp/asn1/TimeTicks.h new file mode 100644 index 00000000..ea92820f --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/TimeTicks.h @@ -0,0 +1,38 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1155-SMI" + * found in "RFC1155-SMI.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _TimeTicks_H_ +#define _TimeTicks_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* TimeTicks */ +typedef INTEGER_t TimeTicks_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_TimeTicks; +asn_struct_free_f TimeTicks_free; +asn_struct_print_f TimeTicks_print; +asn_constr_check_f TimeTicks_constraint; +ber_type_decoder_f TimeTicks_decode_ber; +der_type_encoder_f TimeTicks_encode_der; +xer_type_decoder_f TimeTicks_decode_xer; +xer_type_encoder_f TimeTicks_encode_xer; + +#ifdef __cplusplus +} +#endif + +#endif /* _TimeTicks_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/Trap-PDU.c b/projects/stargazer/plugins/other/snmp/asn1/Trap-PDU.c new file mode 100644 index 00000000..5e82ddf7 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/Trap-PDU.c @@ -0,0 +1,112 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "Trap-PDU.h" + +static asn_TYPE_member_t asn_MBR_Trap_PDU_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct Trap_PDU, enterprise), + (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), + 0, + &asn_DEF_OBJECT_IDENTIFIER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "enterprise" + }, + { ATF_NOFLAGS, 0, offsetof(struct Trap_PDU, agent_addr), + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_NetworkAddress, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "agent-addr" + }, + { ATF_NOFLAGS, 0, offsetof(struct Trap_PDU, generic_trap), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "generic-trap" + }, + { ATF_NOFLAGS, 0, offsetof(struct Trap_PDU, specific_trap), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_INTEGER, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "specific-trap" + }, + { ATF_NOFLAGS, 0, offsetof(struct Trap_PDU, time_stamp), + (ASN_TAG_CLASS_APPLICATION | (3 << 2)), + 0, + &asn_DEF_TimeTicks, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "time-stamp" + }, + { ATF_NOFLAGS, 0, offsetof(struct Trap_PDU, variable_bindings), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), + 0, + &asn_DEF_VarBindList, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "variable-bindings" + }, +}; +static ber_tlv_tag_t asn_DEF_Trap_PDU_tags_1[] = { + (ASN_TAG_CLASS_CONTEXT | (4 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_Trap_PDU_tag2el_1[] = { + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, 0, 1 }, /* generic-trap at 106 */ + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 3, -1, 0 }, /* specific-trap at 116 */ + { (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), 0, 0, 0 }, /* enterprise at 99 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 5, 0, 0 }, /* variable-bindings at 125 */ + { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 1, 0, 0 }, /* internet at 113 */ + { (ASN_TAG_CLASS_APPLICATION | (3 << 2)), 4, 0, 0 } /* time-stamp at 120 */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_Trap_PDU_specs_1 = { + sizeof(struct Trap_PDU), + offsetof(struct Trap_PDU, _asn_ctx), + asn_MAP_Trap_PDU_tag2el_1, + 6, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* Start extensions */ + -1 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_Trap_PDU = { + "Trap-PDU", + "Trap-PDU", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_Trap_PDU_tags_1, + sizeof(asn_DEF_Trap_PDU_tags_1) + /sizeof(asn_DEF_Trap_PDU_tags_1[0]) - 1, /* 1 */ + asn_DEF_Trap_PDU_tags_1, /* Same as above */ + sizeof(asn_DEF_Trap_PDU_tags_1) + /sizeof(asn_DEF_Trap_PDU_tags_1[0]), /* 2 */ + 0, /* No PER visible constraints */ + asn_MBR_Trap_PDU_1, + 6, /* Elements count */ + &asn_SPC_Trap_PDU_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/Trap-PDU.h b/projects/stargazer/plugins/other/snmp/asn1/Trap-PDU.h new file mode 100644 index 00000000..d8a89e11 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/Trap-PDU.h @@ -0,0 +1,57 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _Trap_PDU_H_ +#define _Trap_PDU_H_ + + +#include + +/* Including external dependencies */ +#include +#include "NetworkAddress.h" +#include +#include "TimeTicks.h" +#include "VarBindList.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum Trap_PDU__generic_trap { + Trap_PDU__generic_trap_coldStart = 0, + Trap_PDU__generic_trap_warmStart = 1, + Trap_PDU__generic_trap_linkDown = 2, + Trap_PDU__generic_trap_linkUp = 3, + Trap_PDU__generic_trap_authenticationFailure = 4, + Trap_PDU__generic_trap_egpNeighborLoss = 5, + Trap_PDU__generic_trap_enterpriseSpecific = 6 +} e_Trap_PDU__generic_trap; + +/* Trap-PDU */ +typedef struct Trap_PDU { + OBJECT_IDENTIFIER_t enterprise; + NetworkAddress_t agent_addr; + INTEGER_t generic_trap; + INTEGER_t specific_trap; + TimeTicks_t time_stamp; + VarBindList_t variable_bindings; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} Trap_PDU_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_Trap_PDU; + +#ifdef __cplusplus +} +#endif + +#endif /* _Trap_PDU_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/UdpEntry.c b/projects/stargazer/plugins/other/snmp/asn1/UdpEntry.c new file mode 100644 index 00000000..711bbadc --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/UdpEntry.c @@ -0,0 +1,96 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "UdpEntry.h" + +static int +memb_udpLocalPort_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + long value; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + value = *(const long *)sptr; + + if((value >= 0 && value <= 65535)) { + /* Constraint check succeeded */ + return 0; + } else { + _ASN_CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +static asn_TYPE_member_t asn_MBR_UdpEntry_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct UdpEntry, udpLocalAddress), + (ASN_TAG_CLASS_APPLICATION | (0 << 2)), + 0, + &asn_DEF_IpAddress, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "udpLocalAddress" + }, + { ATF_NOFLAGS, 0, offsetof(struct UdpEntry, udpLocalPort), + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + 0, + &asn_DEF_NativeInteger, + memb_udpLocalPort_constraint_1, + 0, /* PER is not compiled, use -gen-PER */ + 0, + "udpLocalPort" + }, +}; +static ber_tlv_tag_t asn_DEF_UdpEntry_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_UdpEntry_tag2el_1[] = { + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* udpLocalPort at 253 */ + { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 0, 0, 0 } /* udpLocalAddress at 251 */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_UdpEntry_specs_1 = { + sizeof(struct UdpEntry), + offsetof(struct UdpEntry, _asn_ctx), + asn_MAP_UdpEntry_tag2el_1, + 2, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* Start extensions */ + -1 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_UdpEntry = { + "UdpEntry", + "UdpEntry", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_UdpEntry_tags_1, + sizeof(asn_DEF_UdpEntry_tags_1) + /sizeof(asn_DEF_UdpEntry_tags_1[0]), /* 1 */ + asn_DEF_UdpEntry_tags_1, /* Same as above */ + sizeof(asn_DEF_UdpEntry_tags_1) + /sizeof(asn_DEF_UdpEntry_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_UdpEntry_1, + 2, /* Elements count */ + &asn_SPC_UdpEntry_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/UdpEntry.h b/projects/stargazer/plugins/other/snmp/asn1/UdpEntry.h new file mode 100644 index 00000000..e4a10264 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/UdpEntry.h @@ -0,0 +1,39 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1213-MIB" + * found in "RFC1213-MIB.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _UdpEntry_H_ +#define _UdpEntry_H_ + + +#include + +/* Including external dependencies */ +#include "IpAddress.h" +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* UdpEntry */ +typedef struct UdpEntry { + IpAddress_t udpLocalAddress; + long udpLocalPort; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} UdpEntry_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_UdpEntry; + +#ifdef __cplusplus +} +#endif + +#endif /* _UdpEntry_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/VarBind.c b/projects/stargazer/plugins/other/snmp/asn1/VarBind.c new file mode 100644 index 00000000..85a6f97f --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/VarBind.c @@ -0,0 +1,79 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "VarBind.h" + +static asn_TYPE_member_t asn_MBR_VarBind_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct VarBind, name), + (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), + 0, + &asn_DEF_ObjectName, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "name" + }, + { ATF_NOFLAGS, 0, offsetof(struct VarBind, value), + -1 /* Ambiguous tag (CHOICE?) */, + 0, + &asn_DEF_ObjectSyntax, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "value" + }, +}; +static ber_tlv_tag_t asn_DEF_VarBind_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_VarBind_tag2el_1[] = { + { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* number at 73 */ + { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 1, 0, 0 }, /* string at 76 */ + { (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)), 1, 0, 0 }, /* empty at 82 */ + { (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), 0, 0, 1 }, /* name at 133 */ + { (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), 1, -1, 0 }, /* object at 79 */ + { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 1, 0, 0 }, /* internet at 113 */ + { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 1, 0, 0 }, /* counter at 91 */ + { (ASN_TAG_CLASS_APPLICATION | (2 << 2)), 1, 0, 0 }, /* gauge at 94 */ + { (ASN_TAG_CLASS_APPLICATION | (3 << 2)), 1, 0, 0 }, /* ticks at 97 */ + { (ASN_TAG_CLASS_APPLICATION | (4 << 2)), 1, 0, 0 } /* arbitrary at 104 */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_VarBind_specs_1 = { + sizeof(struct VarBind), + offsetof(struct VarBind, _asn_ctx), + asn_MAP_VarBind_tag2el_1, + 10, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* Start extensions */ + -1 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_VarBind = { + "VarBind", + "VarBind", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_VarBind_tags_1, + sizeof(asn_DEF_VarBind_tags_1) + /sizeof(asn_DEF_VarBind_tags_1[0]), /* 1 */ + asn_DEF_VarBind_tags_1, /* Same as above */ + sizeof(asn_DEF_VarBind_tags_1) + /sizeof(asn_DEF_VarBind_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_VarBind_1, + 2, /* Elements count */ + &asn_SPC_VarBind_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/VarBind.h b/projects/stargazer/plugins/other/snmp/asn1/VarBind.h new file mode 100644 index 00000000..63ecad5f --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/VarBind.h @@ -0,0 +1,39 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _VarBind_H_ +#define _VarBind_H_ + + +#include + +/* Including external dependencies */ +#include "ObjectName.h" +#include "ObjectSyntax.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* VarBind */ +typedef struct VarBind { + ObjectName_t name; + ObjectSyntax_t value; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} VarBind_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_VarBind; + +#ifdef __cplusplus +} +#endif + +#endif /* _VarBind_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/VarBindList.c b/projects/stargazer/plugins/other/snmp/asn1/VarBindList.c new file mode 100644 index 00000000..15018ded --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/VarBindList.c @@ -0,0 +1,54 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#include + +#include "VarBindList.h" + +static asn_TYPE_member_t asn_MBR_VarBindList_1[] = { + { ATF_POINTER, 0, 0, + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), + 0, + &asn_DEF_VarBind, + 0, /* Defer constraints checking to the member type */ + 0, /* PER is not compiled, use -gen-PER */ + 0, + "" + }, +}; +static ber_tlv_tag_t asn_DEF_VarBindList_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_VarBindList_specs_1 = { + sizeof(struct VarBindList), + offsetof(struct VarBindList, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +asn_TYPE_descriptor_t asn_DEF_VarBindList = { + "VarBindList", + "VarBindList", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_VarBindList_tags_1, + sizeof(asn_DEF_VarBindList_tags_1) + /sizeof(asn_DEF_VarBindList_tags_1[0]), /* 1 */ + asn_DEF_VarBindList_tags_1, /* Same as above */ + sizeof(asn_DEF_VarBindList_tags_1) + /sizeof(asn_DEF_VarBindList_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_VarBindList_1, + 1, /* Single element */ + &asn_SPC_VarBindList_specs_1 /* Additional specs */ +}; + diff --git a/projects/stargazer/plugins/other/snmp/asn1/VarBindList.h b/projects/stargazer/plugins/other/snmp/asn1/VarBindList.h new file mode 100644 index 00000000..36ef1617 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/VarBindList.h @@ -0,0 +1,43 @@ +/* + * Generated by asn1c-0.9.21 (http://lionet.info/asn1c) + * From ASN.1 module "RFC1157-SNMP" + * found in "RFC1157-SNMP.asn1" + * `asn1c -fskeletons-copy` + */ + +#ifndef _VarBindList_H_ +#define _VarBindList_H_ + + +#include + +/* Including external dependencies */ +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Forward declarations */ +struct VarBind; + +/* VarBindList */ +typedef struct VarBindList { + A_SEQUENCE_OF(struct VarBind) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} VarBindList_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_VarBindList; + +#ifdef __cplusplus +} +#endif + +/* Referred external types */ +#include "VarBind.h" + +#endif /* _VarBindList_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/asn_SEQUENCE_OF.c b/projects/stargazer/plugins/other/snmp/asn1/asn_SEQUENCE_OF.c new file mode 100644 index 00000000..ec952fc9 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/asn_SEQUENCE_OF.c @@ -0,0 +1,41 @@ +/*- + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include + +typedef A_SEQUENCE_OF(void) asn_sequence; + +void +asn_sequence_del(void *asn_sequence_of_x, int number, int _do_free) { + asn_sequence *as = (asn_sequence *)asn_sequence_of_x; + + if(as) { + void *ptr; + int n; + + if(number < 0 || number >= as->count) + return; /* Nothing to delete */ + + if(_do_free && as->free) { + ptr = as->array[number]; + } else { + ptr = 0; + } + + /* + * Shift all elements to the left to hide the gap. + */ + --as->count; + for(n = number; n < as->count; n++) + as->array[n] = as->array[n+1]; + + /* + * Invoke the third-party function only when the state + * of the parent structure is consistent. + */ + if(ptr) as->free(ptr); + } +} + diff --git a/projects/stargazer/plugins/other/snmp/asn1/asn_SEQUENCE_OF.h b/projects/stargazer/plugins/other/snmp/asn1/asn_SEQUENCE_OF.h new file mode 100644 index 00000000..e678f034 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/asn_SEQUENCE_OF.h @@ -0,0 +1,52 @@ +/*- + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef ASN_SEQUENCE_OF_H +#define ASN_SEQUENCE_OF_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * SEQUENCE OF is the same as SET OF with a tiny difference: + * the delete operation preserves the initial order of elements + * and thus MAY operate in non-constant time. + */ +#define A_SEQUENCE_OF(type) A_SET_OF(type) + +#define ASN_SEQUENCE_ADD(headptr, ptr) \ + asn_sequence_add((headptr), (ptr)) + +/*********************************************** + * Implementation of the SEQUENCE OF structure. + */ + +#define asn_sequence_add asn_set_add +#define asn_sequence_empty asn_set_empty + +/* + * Delete the element from the set by its number (base 0). + * This is NOT a constant-time operation. + * The order of elements is preserved. + * If _do_free is given AND the (*free) is initialized, the element + * will be freed using the custom (*free) function as well. + */ +void asn_sequence_del(void *asn_sequence_of_x, int number, int _do_free); + +/* + * Cope with different conversions requirements to/from void in C and C++. + * This is mostly useful for support library. + */ +typedef A_SEQUENCE_OF(void) asn_anonymous_sequence_; +#define _A_SEQUENCE_FROM_VOID(ptr) ((asn_anonymous_sequence_ *)(ptr)) +#define _A_CSEQUENCE_FROM_VOID(ptr) ((const asn_anonymous_sequence_ *)(ptr)) + +#ifdef __cplusplus +} +#endif + +#endif /* ASN_SEQUENCE_OF_H */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/asn_SET_OF.c b/projects/stargazer/plugins/other/snmp/asn1/asn_SET_OF.c new file mode 100644 index 00000000..944f2cb8 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/asn_SET_OF.c @@ -0,0 +1,88 @@ +/*- + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include +#include + +/* + * Add another element into the set. + */ +int +asn_set_add(void *asn_set_of_x, void *ptr) { + asn_anonymous_set_ *as = _A_SET_FROM_VOID(asn_set_of_x); + + if(as == 0 || ptr == 0) { + errno = EINVAL; /* Invalid arguments */ + return -1; + } + + /* + * Make sure there's enough space to insert an element. + */ + if(as->count == as->size) { + int _newsize = as->size ? (as->size << 1) : 4; + void *_new_arr; + _new_arr = REALLOC(as->array, _newsize * sizeof(as->array[0])); + if(_new_arr) { + as->array = (void **)_new_arr; + as->size = _newsize; + } else { + /* ENOMEM */ + return -1; + } + } + + as->array[as->count++] = ptr; + + return 0; +} + +void +asn_set_del(void *asn_set_of_x, int number, int _do_free) { + asn_anonymous_set_ *as = _A_SET_FROM_VOID(asn_set_of_x); + + if(as) { + void *ptr; + if(number < 0 || number >= as->count) + return; + + if(_do_free && as->free) { + ptr = as->array[number]; + } else { + ptr = 0; + } + + as->array[number] = as->array[--as->count]; + + /* + * Invoke the third-party function only when the state + * of the parent structure is consistent. + */ + if(ptr) as->free(ptr); + } +} + +/* + * Free the contents of the set, do not free the set itself. + */ +void +asn_set_empty(void *asn_set_of_x) { + asn_anonymous_set_ *as = _A_SET_FROM_VOID(asn_set_of_x); + + if(as) { + if(as->array) { + if(as->free) { + while(as->count--) + as->free(as->array[as->count]); + } + FREEMEM(as->array); + as->array = 0; + } + as->count = 0; + as->size = 0; + } + +} + diff --git a/projects/stargazer/plugins/other/snmp/asn1/asn_SET_OF.h b/projects/stargazer/plugins/other/snmp/asn1/asn_SET_OF.h new file mode 100644 index 00000000..7edf14b5 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/asn_SET_OF.h @@ -0,0 +1,62 @@ +/*- + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef ASN_SET_OF_H +#define ASN_SET_OF_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define A_SET_OF(type) \ + struct { \ + type **array; \ + int count; /* Meaningful size */ \ + int size; /* Allocated size */ \ + void (*free)(type *); \ + } + +#define ASN_SET_ADD(headptr, ptr) \ + asn_set_add((headptr), (ptr)) + +/******************************************* + * Implementation of the SET OF structure. + */ + +/* + * Add another structure into the set by its pointer. + * RETURN VALUES: + * 0 for success and -1/errno for failure. + */ +int asn_set_add(void *asn_set_of_x, void *ptr); + +/* + * Delete the element from the set by its number (base 0). + * This is a constant-time operation. The order of elements before the + * deleted ones is guaranteed, the order of elements after the deleted + * one is NOT guaranteed. + * If _do_free is given AND the (*free) is initialized, the element + * will be freed using the custom (*free) function as well. + */ +void asn_set_del(void *asn_set_of_x, int number, int _do_free); + +/* + * Empty the contents of the set. Will free the elements, if (*free) is given. + * Will NOT free the set itself. + */ +void asn_set_empty(void *asn_set_of_x); + +/* + * Cope with different conversions requirements to/from void in C and C++. + * This is mostly useful for support library. + */ +typedef A_SET_OF(void) asn_anonymous_set_; +#define _A_SET_FROM_VOID(ptr) ((asn_anonymous_set_ *)(ptr)) +#define _A_CSET_FROM_VOID(ptr) ((const asn_anonymous_set_ *)(ptr)) + +#ifdef __cplusplus +} +#endif + +#endif /* ASN_SET_OF_H */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/asn_application.h b/projects/stargazer/plugins/other/snmp/asn1/asn_application.h new file mode 100644 index 00000000..f40cd86a --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/asn_application.h @@ -0,0 +1,47 @@ +/*- + * Copyright (c) 2004, 2006 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +/* + * Application-level ASN.1 callbacks. + */ +#ifndef _ASN_APPLICATION_H_ +#define _ASN_APPLICATION_H_ + +#include "asn_system.h" /* for platform-dependent types */ +#include "asn_codecs.h" /* for ASN.1 codecs specifics */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Generic type of an application-defined callback to return various + * types of data to the application. + * EXPECTED RETURN VALUES: + * -1: Failed to consume bytes. Abort the mission. + * Non-negative return values indicate success, and ignored. + */ +typedef int (asn_app_consume_bytes_f)(const void *buffer, size_t size, + void *application_specific_key); + +/* + * A callback of this type is called whenever constraint validation fails + * on some ASN.1 type. See "constraints.h" for more details on constraint + * validation. + * This callback specifies a descriptor of the ASN.1 type which failed + * the constraint check, as well as human readable message on what + * particular constraint has failed. + */ +typedef void (asn_app_constraint_failed_f)(void *application_specific_key, + struct asn_TYPE_descriptor_s *type_descriptor_which_failed, + const void *structure_which_failed_ptr, + const char *error_message_format, ...) GCC_PRINTFLIKE(4, 5); + +#ifdef __cplusplus +} +#endif + +#include "constr_TYPE.h" /* for asn_TYPE_descriptor_t */ + +#endif /* _ASN_APPLICATION_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/asn_codecs.h b/projects/stargazer/plugins/other/snmp/asn1/asn_codecs.h new file mode 100644 index 00000000..4a251d94 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/asn_codecs.h @@ -0,0 +1,109 @@ +/*- + * Copyright (c) 2003, 2004, 2005 Lev Walkin . + * All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _ASN_CODECS_H_ +#define _ASN_CODECS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +struct asn_TYPE_descriptor_s; /* Forward declaration */ + +/* + * This structure defines a set of parameters that may be passed + * to every ASN.1 encoder or decoder function. + * WARNING: if max_stack_size member is set, and you are calling the + * function pointers of the asn_TYPE_descriptor_t directly, + * this structure must be ALLOCATED ON THE STACK! + * If you can't always satisfy this requirement, use ber_decode(), + * xer_decode() and uper_decode() functions instead. + */ +typedef struct asn_codec_ctx_s { + /* + * Limit the decoder routines to use no (much) more stack than a given + * number of bytes. Most of decoders are stack-based, and this + * would protect against stack overflows if the number of nested + * encodings is high. + * The OCTET STRING, BIT STRING and ANY BER decoders are heap-based, + * and are safe from this kind of overflow. + * A value from getrlimit(RLIMIT_STACK) may be used to initialize + * this variable. Be careful in multithreaded environments, as the + * stack size is rather limited. + */ + size_t max_stack_size; /* 0 disables stack bounds checking */ +} asn_codec_ctx_t; + +/* + * Type of the return value of the encoding functions (der_encode, xer_encode). + */ +typedef struct asn_enc_rval_s { + /* + * Number of bytes encoded. + * -1 indicates failure to encode the structure. + * In this case, the members below this one are meaningful. + */ + ssize_t encoded; + + /* + * Members meaningful when (encoded == -1), for post mortem analysis. + */ + + /* Type which cannot be encoded */ + struct asn_TYPE_descriptor_s *failed_type; + + /* Pointer to the structure of that type */ + void *structure_ptr; +} asn_enc_rval_t; +#define _ASN_ENCODE_FAILED do { \ + asn_enc_rval_t tmp_error; \ + tmp_error.encoded = -1; \ + tmp_error.failed_type = td; \ + tmp_error.structure_ptr = sptr; \ + ASN_DEBUG("Failed to encode element %s", td->name); \ + return tmp_error; \ +} while(0) +#define _ASN_ENCODED_OK(rval) do { \ + rval.structure_ptr = 0; \ + rval.failed_type = 0; \ + return rval; \ +} while(0) + +/* + * Type of the return value of the decoding functions (ber_decode, xer_decode) + * + * Please note that the number of consumed bytes is ALWAYS meaningful, + * even if code==RC_FAIL. This is to indicate the number of successfully + * decoded bytes, hence providing a possibility to fail with more diagnostics + * (i.e., print the offending remainder of the buffer). + */ +enum asn_dec_rval_code_e { + RC_OK, /* Decoded successfully */ + RC_WMORE, /* More data expected, call again */ + RC_FAIL /* Failure to decode data */ +}; +typedef struct asn_dec_rval_s { + enum asn_dec_rval_code_e code; /* Result code */ + size_t consumed; /* Number of bytes consumed */ +} asn_dec_rval_t; +#define _ASN_DECODE_FAILED do { \ + asn_dec_rval_t tmp_error; \ + tmp_error.code = RC_FAIL; \ + tmp_error.consumed = 0; \ + ASN_DEBUG("Failed to decode element %s", td->name); \ + return tmp_error; \ +} while(0) +#define _ASN_DECODE_STARVED do { \ + asn_dec_rval_t tmp_error; \ + tmp_error.code = RC_WMORE; \ + tmp_error.consumed = 0; \ + return tmp_error; \ +} while(0) + +#ifdef __cplusplus +} +#endif + +#endif /* _ASN_CODECS_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/asn_codecs_prim.c b/projects/stargazer/plugins/other/snmp/asn1/asn_codecs_prim.c new file mode 100644 index 00000000..4e5c6393 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/asn_codecs_prim.c @@ -0,0 +1,295 @@ +/*- + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include +#include + +/* + * Decode an always-primitive type. + */ +asn_dec_rval_t +ber_decode_primitive(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *td, + void **sptr, const void *buf_ptr, size_t size, int tag_mode) { + ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)*sptr; + asn_dec_rval_t rval; + ber_tlv_len_t length; + + /* + * If the structure is not there, allocate it. + */ + if(st == NULL) { + st = (ASN__PRIMITIVE_TYPE_t *)CALLOC(1, sizeof(*st)); + if(st == NULL) _ASN_DECODE_FAILED; + *sptr = (void *)st; + } + + ASN_DEBUG("Decoding %s as plain primitive (tm=%d)", + td->name, tag_mode); + + /* + * Check tags and extract value length. + */ + rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size, + tag_mode, 0, &length, 0); + if(rval.code != RC_OK) + return rval; + + ASN_DEBUG("%s length is %d bytes", td->name, (int)length); + + /* + * Make sure we have this length. + */ + buf_ptr = ((const char *)buf_ptr) + rval.consumed; + size -= rval.consumed; + if(length > (ber_tlv_len_t)size) { + rval.code = RC_WMORE; + rval.consumed = 0; + return rval; + } + + st->size = (int)length; + /* The following better be optimized away. */ + if(sizeof(st->size) != sizeof(length) + && (ber_tlv_len_t)st->size != length) { + st->size = 0; + _ASN_DECODE_FAILED; + } + + st->buf = (uint8_t *)MALLOC(length + 1); + if(!st->buf) { + st->size = 0; + _ASN_DECODE_FAILED; + } + + memcpy(st->buf, buf_ptr, length); + st->buf[length] = '\0'; /* Just in case */ + + rval.code = RC_OK; + rval.consumed += length; + + ASN_DEBUG("Took %ld/%ld bytes to encode %s", + (long)rval.consumed, + (long)length, td->name); + + return rval; +} + +/* + * Encode an always-primitive type using DER. + */ +asn_enc_rval_t +der_encode_primitive(asn_TYPE_descriptor_t *td, void *sptr, + int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + asn_enc_rval_t erval; + ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)sptr; + + ASN_DEBUG("%s %s as a primitive type (tm=%d)", + cb?"Encoding":"Estimating", td->name, tag_mode); + + erval.encoded = der_write_tags(td, st->size, tag_mode, 0, tag, + cb, app_key); + ASN_DEBUG("%s wrote tags %d", td->name, (int)erval.encoded); + if(erval.encoded == -1) { + erval.failed_type = td; + erval.structure_ptr = sptr; + return erval; + } + + if(cb && st->buf) { + if(cb(st->buf, st->size, app_key) < 0) { + erval.encoded = -1; + erval.failed_type = td; + erval.structure_ptr = sptr; + return erval; + } + } else { + assert(st->buf || st->size == 0); + } + + erval.encoded += st->size; + _ASN_ENCODED_OK(erval); +} + +void +ASN__PRIMITIVE_TYPE_free(asn_TYPE_descriptor_t *td, void *sptr, + int contents_only) { + ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)sptr; + + if(!td || !sptr) + return; + + ASN_DEBUG("Freeing %s as a primitive type", td->name); + + if(st->buf) + FREEMEM(st->buf); + + if(!contents_only) + FREEMEM(st); +} + + +/* + * Local internal type passed around as an argument. + */ +struct xdp_arg_s { + asn_TYPE_descriptor_t *type_descriptor; + void *struct_key; + xer_primitive_body_decoder_f *prim_body_decoder; + int decoded_something; + int want_more; +}; + + +static int +xer_decode__unexpected_tag(void *key, const void *chunk_buf, size_t chunk_size) { + struct xdp_arg_s *arg = (struct xdp_arg_s *)key; + enum xer_pbd_rval bret; + + if(arg->decoded_something) { + if(xer_is_whitespace(chunk_buf, chunk_size)) + return 0; /* Skip it. */ + /* + * Decoding was done once already. Prohibit doing it again. + */ + return -1; + } + + bret = arg->prim_body_decoder(arg->type_descriptor, + arg->struct_key, chunk_buf, chunk_size); + switch(bret) { + case XPBD_SYSTEM_FAILURE: + case XPBD_DECODER_LIMIT: + case XPBD_BROKEN_ENCODING: + break; + case XPBD_BODY_CONSUMED: + /* Tag decoded successfully */ + arg->decoded_something = 1; + /* Fall through */ + case XPBD_NOT_BODY_IGNORE: /* Safe to proceed further */ + return 0; + } + + return -1; +} + +static ssize_t +xer_decode__body(void *key, const void *chunk_buf, size_t chunk_size, int have_more) { + struct xdp_arg_s *arg = (struct xdp_arg_s *)key; + enum xer_pbd_rval bret; + + if(arg->decoded_something) { + if(xer_is_whitespace(chunk_buf, chunk_size)) + return chunk_size; + /* + * Decoding was done once already. Prohibit doing it again. + */ + return -1; + } + + if(!have_more) { + /* + * If we've received something like "1", we can't really + * tell whether it is really `1` or `123`, until we know + * that there is no more data coming. + * The have_more argument will be set to 1 once something + * like this is available to the caller of this callback: + * "1want_more = 1; + return -1; + } + + bret = arg->prim_body_decoder(arg->type_descriptor, + arg->struct_key, chunk_buf, chunk_size); + switch(bret) { + case XPBD_SYSTEM_FAILURE: + case XPBD_DECODER_LIMIT: + case XPBD_BROKEN_ENCODING: + break; + case XPBD_BODY_CONSUMED: + /* Tag decoded successfully */ + arg->decoded_something = 1; + /* Fall through */ + case XPBD_NOT_BODY_IGNORE: /* Safe to proceed further */ + return chunk_size; + } + + return -1; +} + + +asn_dec_rval_t +xer_decode_primitive(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *td, + void **sptr, + size_t struct_size, + const char *opt_mname, + const void *buf_ptr, size_t size, + xer_primitive_body_decoder_f *prim_body_decoder +) { + const char *xml_tag = opt_mname ? opt_mname : td->xml_tag; + asn_struct_ctx_t s_ctx; + struct xdp_arg_s s_arg; + asn_dec_rval_t rc; + + /* + * Create the structure if does not exist. + */ + if(!*sptr) { + *sptr = CALLOC(1, struct_size); + if(!*sptr) _ASN_DECODE_FAILED; + } + + memset(&s_ctx, 0, sizeof(s_ctx)); + s_arg.type_descriptor = td; + s_arg.struct_key = *sptr; + s_arg.prim_body_decoder = prim_body_decoder; + s_arg.decoded_something = 0; + s_arg.want_more = 0; + + rc = xer_decode_general(opt_codec_ctx, &s_ctx, &s_arg, + xml_tag, buf_ptr, size, + xer_decode__unexpected_tag, xer_decode__body); + switch(rc.code) { + case RC_OK: + if(!s_arg.decoded_something) { + char ch; + ASN_DEBUG("Primitive body is not recognized, " + "supplying empty one"); + /* + * Decoding opportunity has come and gone. + * Where's the result? + * Try to feed with empty body, see if it eats it. + */ + if(prim_body_decoder(s_arg.type_descriptor, + s_arg.struct_key, &ch, 0) + != XPBD_BODY_CONSUMED) { + /* + * This decoder does not like empty stuff. + */ + _ASN_DECODE_FAILED; + } + } + break; + case RC_WMORE: + /* + * Redo the whole thing later. + * We don't have a context to save intermediate parsing state. + */ + rc.consumed = 0; + break; + case RC_FAIL: + rc.consumed = 0; + if(s_arg.want_more) + rc.code = RC_WMORE; + else + _ASN_DECODE_FAILED; + break; + } + return rc; +} + diff --git a/projects/stargazer/plugins/other/snmp/asn1/asn_codecs_prim.h b/projects/stargazer/plugins/other/snmp/asn1/asn_codecs_prim.h new file mode 100644 index 00000000..0f683fdd --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/asn_codecs_prim.h @@ -0,0 +1,53 @@ +/*- + * Copyright (c) 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef ASN_CODECS_PRIM_H +#define ASN_CODECS_PRIM_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct ASN__PRIMITIVE_TYPE_s { + uint8_t *buf; /* Buffer with consecutive primitive encoding bytes */ + int size; /* Size of the buffer */ +} ASN__PRIMITIVE_TYPE_t; /* Do not use this type directly! */ + +asn_struct_free_f ASN__PRIMITIVE_TYPE_free; +ber_type_decoder_f ber_decode_primitive; +der_type_encoder_f der_encode_primitive; + +/* + * A callback specification for the xer_decode_primitive() function below. + */ +enum xer_pbd_rval { + XPBD_SYSTEM_FAILURE, /* System failure (memory shortage, etc) */ + XPBD_DECODER_LIMIT, /* Hit some decoder limitation or deficiency */ + XPBD_BROKEN_ENCODING, /* Encoding of a primitive body is broken */ + XPBD_NOT_BODY_IGNORE, /* Not a body format, but safe to ignore */ + XPBD_BODY_CONSUMED /* Body is recognized and consumed */ +}; +typedef enum xer_pbd_rval (xer_primitive_body_decoder_f) + (asn_TYPE_descriptor_t *td, void *struct_ptr, + const void *chunk_buf, size_t chunk_size); + +/* + * Specific function to decode simple primitive types. + * Also see xer_decode_general() in xer_decoder.h + */ +asn_dec_rval_t xer_decode_primitive(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *type_descriptor, + void **struct_ptr, size_t struct_size, + const char *opt_mname, + const void *buf_ptr, size_t size, + xer_primitive_body_decoder_f *prim_body_decoder +); + +#ifdef __cplusplus +} +#endif + +#endif /* ASN_CODECS_PRIM_H */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/asn_internal.h b/projects/stargazer/plugins/other/snmp/asn1/asn_internal.h new file mode 100644 index 00000000..67f055a6 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/asn_internal.h @@ -0,0 +1,111 @@ +/*- + * Copyright (c) 2003, 2004, 2005 Lev Walkin . + * All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +/* + * Declarations internally useful for the ASN.1 support code. + */ +#ifndef _ASN_INTERNAL_H_ +#define _ASN_INTERNAL_H_ + +#include "asn_application.h" /* Application-visible API */ + +#ifndef __NO_ASSERT_H__ /* Include assert.h only for internal use. */ +#include /* for assert() macro */ +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* Environment version might be used to avoid running with the old library */ +#define ASN1C_ENVIRONMENT_VERSION 920 /* Compile-time version */ +int get_asn1c_environment_version(void); /* Run-time version */ + +#define CALLOC(nmemb, size) calloc(nmemb, size) +#define MALLOC(size) malloc(size) +#define REALLOC(oldptr, size) realloc(oldptr, size) +#define FREEMEM(ptr) free(ptr) + +/* + * A macro for debugging the ASN.1 internals. + * You may enable or override it. + */ +#ifndef ASN_DEBUG /* If debugging code is not defined elsewhere... */ +#if EMIT_ASN_DEBUG == 1 /* And it was asked to emit this code... */ +#ifdef __GNUC__ +#define ASN_DEBUG(fmt, args...) do { \ + fprintf(stderr, fmt, ##args); \ + fprintf(stderr, " (%s:%d)\n", \ + __FILE__, __LINE__); \ + } while(0) +#else /* !__GNUC__ */ +void ASN_DEBUG_f(const char *fmt, ...); +#define ASN_DEBUG ASN_DEBUG_f +#endif /* __GNUC__ */ +#else /* EMIT_ASN_DEBUG != 1 */ +static inline void ASN_DEBUG(const char *fmt, ...) { (void)fmt; } +#endif /* EMIT_ASN_DEBUG */ +#endif /* ASN_DEBUG */ + +/* + * Invoke the application-supplied callback and fail, if something is wrong. + */ +#define __ASN_E_cbc(buf, size) (cb((buf), (size), app_key) < 0) +#define _ASN_E_CALLBACK(foo) do { \ + if(foo) goto cb_failed; \ + } while(0) +#define _ASN_CALLBACK(buf, size) \ + _ASN_E_CALLBACK(__ASN_E_cbc(buf, size)) +#define _ASN_CALLBACK2(buf1, size1, buf2, size2) \ + _ASN_E_CALLBACK(__ASN_E_cbc(buf1, size1) || __ASN_E_cbc(buf2, size2)) +#define _ASN_CALLBACK3(buf1, size1, buf2, size2, buf3, size3) \ + _ASN_E_CALLBACK(__ASN_E_cbc(buf1, size1) \ + || __ASN_E_cbc(buf2, size2) \ + || __ASN_E_cbc(buf3, size3)) + +#define _i_ASN_TEXT_INDENT(nl, level) do { \ + int __level = (level); \ + int __nl = ((nl) != 0); \ + int __i; \ + if(__nl) _ASN_CALLBACK("\n", 1); \ + for(__i = 0; __i < __level; __i++) \ + _ASN_CALLBACK(" ", 4); \ + er.encoded += __nl + 4 * __level; \ +} while(0) + +#define _i_INDENT(nl) do { \ + int __i; \ + if((nl) && cb("\n", 1, app_key) < 0) return -1; \ + for(__i = 0; __i < ilevel; __i++) \ + if(cb(" ", 4, app_key) < 0) return -1; \ +} while(0) + +/* + * Check stack against overflow, if limit is set. + */ +#define _ASN_DEFAULT_STACK_MAX (30000) +static inline int +_ASN_STACK_OVERFLOW_CHECK(asn_codec_ctx_t *ctx) { + if(ctx && ctx->max_stack_size) { + + /* ctx MUST be allocated on the stack */ + ptrdiff_t usedstack = ((char *)ctx - (char *)&ctx); + if(usedstack > 0) usedstack = -usedstack; /* grows up! */ + + /* double negative required to avoid int wrap-around */ + if(usedstack < -(ptrdiff_t)ctx->max_stack_size) { + ASN_DEBUG("Stack limit %ld reached", + (long)ctx->max_stack_size); + return -1; + } + } + return 0; +} + +#ifdef __cplusplus +} +#endif + +#endif /* _ASN_INTERNAL_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/asn_system.h b/projects/stargazer/plugins/other/snmp/asn1/asn_system.h new file mode 100644 index 00000000..d7ebdaa4 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/asn_system.h @@ -0,0 +1,104 @@ +/*- + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +/* + * Miscellaneous system-dependent types. + */ +#ifndef _ASN_SYSTEM_H_ +#define _ASN_SYSTEM_H_ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include /* For snprintf(3) */ +#include /* For *alloc(3) */ +#include /* For memcpy(3) */ +#include /* For size_t */ +#include /* For va_start */ +#include /* for offsetof and ptrdiff_t */ + +#ifdef WIN32 + +#include +#include +#define snprintf _snprintf +#define vsnprintf _vsnprintf + +#ifdef _MSC_VER /* MSVS.Net */ +#ifndef __cplusplus +#define inline __inline +#endif +#define ssize_t SSIZE_T +typedef char int8_t; +typedef short int16_t; +typedef int int32_t; +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +#define WIN32_LEAN_AND_MEAN +#include +#include +#define isnan _isnan +#define finite _finite +#define copysign _copysign +#define ilogb _logb +#endif /* _MSC_VER */ + +#else /* !WIN32 */ + +#if defined(__vxworks) +#include +#else /* !defined(__vxworks) */ + +#include /* C99 specifies this file */ +/* + * 1. Earlier FreeBSD version didn't have , + * but was present. + * 2. Sun Solaris requires for alloca(3), + * but does not have . + */ +#if (!defined(__FreeBSD__) || !defined(_SYS_INTTYPES_H_)) +#if defined(sun) +#include /* For alloca(3) */ +#include /* for finite(3) */ +#elif defined(__hpux) +#ifdef __GNUC__ +#include /* For alloca(3) */ +#else /* !__GNUC__ */ +#define inline +#endif /* __GNUC__ */ +#else +#include /* SUSv2+ and C99 specify this file, for uintXX_t */ +#endif /* defined(sun) */ +#endif + +#endif /* defined(__vxworks) */ + +#endif /* WIN32 */ + +#if __GNUC__ >= 3 +#ifndef GCC_PRINTFLIKE +#define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var))) +#endif +#else +#ifndef GCC_PRINTFLIKE +#define GCC_PRINTFLIKE(fmt,var) /* nothing */ +#endif +#endif + +#ifndef offsetof /* If not defined by */ +#define offsetof(s, m) ((ptrdiff_t)&(((s *)0)->m) - (ptrdiff_t)((s *)0)) +#endif /* offsetof */ + +#ifndef MIN /* Suitable for comparing primitive types (integers) */ +#if defined(__GNUC__) +#define MIN(a,b) ({ __typeof a _a = a; __typeof b _b = b; \ + ((_a)<(_b)?(_a):(_b)); }) +#else /* !__GNUC__ */ +#define MIN(a,b) ((a)<(b)?(a):(b)) /* Unsafe variant */ +#endif /* __GNUC__ */ +#endif /* MIN */ + +#endif /* _ASN_SYSTEM_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/ber_decoder.c b/projects/stargazer/plugins/other/snmp/asn1/ber_decoder.c new file mode 100644 index 00000000..601f66c0 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/ber_decoder.c @@ -0,0 +1,283 @@ +/*- + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include + +#undef ADVANCE +#define ADVANCE(num_bytes) do { \ + size_t num = num_bytes; \ + ptr = ((const char *)ptr) + num; \ + size -= num; \ + consumed_myself += num; \ + } while(0) +#undef RETURN +#define RETURN(_code) do { \ + asn_dec_rval_t rval; \ + rval.code = _code; \ + if(opt_ctx) opt_ctx->step = step; /* Save context */ \ + if(_code == RC_OK || opt_ctx) \ + rval.consumed = consumed_myself; \ + else \ + rval.consumed = 0; /* Context-free */ \ + return rval; \ + } while(0) + +/* + * The BER decoder of any type. + */ +asn_dec_rval_t +ber_decode(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *type_descriptor, + void **struct_ptr, const void *ptr, size_t size) { + asn_codec_ctx_t s_codec_ctx; + + /* + * Stack checker requires that the codec context + * must be allocated on the stack. + */ + if(opt_codec_ctx) { + if(opt_codec_ctx->max_stack_size) { + s_codec_ctx = *opt_codec_ctx; + opt_codec_ctx = &s_codec_ctx; + } + } else { + /* If context is not given, be security-conscious anyway */ + memset(&s_codec_ctx, 0, sizeof(s_codec_ctx)); + s_codec_ctx.max_stack_size = _ASN_DEFAULT_STACK_MAX; + opt_codec_ctx = &s_codec_ctx; + } + + /* + * Invoke type-specific decoder. + */ + return type_descriptor->ber_decoder(opt_codec_ctx, type_descriptor, + struct_ptr, /* Pointer to the destination structure */ + ptr, size, /* Buffer and its size */ + 0 /* Default tag mode is 0 */ + ); +} + +/* + * Check the set of >> tags matches the definition. + */ +asn_dec_rval_t +ber_check_tags(asn_codec_ctx_t *opt_codec_ctx, + asn_TYPE_descriptor_t *td, asn_struct_ctx_t *opt_ctx, + const void *ptr, size_t size, int tag_mode, int last_tag_form, + ber_tlv_len_t *last_length, int *opt_tlv_form) { + ssize_t consumed_myself = 0; + ssize_t tag_len; + ssize_t len_len; + ber_tlv_tag_t tlv_tag; + ber_tlv_len_t tlv_len; + ber_tlv_len_t limit_len = -1; + int expect_00_terminators = 0; + int tlv_constr = -1; /* If CHOICE, opt_tlv_form is not given */ + int step = opt_ctx ? opt_ctx->step : 0; /* Where we left previously */ + int tagno; + + /* + * Make sure we didn't exceed the maximum stack size. + */ + if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx)) + RETURN(RC_FAIL); + + /* + * So what does all this implicit skip stuff mean? + * Imagine two types, + * A ::= [5] IMPLICIT T + * B ::= [2] EXPLICIT T + * Where T is defined as + * T ::= [4] IMPLICIT SEQUENCE { ... } + * + * Let's say, we are starting to decode type A, given the + * following TLV stream: <5> <0>. What does this mean? + * It means that the type A contains type T which is, + * in turn, empty. + * Remember though, that we are still in A. We cannot + * just pass control to the type T decoder. Why? Because + * the type T decoder expects <4> <0>, not <5> <0>. + * So, we must make sure we are going to receive <5> while + * still in A, then pass control to the T decoder, indicating + * that the tag <4> was implicitly skipped. The decoder of T + * hence will be prepared to treat <4> as valid tag, and decode + * it appropriately. + */ + + tagno = step /* Continuing where left previously */ + + (tag_mode==1?-1:0) + ; + ASN_DEBUG("ber_check_tags(%s, size=%ld, tm=%d, step=%d, tagno=%d)", + td->name, (long)size, tag_mode, step, tagno); + /* assert(td->tags_count >= 1) May not be the case for CHOICE or ANY */ + + if(tag_mode == 0 && tagno == td->tags_count) { + /* + * This must be the _untagged_ ANY type, + * which outermost tag isn't known in advance. + * Fetch the tag and length separately. + */ + tag_len = ber_fetch_tag(ptr, size, &tlv_tag); + switch(tag_len) { + case -1: RETURN(RC_FAIL); + case 0: RETURN(RC_WMORE); + } + tlv_constr = BER_TLV_CONSTRUCTED(ptr); + len_len = ber_fetch_length(tlv_constr, + (const char *)ptr + tag_len, size - tag_len, &tlv_len); + switch(len_len) { + case -1: RETURN(RC_FAIL); + case 0: RETURN(RC_WMORE); + } + ASN_DEBUG("Advancing %ld in ANY case", + (long)(tag_len + len_len)); + ADVANCE(tag_len + len_len); + } else { + assert(tagno < td->tags_count); /* At least one loop */ + } + for((void)tagno; tagno < td->tags_count; tagno++, step++) { + + /* + * Fetch and process T from TLV. + */ + tag_len = ber_fetch_tag(ptr, size, &tlv_tag); + ASN_DEBUG("Fetching tag from {%p,%ld}: " + "len %ld, step %d, tagno %d got %s", + ptr, (long)size, + (long)tag_len, step, tagno, + ber_tlv_tag_string(tlv_tag)); + switch(tag_len) { + case -1: RETURN(RC_FAIL); + case 0: RETURN(RC_WMORE); + } + + tlv_constr = BER_TLV_CONSTRUCTED(ptr); + + /* + * If {I}, don't check anything. + * If {I,B,C}, check B and C unless we're at I. + */ + if(tag_mode != 0 && step == 0) { + /* + * We don't expect tag to match here. + * It's just because we don't know how the tag + * is supposed to look like. + */ + } else { + assert(tagno >= 0); /* Guaranteed by the code above */ + if(tlv_tag != td->tags[tagno]) { + /* + * Unexpected tag. Too bad. + */ + ASN_DEBUG("Expected: %s, " + "expectation failed (tn=%d, tm=%d)", + ber_tlv_tag_string(td->tags[tagno]), + tagno, tag_mode + ); + RETURN(RC_FAIL); + } + } + + /* + * Attention: if there are more tags expected, + * ensure that the current tag is presented + * in constructed form (it contains other tags!). + * If this one is the last one, check that the tag form + * matches the one given in descriptor. + */ + if(tagno < (td->tags_count - 1)) { + if(tlv_constr == 0) { + ASN_DEBUG("tlv_constr = %d, expfail", + tlv_constr); + RETURN(RC_FAIL); + } + } else { + if(last_tag_form != tlv_constr + && last_tag_form != -1) { + ASN_DEBUG("last_tag_form %d != %d", + last_tag_form, tlv_constr); + RETURN(RC_FAIL); + } + } + + /* + * Fetch and process L from TLV. + */ + len_len = ber_fetch_length(tlv_constr, + (const char *)ptr + tag_len, size - tag_len, &tlv_len); + ASN_DEBUG("Fetchinig len = %ld", (long)len_len); + switch(len_len) { + case -1: RETURN(RC_FAIL); + case 0: RETURN(RC_WMORE); + } + + /* + * FIXME + * As of today, the chain of tags + * must either contain several indefinite length TLVs, + * or several definite length ones. + * No mixing is allowed. + */ + if(tlv_len == -1) { + /* + * Indefinite length. + */ + if(limit_len == -1) { + expect_00_terminators++; + } else { + ASN_DEBUG("Unexpected indefinite length " + "in a chain of definite lengths"); + RETURN(RC_FAIL); + } + ADVANCE(tag_len + len_len); + continue; + } else { + if(expect_00_terminators) { + ASN_DEBUG("Unexpected definite length " + "in a chain of indefinite lengths"); + RETURN(RC_FAIL); + } + } + + /* + * Check that multiple TLVs specify ever decreasing length, + * which is consistent. + */ + if(limit_len == -1) { + limit_len = tlv_len + tag_len + len_len; + if(limit_len < 0) { + /* Too great tlv_len value? */ + RETURN(RC_FAIL); + } + } else if(limit_len != tlv_len + tag_len + len_len) { + /* + * Inner TLV specifies length which is inconsistent + * with the outer TLV's length value. + */ + ASN_DEBUG("Outer TLV is %ld and inner is %ld", + (long)limit_len, (long)tlv_len); + RETURN(RC_FAIL); + } + + ADVANCE(tag_len + len_len); + + limit_len -= (tag_len + len_len); + if((ssize_t)size > limit_len) { + /* + * Make sure that we won't consume more bytes + * from the parent frame than the inferred limit. + */ + size = limit_len; + } + } + + if(opt_tlv_form) + *opt_tlv_form = tlv_constr; + if(expect_00_terminators) + *last_length = -expect_00_terminators; + else + *last_length = tlv_len; + + RETURN(RC_OK); +} diff --git a/projects/stargazer/plugins/other/snmp/asn1/ber_decoder.h b/projects/stargazer/plugins/other/snmp/asn1/ber_decoder.h new file mode 100644 index 00000000..768133b6 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/ber_decoder.h @@ -0,0 +1,63 @@ +/*- + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _BER_DECODER_H_ +#define _BER_DECODER_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +struct asn_TYPE_descriptor_s; /* Forward declaration */ +struct asn_codec_ctx_s; /* Forward declaration */ + +/* + * The BER decoder of any type. + * This function may be invoked directly from the application. + */ +asn_dec_rval_t ber_decode(struct asn_codec_ctx_s *opt_codec_ctx, + struct asn_TYPE_descriptor_s *type_descriptor, + void **struct_ptr, /* Pointer to a target structure's pointer */ + const void *buffer, /* Data to be decoded */ + size_t size /* Size of that buffer */ + ); + +/* + * Type of generic function which decodes the byte stream into the structure. + */ +typedef asn_dec_rval_t (ber_type_decoder_f)( + struct asn_codec_ctx_s *opt_codec_ctx, + struct asn_TYPE_descriptor_s *type_descriptor, + void **struct_ptr, const void *buf_ptr, size_t size, + int tag_mode); + +/******************************* + * INTERNALLY USEFUL FUNCTIONS * + *******************************/ + +/* + * Check that all tags correspond to the type definition (as given in head). + * On return, last_length would contain either a non-negative length of the + * value part of the last TLV, or the negative number of expected + * "end of content" sequences. The number may only be negative if the + * head->last_tag_form is non-zero. + */ +asn_dec_rval_t ber_check_tags( + struct asn_codec_ctx_s *opt_codec_ctx, /* codec options */ + struct asn_TYPE_descriptor_s *type_descriptor, + asn_struct_ctx_t *opt_ctx, /* saved decoding context */ + const void *ptr, size_t size, + int tag_mode, /* {-1,0,1}: IMPLICIT, no, EXPLICIT */ + int last_tag_form, /* {-1,0:1}: any, primitive, constr */ + ber_tlv_len_t *last_length, + int *opt_tlv_form /* optional tag form */ + ); + +#ifdef __cplusplus +} +#endif + +#endif /* _BER_DECODER_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/ber_tlv_length.c b/projects/stargazer/plugins/other/snmp/asn1/ber_tlv_length.c new file mode 100644 index 00000000..b87e75e0 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/ber_tlv_length.c @@ -0,0 +1,178 @@ +/*- + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include +#include + +ssize_t +ber_fetch_length(int _is_constructed, const void *bufptr, size_t size, + ber_tlv_len_t *len_r) { + const uint8_t *buf = (const uint8_t *)bufptr; + unsigned oct; + + if(size == 0) + return 0; /* Want more */ + + oct = *(const uint8_t *)buf; + if((oct & 0x80) == 0) { + /* + * Short definite length. + */ + *len_r = oct; /* & 0x7F */ + return 1; + } else { + ber_tlv_len_t len; + size_t skipped; + + if(_is_constructed && oct == 0x80) { + *len_r = -1; /* Indefinite length */ + return 1; + } + + if(oct == 0xff) { + /* Reserved in standard for future use. */ + return -1; + } + + oct &= 0x7F; /* Leave only the 7 LS bits */ + for(len = 0, buf++, skipped = 1; + oct && (++skipped <= size); buf++, oct--) { + + len = (len << 8) | *buf; + if(len < 0 + || (len >> ((8 * sizeof(len)) - 8) && oct > 1)) { + /* + * Too large length value. + */ + return -1; + } + } + + if(oct == 0) { + ber_tlv_len_t lenplusepsilon = (size_t)len + 1024; + /* + * Here length may be very close or equal to 2G. + * However, the arithmetics used in some decoders + * may add some (small) quantities to the length, + * to check the resulting value against some limits. + * This may result in integer wrap-around, which + * we try to avoid by checking it earlier here. + */ + if(lenplusepsilon < 0) { + /* Too large length value */ + return -1; + } + + *len_r = len; + return skipped; + } + + return 0; /* Want more */ + } + +} + +ssize_t +ber_skip_length(asn_codec_ctx_t *opt_codec_ctx, + int _is_constructed, const void *ptr, size_t size) { + ber_tlv_len_t vlen; /* Length of V in TLV */ + ssize_t tl; /* Length of L in TLV */ + ssize_t ll; /* Length of L in TLV */ + size_t skip; + + /* + * Make sure we didn't exceed the maximum stack size. + */ + if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx)) + return -1; + + /* + * Determine the size of L in TLV. + */ + ll = ber_fetch_length(_is_constructed, ptr, size, &vlen); + if(ll <= 0) return ll; + + /* + * Definite length. + */ + if(vlen >= 0) { + skip = ll + vlen; + if(skip > size) + return 0; /* Want more */ + return skip; + } + + /* + * Indefinite length! + */ + ASN_DEBUG("Skipping indefinite length"); + for(skip = ll, ptr = ((const char *)ptr) + ll, size -= ll;;) { + ber_tlv_tag_t tag; + + /* Fetch the tag */ + tl = ber_fetch_tag(ptr, size, &tag); + if(tl <= 0) return tl; + + ll = ber_skip_length(opt_codec_ctx, + BER_TLV_CONSTRUCTED(ptr), + ((const char *)ptr) + tl, size - tl); + if(ll <= 0) return ll; + + skip += tl + ll; + + /* + * This may be the end of the indefinite length structure, + * two consecutive 0 octets. + * Check if it is true. + */ + if(((const uint8_t *)ptr)[0] == 0 + && ((const uint8_t *)ptr)[1] == 0) + return skip; + + ptr = ((const char *)ptr) + tl + ll; + size -= tl + ll; + } + + /* UNREACHABLE */ +} + +size_t +der_tlv_length_serialize(ber_tlv_len_t len, void *bufp, size_t size) { + size_t required_size; /* Size of len encoding */ + uint8_t *buf = (uint8_t *)bufp; + uint8_t *end; + size_t i; + + if(len <= 127) { + /* Encoded in 1 octet */ + if(size) *buf = (uint8_t)len; + return 1; + } + + /* + * Compute the size of the subsequent bytes. + */ + for(required_size = 1, i = 8; i < 8 * sizeof(len); i += 8) { + if(len >> i) + required_size++; + else + break; + } + + if(size <= required_size) + return required_size + 1; + + *buf++ = (uint8_t)(0x80 | required_size); /* Length of the encoding */ + + /* + * Produce the len encoding, space permitting. + */ + end = buf + required_size; + for(i -= 8; buf < end; i -= 8, buf++) + *buf = (uint8_t)(len >> i); + + return required_size + 1; +} + diff --git a/projects/stargazer/plugins/other/snmp/asn1/ber_tlv_length.h b/projects/stargazer/plugins/other/snmp/asn1/ber_tlv_length.h new file mode 100644 index 00000000..34968022 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/ber_tlv_length.h @@ -0,0 +1,50 @@ +/*- + * Copyright (c) 2003 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _BER_TLV_LENGTH_H_ +#define _BER_TLV_LENGTH_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef ssize_t ber_tlv_len_t; + +/* + * This function tries to fetch the length of the BER TLV value and place it + * in *len_r. + * RETURN VALUES: + * 0: More data expected than bufptr contains. + * -1: Fatal error deciphering length. + * >0: Number of bytes used from bufptr. + * On return with >0, len_r is constrained as -1..MAX, where -1 mean + * that the value is of indefinite length. + */ +ssize_t ber_fetch_length(int _is_constructed, const void *bufptr, size_t size, + ber_tlv_len_t *len_r); + +/* + * This function expects bufptr to be positioned over L in TLV. + * It returns number of bytes occupied by L and V together, suitable + * for skipping. The function properly handles indefinite length. + * RETURN VALUES: + * Standard {-1,0,>0} convention. + */ +ssize_t ber_skip_length( + struct asn_codec_ctx_s *opt_codec_ctx, /* optional context */ + int _is_constructed, const void *bufptr, size_t size); + +/* + * This function serializes the length (L from TLV) in DER format. + * It always returns number of bytes necessary to represent the length, + * it is a caller's responsibility to check the return value + * against the supplied buffer's size. + */ +size_t der_tlv_length_serialize(ber_tlv_len_t len, void *bufptr, size_t size); + +#ifdef __cplusplus +} +#endif + +#endif /* _BER_TLV_LENGTH_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/ber_tlv_tag.c b/projects/stargazer/plugins/other/snmp/asn1/ber_tlv_tag.c new file mode 100644 index 00000000..42708760 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/ber_tlv_tag.c @@ -0,0 +1,144 @@ +/*- + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include +#include + +ssize_t +ber_fetch_tag(const void *ptr, size_t size, ber_tlv_tag_t *tag_r) { + ber_tlv_tag_t val; + ber_tlv_tag_t tclass; + size_t skipped; + + if(size == 0) + return 0; + + val = *(const uint8_t *)ptr; + tclass = (val >> 6); + if((val &= 0x1F) != 0x1F) { + /* + * Simple form: everything encoded in a single octet. + * Tag Class is encoded using two least significant bits. + */ + *tag_r = (val << 2) | tclass; + return 1; + } + + /* + * Each octet contains 7 bits of useful information. + * The MSB is 0 if it is the last octet of the tag. + */ + for(val = 0, ptr = ((const char *)ptr) + 1, skipped = 2; + skipped <= size; + ptr = ((const char *)ptr) + 1, skipped++) { + unsigned int oct = *(const uint8_t *)ptr; + if(oct & 0x80) { + val = (val << 7) | (oct & 0x7F); + /* + * Make sure there are at least 9 bits spare + * at the MS side of a value. + */ + if(val >> ((8 * sizeof(val)) - 9)) { + /* + * We would not be able to accomodate + * any more tag bits. + */ + return -1; + } + } else { + val = (val << 7) | oct; + *tag_r = (val << 2) | tclass; + return skipped; + } + } + + return 0; /* Want more */ +} + + +ssize_t +ber_tlv_tag_fwrite(ber_tlv_tag_t tag, FILE *f) { + char buf[sizeof("[APPLICATION ]") + 32]; + ssize_t ret; + + ret = ber_tlv_tag_snprint(tag, buf, sizeof(buf)); + if(ret >= (ssize_t)sizeof(buf) || ret < 2) { + errno = EPERM; + return -1; + } + + return fwrite(buf, 1, ret, f); +} + +ssize_t +ber_tlv_tag_snprint(ber_tlv_tag_t tag, char *buf, size_t size) { + char *type = 0; + int ret; + + switch(tag & 0x3) { + case ASN_TAG_CLASS_UNIVERSAL: type = "UNIVERSAL "; break; + case ASN_TAG_CLASS_APPLICATION: type = "APPLICATION "; break; + case ASN_TAG_CLASS_CONTEXT: type = ""; break; + case ASN_TAG_CLASS_PRIVATE: type = "PRIVATE "; break; + } + + ret = snprintf(buf, size, "[%s%u]", type, ((unsigned)tag) >> 2); + if(ret <= 0 && size) buf[0] = '\0'; /* against broken libc's */ + + return ret; +} + +char * +ber_tlv_tag_string(ber_tlv_tag_t tag) { + static char buf[sizeof("[APPLICATION ]") + 32]; + + (void)ber_tlv_tag_snprint(tag, buf, sizeof(buf)); + + return buf; +} + + +size_t +ber_tlv_tag_serialize(ber_tlv_tag_t tag, void *bufp, size_t size) { + int tclass = BER_TAG_CLASS(tag); + ber_tlv_tag_t tval = BER_TAG_VALUE(tag); + uint8_t *buf = (uint8_t *)bufp; + uint8_t *end; + size_t required_size; + size_t i; + + if(tval <= 30) { + /* Encoded in 1 octet */ + if(size) buf[0] = (tclass << 6) | tval; + return 1; + } else if(size) { + *buf++ = (tclass << 6) | 0x1F; + size--; + } + + /* + * Compute the size of the subsequent bytes. + */ + for(required_size = 1, i = 7; i < 8 * sizeof(tval); i += 7) { + if(tval >> i) + required_size++; + else + break; + } + + if(size < required_size) + return required_size + 1; + + /* + * Fill in the buffer, space permitting. + */ + end = buf + required_size - 1; + for(i -= 7; buf < end; i -= 7, buf++) + *buf = 0x80 | ((tval >> i) & 0x7F); + *buf = (tval & 0x7F); /* Last octet without high bit */ + + return required_size + 1; +} + diff --git a/projects/stargazer/plugins/other/snmp/asn1/ber_tlv_tag.h b/projects/stargazer/plugins/other/snmp/asn1/ber_tlv_tag.h new file mode 100644 index 00000000..60e86686 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/ber_tlv_tag.h @@ -0,0 +1,60 @@ +/*- + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _BER_TLV_TAG_H_ +#define _BER_TLV_TAG_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +enum asn_tag_class { + ASN_TAG_CLASS_UNIVERSAL = 0, /* 0b00 */ + ASN_TAG_CLASS_APPLICATION = 1, /* 0b01 */ + ASN_TAG_CLASS_CONTEXT = 2, /* 0b10 */ + ASN_TAG_CLASS_PRIVATE = 3 /* 0b11 */ +}; +typedef unsigned ber_tlv_tag_t; /* BER TAG from Tag-Length-Value */ + +/* + * Tag class is encoded together with tag value for optimization purposes. + */ +#define BER_TAG_CLASS(tag) ((tag) & 0x3) +#define BER_TAG_VALUE(tag) ((tag) >> 2) +#define BER_TLV_CONSTRUCTED(tagptr) (((*(const uint8_t *)tagptr)&0x20)?1:0) + +#define BER_TAGS_EQUAL(tag1, tag2) ((tag1) == (tag2)) + +/* + * Several functions for printing the TAG in the canonical form + * (i.e. "[PRIVATE 0]"). + * Return values correspond to their libc counterparts (if any). + */ +ssize_t ber_tlv_tag_snprint(ber_tlv_tag_t tag, char *buf, size_t buflen); +ssize_t ber_tlv_tag_fwrite(ber_tlv_tag_t tag, FILE *); +char *ber_tlv_tag_string(ber_tlv_tag_t tag); + + +/* + * This function tries to fetch the tag from the input stream. + * RETURN VALUES: + * 0: More data expected than bufptr contains. + * -1: Fatal error deciphering tag. + * >0: Number of bytes used from bufptr. tag_r will contain the tag. + */ +ssize_t ber_fetch_tag(const void *bufptr, size_t size, ber_tlv_tag_t *tag_r); + +/* + * This function serializes the tag (T from TLV) in BER format. + * It always returns number of bytes necessary to represent the tag, + * it is a caller's responsibility to check the return value + * against the supplied buffer's size. + */ +size_t ber_tlv_tag_serialize(ber_tlv_tag_t tag, void *bufptr, size_t size); + +#ifdef __cplusplus +} +#endif + +#endif /* _BER_TLV_TAG_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/constr_CHOICE.c b/projects/stargazer/plugins/other/snmp/asn1/constr_CHOICE.c new file mode 100644 index 00000000..b8d6fa9a --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/constr_CHOICE.c @@ -0,0 +1,1101 @@ +/* + * Copyright (c) 2003, 2004, 2005, 2006 Lev Walkin . + * All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include + +/* + * Number of bytes left for this structure. + * (ctx->left) indicates the number of bytes _transferred_ for the structure. + * (size) contains the number of bytes in the buffer passed. + */ +#define LEFT ((size<(size_t)ctx->left)?size:(size_t)ctx->left) + +/* + * If the subprocessor function returns with an indication that it wants + * more data, it may well be a fatal decoding problem, because the + * size is constrained by the 's L, even if the buffer size allows + * reading more data. + * For example, consider the buffer containing the following TLVs: + * ... + * The TLV length clearly indicates that one byte is expected in V, but + * if the V processor returns with "want more data" even if the buffer + * contains way more data than the V processor have seen. + */ +#define SIZE_VIOLATION (ctx->left >= 0 && (size_t)ctx->left <= size) + +/* + * This macro "eats" the part of the buffer which is definitely "consumed", + * i.e. was correctly converted into local representation or rightfully skipped. + */ +#undef ADVANCE +#define ADVANCE(num_bytes) do { \ + size_t num = num_bytes; \ + ptr = ((const char *)ptr) + num;\ + size -= num; \ + if(ctx->left >= 0) \ + ctx->left -= num; \ + consumed_myself += num; \ + } while(0) + +/* + * Switch to the next phase of parsing. + */ +#undef NEXT_PHASE +#define NEXT_PHASE(ctx) do { \ + ctx->phase++; \ + ctx->step = 0; \ + } while(0) + +/* + * Return a standardized complex structure. + */ +#undef RETURN +#define RETURN(_code) do { \ + rval.code = _code; \ + rval.consumed = consumed_myself;\ + return rval; \ + } while(0) + +/* + * See the definitions. + */ +static int _fetch_present_idx(const void *struct_ptr, int off, int size); +static void _set_present_idx(void *sptr, int offset, int size, int pres); + +/* + * Tags are canonically sorted in the tag to member table. + */ +static int +_search4tag(const void *ap, const void *bp) { + const asn_TYPE_tag2member_t *a = (const asn_TYPE_tag2member_t *)ap; + const asn_TYPE_tag2member_t *b = (const asn_TYPE_tag2member_t *)bp; + + int a_class = BER_TAG_CLASS(a->el_tag); + int b_class = BER_TAG_CLASS(b->el_tag); + + if(a_class == b_class) { + ber_tlv_tag_t a_value = BER_TAG_VALUE(a->el_tag); + ber_tlv_tag_t b_value = BER_TAG_VALUE(b->el_tag); + + if(a_value == b_value) + return 0; + else if(a_value < b_value) + return -1; + else + return 1; + } else if(a_class < b_class) { + return -1; + } else { + return 1; + } +} + +/* + * The decoder of the CHOICE type. + */ +asn_dec_rval_t +CHOICE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **struct_ptr, const void *ptr, size_t size, int tag_mode) { + /* + * Bring closer parts of structure description. + */ + asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics; + asn_TYPE_member_t *elements = td->elements; + + /* + * Parts of the structure being constructed. + */ + void *st = *struct_ptr; /* Target structure. */ + asn_struct_ctx_t *ctx; /* Decoder context */ + + ber_tlv_tag_t tlv_tag; /* T from TLV */ + ssize_t tag_len; /* Length of TLV's T */ + asn_dec_rval_t rval; /* Return code from subparsers */ + + ssize_t consumed_myself = 0; /* Consumed bytes from ptr */ + + ASN_DEBUG("Decoding %s as CHOICE", td->name); + + /* + * Create the target structure if it is not present already. + */ + if(st == 0) { + st = *struct_ptr = CALLOC(1, specs->struct_size); + if(st == 0) { + RETURN(RC_FAIL); + } + } + + /* + * Restore parsing context. + */ + ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset); + + /* + * Start to parse where left previously + */ + switch(ctx->phase) { + case 0: + /* + * PHASE 0. + * Check that the set of tags associated with given structure + * perfectly fits our expectations. + */ + + if(tag_mode || td->tags_count) { + rval = ber_check_tags(opt_codec_ctx, td, ctx, ptr, size, + tag_mode, -1, &ctx->left, 0); + if(rval.code != RC_OK) { + ASN_DEBUG("%s tagging check failed: %d", + td->name, rval.code); + return rval; + } + + if(ctx->left >= 0) { + /* ?Substracted below! */ + ctx->left += rval.consumed; + } + ADVANCE(rval.consumed); + } else { + ctx->left = -1; + } + + NEXT_PHASE(ctx); + + ASN_DEBUG("Structure consumes %ld bytes, buffer %ld", + (long)ctx->left, (long)size); + + /* Fall through */ + case 1: + /* + * Fetch the T from TLV. + */ + tag_len = ber_fetch_tag(ptr, LEFT, &tlv_tag); + ASN_DEBUG("In %s CHOICE tag length %d", td->name, (int)tag_len); + switch(tag_len) { + case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE); + /* Fall through */ + case -1: RETURN(RC_FAIL); + } + + do { + asn_TYPE_tag2member_t *t2m; + asn_TYPE_tag2member_t key; + + key.el_tag = tlv_tag; + t2m = (asn_TYPE_tag2member_t *)bsearch(&key, + specs->tag2el, specs->tag2el_count, + sizeof(specs->tag2el[0]), _search4tag); + if(t2m) { + /* + * Found the element corresponding to the tag. + */ + NEXT_PHASE(ctx); + ctx->step = t2m->el_no; + break; + } else if(specs->ext_start == -1) { + ASN_DEBUG("Unexpected tag %s " + "in non-extensible CHOICE %s", + ber_tlv_tag_string(tlv_tag), td->name); + RETURN(RC_FAIL); + } else { + /* Skip this tag */ + ssize_t skip; + + ASN_DEBUG("Skipping unknown tag %s", + ber_tlv_tag_string(tlv_tag)); + + skip = ber_skip_length(opt_codec_ctx, + BER_TLV_CONSTRUCTED(ptr), + (const char *)ptr + tag_len, + LEFT - tag_len); + + switch(skip) { + case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE); + /* Fall through */ + case -1: RETURN(RC_FAIL); + } + + ADVANCE(skip + tag_len); + RETURN(RC_OK); + } + } while(0); + + case 2: + /* + * PHASE 2. + * Read in the element. + */ + do { + asn_TYPE_member_t *elm;/* CHOICE's element */ + void *memb_ptr; /* Pointer to the member */ + void **memb_ptr2; /* Pointer to that pointer */ + + elm = &elements[ctx->step]; + + /* + * Compute the position of the member inside a structure, + * and also a type of containment (it may be contained + * as pointer or using inline inclusion). + */ + if(elm->flags & ATF_POINTER) { + /* Member is a pointer to another structure */ + memb_ptr2 = (void **)((char *)st + elm->memb_offset); + } else { + /* + * A pointer to a pointer + * holding the start of the structure + */ + memb_ptr = (char *)st + elm->memb_offset; + memb_ptr2 = &memb_ptr; + } + /* Set presence to be able to free it properly at any time */ + _set_present_idx(st, specs->pres_offset, + specs->pres_size, ctx->step + 1); + /* + * Invoke the member fetch routine according to member's type + */ + rval = elm->type->ber_decoder(opt_codec_ctx, elm->type, + memb_ptr2, ptr, LEFT, elm->tag_mode); + switch(rval.code) { + case RC_OK: + break; + case RC_WMORE: /* More data expected */ + if(!SIZE_VIOLATION) { + ADVANCE(rval.consumed); + RETURN(RC_WMORE); + } + RETURN(RC_FAIL); + case RC_FAIL: /* Fatal error */ + RETURN(rval.code); + } /* switch(rval) */ + + ADVANCE(rval.consumed); + } while(0); + + NEXT_PHASE(ctx); + + /* Fall through */ + case 3: + ASN_DEBUG("CHOICE %s Leftover: %ld, size = %ld, tm=%d, tc=%d", + td->name, (long)ctx->left, (long)size, + tag_mode, td->tags_count); + + if(ctx->left > 0) { + /* + * The type must be fully decoded + * by the CHOICE member-specific decoder. + */ + RETURN(RC_FAIL); + } + + if(ctx->left == -1 + && !(tag_mode || td->tags_count)) { + /* + * This is an untagged CHOICE. + * It doesn't contain nothing + * except for the member itself, including all its tags. + * The decoding is completed. + */ + NEXT_PHASE(ctx); + break; + } + + /* + * Read in the "end of data chunks"'s. + */ + while(ctx->left < 0) { + ssize_t tl; + + tl = ber_fetch_tag(ptr, LEFT, &tlv_tag); + switch(tl) { + case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE); + /* Fall through */ + case -1: RETURN(RC_FAIL); + } + + /* + * Expected <0><0>... + */ + if(((const uint8_t *)ptr)[0] == 0) { + if(LEFT < 2) { + if(SIZE_VIOLATION) + RETURN(RC_FAIL); + else + RETURN(RC_WMORE); + } else if(((const uint8_t *)ptr)[1] == 0) { + /* + * Correctly finished with <0><0>. + */ + ADVANCE(2); + ctx->left++; + continue; + } + } else { + ASN_DEBUG("Unexpected continuation in %s", + td->name); + RETURN(RC_FAIL); + } + + /* UNREACHABLE */ + } + + NEXT_PHASE(ctx); + case 4: + /* No meaningful work here */ + break; + } + + RETURN(RC_OK); +} + +asn_enc_rval_t +CHOICE_encode_der(asn_TYPE_descriptor_t *td, void *sptr, + int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics; + asn_TYPE_member_t *elm; /* CHOICE element */ + asn_enc_rval_t erval; + void *memb_ptr; + size_t computed_size = 0; + int present; + + if(!sptr) _ASN_ENCODE_FAILED; + + ASN_DEBUG("%s %s as CHOICE", + cb?"Encoding":"Estimating", td->name); + + present = _fetch_present_idx(sptr, + specs->pres_offset, specs->pres_size); + + /* + * If the structure was not initialized, it cannot be encoded: + * can't deduce what to encode in the choice type. + */ + if(present <= 0 || present > td->elements_count) { + if(present == 0 && td->elements_count == 0) { + /* The CHOICE is empty?! */ + erval.encoded = 0; + _ASN_ENCODED_OK(erval); + } + _ASN_ENCODE_FAILED; + } + + /* + * Seek over the present member of the structure. + */ + elm = &td->elements[present-1]; + if(elm->flags & ATF_POINTER) { + memb_ptr = *(void **)((char *)sptr + elm->memb_offset); + if(memb_ptr == 0) { + if(elm->optional) { + erval.encoded = 0; + _ASN_ENCODED_OK(erval); + } + /* Mandatory element absent */ + _ASN_ENCODE_FAILED; + } + } else { + memb_ptr = (void *)((char *)sptr + elm->memb_offset); + } + + /* + * If the CHOICE itself is tagged EXPLICIT: + * T ::= [2] EXPLICIT CHOICE { ... } + * Then emit the appropriate tags. + */ + if(tag_mode == 1 || td->tags_count) { + /* + * For this, we need to pre-compute the member. + */ + ssize_t ret; + + /* Encode member with its tag */ + erval = elm->type->der_encoder(elm->type, memb_ptr, + elm->tag_mode, elm->tag, 0, 0); + if(erval.encoded == -1) + return erval; + + /* Encode CHOICE with parent or my own tag */ + ret = der_write_tags(td, erval.encoded, tag_mode, 1, tag, + cb, app_key); + if(ret == -1) + _ASN_ENCODE_FAILED; + computed_size += ret; + } + + /* + * Encode the single underlying member. + */ + erval = elm->type->der_encoder(elm->type, memb_ptr, + elm->tag_mode, elm->tag, cb, app_key); + if(erval.encoded == -1) + return erval; + + ASN_DEBUG("Encoded CHOICE member in %ld bytes (+%ld)", + (long)erval.encoded, (long)computed_size); + + erval.encoded += computed_size; + + return erval; +} + +ber_tlv_tag_t +CHOICE_outmost_tag(asn_TYPE_descriptor_t *td, const void *ptr, int tag_mode, ber_tlv_tag_t tag) { + asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics; + int present; + + assert(tag_mode == 0); (void)tag_mode; + assert(tag == 0); (void)tag; + + /* + * Figure out which CHOICE element is encoded. + */ + present = _fetch_present_idx(ptr, specs->pres_offset, specs->pres_size); + + if(present > 0 || present <= td->elements_count) { + asn_TYPE_member_t *elm = &td->elements[present-1]; + const void *memb_ptr; + + if(elm->flags & ATF_POINTER) { + memb_ptr = *(const void * const *) + ((const char *)ptr + elm->memb_offset); + } else { + memb_ptr = (const void *) + ((const char *)ptr + elm->memb_offset); + } + + return asn_TYPE_outmost_tag(elm->type, memb_ptr, + elm->tag_mode, elm->tag); + } else { + return (ber_tlv_tag_t)-1; + } +} + +int +CHOICE_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics; + int present; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* + * Figure out which CHOICE element is encoded. + */ + present = _fetch_present_idx(sptr, specs->pres_offset,specs->pres_size); + if(present > 0 && present <= td->elements_count) { + asn_TYPE_member_t *elm = &td->elements[present-1]; + const void *memb_ptr; + + if(elm->flags & ATF_POINTER) { + memb_ptr = *(const void * const *)((const char *)sptr + elm->memb_offset); + if(!memb_ptr) { + if(elm->optional) + return 0; + _ASN_CTFAIL(app_key, td, + "%s: mandatory CHOICE element %s absent (%s:%d)", + td->name, elm->name, __FILE__, __LINE__); + return -1; + } + } else { + memb_ptr = (const void *)((const char *)sptr + elm->memb_offset); + } + + if(elm->memb_constraints) { + return elm->memb_constraints(elm->type, memb_ptr, + ctfailcb, app_key); + } else { + int ret = elm->type->check_constraints(elm->type, + memb_ptr, ctfailcb, app_key); + /* + * Cannot inherit it eralier: + * need to make sure we get the updated version. + */ + elm->memb_constraints = elm->type->check_constraints; + return ret; + } + } else { + _ASN_CTFAIL(app_key, td, + "%s: no CHOICE element given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +#undef XER_ADVANCE +#define XER_ADVANCE(num_bytes) do { \ + size_t num = num_bytes; \ + buf_ptr = ((const char *)buf_ptr) + num;\ + size -= num; \ + consumed_myself += num; \ + } while(0) + +/* + * Decode the XER (XML) data. + */ +asn_dec_rval_t +CHOICE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **struct_ptr, const char *opt_mname, + const void *buf_ptr, size_t size) { + /* + * Bring closer parts of structure description. + */ + asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics; + const char *xml_tag = opt_mname ? opt_mname : td->xml_tag; + + /* + * Parts of the structure being constructed. + */ + void *st = *struct_ptr; /* Target structure. */ + asn_struct_ctx_t *ctx; /* Decoder context */ + + asn_dec_rval_t rval; /* Return value of a decoder */ + ssize_t consumed_myself = 0; /* Consumed bytes from ptr */ + int edx; /* Element index */ + + /* + * Create the target structure if it is not present already. + */ + if(st == 0) { + st = *struct_ptr = CALLOC(1, specs->struct_size); + if(st == 0) RETURN(RC_FAIL); + } + + /* + * Restore parsing context. + */ + ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset); + if(ctx->phase == 0 && !*xml_tag) + ctx->phase = 1; /* Skip the outer tag checking phase */ + + /* + * Phases of XER/XML processing: + * Phase 0: Check that the opening tag matches our expectations. + * Phase 1: Processing body and reacting on closing tag. + * Phase 2: Processing inner type. + * Phase 3: Only waiting for closing tag. + * Phase 4: Skipping unknown extensions. + * Phase 5: PHASED OUT + */ + for(edx = ctx->step; ctx->phase <= 4;) { + pxer_chunk_type_e ch_type; /* XER chunk type */ + ssize_t ch_size; /* Chunk size */ + xer_check_tag_e tcv; /* Tag check value */ + asn_TYPE_member_t *elm; + + /* + * Go inside the member. + */ + if(ctx->phase == 2) { + asn_dec_rval_t tmprval; + void *memb_ptr; /* Pointer to the member */ + void **memb_ptr2; /* Pointer to that pointer */ + + elm = &td->elements[edx]; + + if(elm->flags & ATF_POINTER) { + /* Member is a pointer to another structure */ + memb_ptr2 = (void **)((char *)st + + elm->memb_offset); + } else { + memb_ptr = (char *)st + elm->memb_offset; + memb_ptr2 = &memb_ptr; + } + + /* Start/Continue decoding the inner member */ + tmprval = elm->type->xer_decoder(opt_codec_ctx, + elm->type, memb_ptr2, elm->name, + buf_ptr, size); + XER_ADVANCE(tmprval.consumed); + ASN_DEBUG("XER/CHOICE: itdf: [%s] code=%d", + elm->type->name, tmprval.code); + if(tmprval.code != RC_OK) + RETURN(tmprval.code); + assert(_fetch_present_idx(st, + specs->pres_offset, specs->pres_size) == 0); + /* Record what we've got */ + _set_present_idx(st, + specs->pres_offset, specs->pres_size, edx + 1); + ctx->phase = 3; + /* Fall through */ + } + + /* No need to wait for closing tag; special mode. */ + if(ctx->phase == 3 && !*xml_tag) { + ctx->phase = 5; /* Phase out */ + RETURN(RC_OK); + } + + /* + * Get the next part of the XML stream. + */ + ch_size = xer_next_token(&ctx->context, buf_ptr, size, &ch_type); + switch(ch_size) { + case -1: RETURN(RC_FAIL); + case 0: RETURN(RC_WMORE); + default: + switch(ch_type) { + case PXER_COMMENT: /* Got XML comment */ + case PXER_TEXT: /* Ignore free-standing text */ + XER_ADVANCE(ch_size); /* Skip silently */ + continue; + case PXER_TAG: + break; /* Check the rest down there */ + } + } + + tcv = xer_check_tag(buf_ptr, ch_size, xml_tag); + ASN_DEBUG("XER/CHOICE checked [%c%c%c%c] vs [%s], tcv=%d", + ch_size>0?((const uint8_t *)buf_ptr)[0]:'?', + ch_size>1?((const uint8_t *)buf_ptr)[1]:'?', + ch_size>2?((const uint8_t *)buf_ptr)[2]:'?', + ch_size>3?((const uint8_t *)buf_ptr)[3]:'?', + xml_tag, tcv); + + /* Skip the extensions section */ + if(ctx->phase == 4) { + ASN_DEBUG("skip_unknown(%d, %ld)", + tcv, (long)ctx->left); + switch(xer_skip_unknown(tcv, &ctx->left)) { + case -1: + ctx->phase = 5; + RETURN(RC_FAIL); + continue; + case 1: + ctx->phase = 3; + /* Fall through */ + case 0: + XER_ADVANCE(ch_size); + continue; + case 2: + ctx->phase = 3; + break; + } + } + + switch(tcv) { + case XCT_BOTH: + break; /* No CHOICE? */ + case XCT_CLOSING: + if(ctx->phase != 3) + break; + XER_ADVANCE(ch_size); + ctx->phase = 5; /* Phase out */ + RETURN(RC_OK); + case XCT_OPENING: + if(ctx->phase == 0) { + XER_ADVANCE(ch_size); + ctx->phase = 1; /* Processing body phase */ + continue; + } + /* Fall through */ + case XCT_UNKNOWN_OP: + case XCT_UNKNOWN_BO: + + if(ctx->phase != 1) + break; /* Really unexpected */ + + /* + * Search which inner member corresponds to this tag. + */ + for(edx = 0; edx < td->elements_count; edx++) { + elm = &td->elements[edx]; + tcv = xer_check_tag(buf_ptr,ch_size,elm->name); + switch(tcv) { + case XCT_BOTH: + case XCT_OPENING: + /* + * Process this member. + */ + ctx->step = edx; + ctx->phase = 2; + break; + case XCT_UNKNOWN_OP: + case XCT_UNKNOWN_BO: + continue; + default: + edx = td->elements_count; + break; /* Phase out */ + } + break; + } + if(edx != td->elements_count) + continue; + + /* It is expected extension */ + if(specs->ext_start != -1) { + ASN_DEBUG("Got anticipated extension"); + /* + * Check for (XCT_BOTH or XCT_UNKNOWN_BO) + * By using a mask. Only record a pure + * tags. + */ + if(tcv & XCT_CLOSING) { + /* Found without body */ + ctx->phase = 3; /* Terminating */ + } else { + ctx->left = 1; + ctx->phase = 4; /* Skip ...'s */ + } + XER_ADVANCE(ch_size); + continue; + } + + /* Fall through */ + default: + break; + } + + ASN_DEBUG("Unexpected XML tag [%c%c%c%c] in CHOICE [%s]" + " (ph=%d, tag=%s)", + ch_size>0?((const uint8_t *)buf_ptr)[0]:'?', + ch_size>1?((const uint8_t *)buf_ptr)[1]:'?', + ch_size>2?((const uint8_t *)buf_ptr)[2]:'?', + ch_size>3?((const uint8_t *)buf_ptr)[3]:'?', + td->name, ctx->phase, xml_tag); + break; + } + + ctx->phase = 5; /* Phase out, just in case */ + RETURN(RC_FAIL); +} + + +asn_enc_rval_t +CHOICE_encode_xer(asn_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + asn_CHOICE_specifics_t *specs=(asn_CHOICE_specifics_t *)td->specifics; + asn_enc_rval_t er; + int present; + + if(!sptr) + _ASN_ENCODE_FAILED; + + /* + * Figure out which CHOICE element is encoded. + */ + present = _fetch_present_idx(sptr, specs->pres_offset,specs->pres_size); + + if(present <= 0 || present > td->elements_count) { + _ASN_ENCODE_FAILED; + } else { + asn_enc_rval_t tmper; + asn_TYPE_member_t *elm = &td->elements[present-1]; + void *memb_ptr; + const char *mname = elm->name; + unsigned int mlen = strlen(mname); + + if(elm->flags & ATF_POINTER) { + memb_ptr = *(void **)((char *)sptr + elm->memb_offset); + if(!memb_ptr) _ASN_ENCODE_FAILED; + } else { + memb_ptr = (void *)((char *)sptr + elm->memb_offset); + } + + er.encoded = 0; + + if(!(flags & XER_F_CANONICAL)) _i_ASN_TEXT_INDENT(1, ilevel); + _ASN_CALLBACK3("<", 1, mname, mlen, ">", 1); + + tmper = elm->type->xer_encoder(elm->type, memb_ptr, + ilevel + 1, flags, cb, app_key); + if(tmper.encoded == -1) return tmper; + + _ASN_CALLBACK3("", 1); + + er.encoded += 5 + (2 * mlen) + tmper.encoded; + } + + if(!(flags & XER_F_CANONICAL)) _i_ASN_TEXT_INDENT(1, ilevel - 1); + + _ASN_ENCODED_OK(er); +cb_failed: + _ASN_ENCODE_FAILED; +} + +asn_dec_rval_t +CHOICE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) { + asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics; + asn_dec_rval_t rv; + asn_per_constraint_t *ct; + asn_TYPE_member_t *elm; /* CHOICE's element */ + void *memb_ptr; + void **memb_ptr2; + void *st = *sptr; + int value; + + if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx)) + _ASN_DECODE_FAILED; + + /* + * Create the target structure if it is not present already. + */ + if(!st) { + st = *sptr = CALLOC(1, specs->struct_size); + if(!st) _ASN_DECODE_FAILED; + } + + if(constraints) ct = &constraints->value; + else if(td->per_constraints) ct = &td->per_constraints->value; + else ct = 0; + + if(ct && ct->flags & APC_EXTENSIBLE) { + value = per_get_few_bits(pd, 1); + if(value < 0) _ASN_DECODE_STARVED; + if(value) ct = 0; /* Not restricted */ + } + + if(ct && ct->range_bits >= 0) { + value = per_get_few_bits(pd, ct->range_bits); + if(value < 0) _ASN_DECODE_STARVED; + ASN_DEBUG("CHOICE %s got index %d in range %d", + td->name, value, ct->range_bits); + if(value > ct->upper_bound) + _ASN_DECODE_FAILED; + } else { + if(specs->ext_start == -1) + _ASN_DECODE_FAILED; + value = uper_get_nsnnwn(pd); + if(value < 0) _ASN_DECODE_STARVED; + value += specs->ext_start; + if(value >= td->elements_count) + _ASN_DECODE_FAILED; + ASN_DEBUG("NOT IMPLEMENTED YET"); + _ASN_DECODE_FAILED; + } + + /* Adjust if canonical order is different from natural order */ + if(specs->canonical_order) + value = specs->canonical_order[value]; + + /* Set presence to be able to free it later */ + _set_present_idx(st, specs->pres_offset, specs->pres_size, value + 1); + + elm = &td->elements[value]; + if(elm->flags & ATF_POINTER) { + /* Member is a pointer to another structure */ + memb_ptr2 = (void **)((char *)st + elm->memb_offset); + } else { + memb_ptr = (char *)st + elm->memb_offset; + memb_ptr2 = &memb_ptr; + } + ASN_DEBUG("Discovered CHOICE %s encodes %s", td->name, elm->name); + + rv = elm->type->uper_decoder(opt_codec_ctx, elm->type, + elm->per_constraints, memb_ptr2, pd); + if(rv.code != RC_OK) + ASN_DEBUG("Failed to decode %s in %s (CHOICE)", + elm->name, td->name); + return rv; +} + +asn_enc_rval_t +CHOICE_encode_uper(asn_TYPE_descriptor_t *td, + asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) { + asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics; + asn_TYPE_member_t *elm; /* CHOICE's element */ + asn_per_constraint_t *ct; + void *memb_ptr; + int present; + + if(!sptr) _ASN_ENCODE_FAILED; + + ASN_DEBUG("Encoding %s as CHOICE", td->name); + + if(constraints) ct = &constraints->value; + else if(td->per_constraints) ct = &td->per_constraints->value; + else ct = 0; + + present = _fetch_present_idx(sptr, + specs->pres_offset, specs->pres_size); + + /* + * If the structure was not initialized properly, it cannot be encoded: + * can't deduce what to encode in the choice type. + */ + if(present <= 0 || present > td->elements_count) + _ASN_ENCODE_FAILED; + else + present--; + + /* Adjust if canonical order is different from natural order */ + if(specs->canonical_order) + present = specs->canonical_order[present]; + + ASN_DEBUG("Encoding %s CHOICE element %d", td->name, present); + + if(ct && ct->range_bits >= 0) { + if(present < ct->lower_bound + || present > ct->upper_bound) { + if(ct->flags & APC_EXTENSIBLE) { + if(per_put_few_bits(po, 1, 1)) + _ASN_ENCODE_FAILED; + } else { + _ASN_ENCODE_FAILED; + } + ct = 0; + } + } + if(ct && ct->flags & APC_EXTENSIBLE) + if(per_put_few_bits(po, 0, 1)) + _ASN_ENCODE_FAILED; + + if(ct && ct->range_bits >= 0) { + if(per_put_few_bits(po, present, ct->range_bits)) + _ASN_ENCODE_FAILED; + } else { + if(specs->ext_start == -1) + _ASN_ENCODE_FAILED; + if(uper_put_nsnnwn(po, present - specs->ext_start)) + _ASN_ENCODE_FAILED; + ASN_DEBUG("NOT IMPLEMENTED YET"); + _ASN_ENCODE_FAILED; + } + + elm = &td->elements[present]; + if(elm->flags & ATF_POINTER) { + /* Member is a pointer to another structure */ + memb_ptr = *(void **)((char *)sptr + elm->memb_offset); + if(!memb_ptr) _ASN_ENCODE_FAILED; + } else { + memb_ptr = (char *)sptr + elm->memb_offset; + } + + return elm->type->uper_encoder(elm->type, elm->per_constraints, + memb_ptr, po); +} + + +int +CHOICE_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel, + asn_app_consume_bytes_f *cb, void *app_key) { + asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics; + int present; + + if(!sptr) return (cb("", 8, app_key) < 0) ? -1 : 0; + + /* + * Figure out which CHOICE element is encoded. + */ + present = _fetch_present_idx(sptr, specs->pres_offset,specs->pres_size); + + /* + * Print that element. + */ + if(present > 0 && present <= td->elements_count) { + asn_TYPE_member_t *elm = &td->elements[present-1]; + const void *memb_ptr; + + if(elm->flags & ATF_POINTER) { + memb_ptr = *(const void * const *)((const char *)sptr + elm->memb_offset); + if(!memb_ptr) return (cb("", 8, app_key) < 0) ? -1 : 0; + } else { + memb_ptr = (const void *)((const char *)sptr + elm->memb_offset); + } + + /* Print member's name and stuff */ + if(0) { + if(cb(elm->name, strlen(elm->name), app_key) < 0 + || cb(": ", 2, app_key) < 0) + return -1; + } + + return elm->type->print_struct(elm->type, memb_ptr, ilevel, + cb, app_key); + } else { + return (cb("", 8, app_key) < 0) ? -1 : 0; + } +} + +void +CHOICE_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) { + asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics; + int present; + + if(!td || !ptr) + return; + + ASN_DEBUG("Freeing %s as CHOICE", td->name); + + /* + * Figure out which CHOICE element is encoded. + */ + present = _fetch_present_idx(ptr, specs->pres_offset, specs->pres_size); + + /* + * Free that element. + */ + if(present > 0 && present <= td->elements_count) { + asn_TYPE_member_t *elm = &td->elements[present-1]; + void *memb_ptr; + + if(elm->flags & ATF_POINTER) { + memb_ptr = *(void **)((char *)ptr + elm->memb_offset); + if(memb_ptr) + ASN_STRUCT_FREE(*elm->type, memb_ptr); + } else { + memb_ptr = (void *)((char *)ptr + elm->memb_offset); + ASN_STRUCT_FREE_CONTENTS_ONLY(*elm->type, memb_ptr); + } + } + + if(!contents_only) { + FREEMEM(ptr); + } +} + + +/* + * The following functions functions offer protection against -fshort-enums, + * compatible with little- and big-endian machines. + * If assertion is triggered, either disable -fshort-enums, or add an entry + * here with the ->pres_size of your target stracture. + * Unless the target structure is packed, the ".present" member + * is guaranteed to be aligned properly. ASN.1 compiler itself does not + * produce packed code. + */ +static int +_fetch_present_idx(const void *struct_ptr, int pres_offset, int pres_size) { + const void *present_ptr; + int present; + + present_ptr = ((const char *)struct_ptr) + pres_offset; + + switch(pres_size) { + case sizeof(int): present = *(const int *)present_ptr; break; + case sizeof(short): present = *(const short *)present_ptr; break; + case sizeof(char): present = *(const char *)present_ptr; break; + default: + /* ANSI C mandates enum to be equivalent to integer */ + assert(pres_size != sizeof(int)); + return 0; /* If not aborted, pass back safe value */ + } + + return present; +} + +static void +_set_present_idx(void *struct_ptr, int pres_offset, int pres_size, int present) { + void *present_ptr; + present_ptr = ((char *)struct_ptr) + pres_offset; + + switch(pres_size) { + case sizeof(int): *(int *)present_ptr = present; break; + case sizeof(short): *(short *)present_ptr = present; break; + case sizeof(char): *(char *)present_ptr = present; break; + default: + /* ANSI C mandates enum to be equivalent to integer */ + assert(pres_size != sizeof(int)); + } +} diff --git a/projects/stargazer/plugins/other/snmp/asn1/constr_CHOICE.h b/projects/stargazer/plugins/other/snmp/asn1/constr_CHOICE.h new file mode 100644 index 00000000..83404e6d --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/constr_CHOICE.h @@ -0,0 +1,57 @@ +/*- + * Copyright (c) 2003, 2004, 2005 Lev Walkin . + * All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _CONSTR_CHOICE_H_ +#define _CONSTR_CHOICE_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct asn_CHOICE_specifics_s { + /* + * Target structure description. + */ + int struct_size; /* Size of the target structure. */ + int ctx_offset; /* Offset of the asn_codec_ctx_t member */ + int pres_offset; /* Identifier of the present member */ + int pres_size; /* Size of the identifier (enum) */ + + /* + * Tags to members mapping table. + */ + asn_TYPE_tag2member_t *tag2el; + int tag2el_count; + + /* Canonical ordering of CHOICE elements, for PER */ + int *canonical_order; + + /* + * Extensions-related stuff. + */ + int ext_start; /* First member of extensions, or -1 */ +} asn_CHOICE_specifics_t; + +/* + * A set specialized functions dealing with the CHOICE type. + */ +asn_struct_free_f CHOICE_free; +asn_struct_print_f CHOICE_print; +asn_constr_check_f CHOICE_constraint; +ber_type_decoder_f CHOICE_decode_ber; +der_type_encoder_f CHOICE_encode_der; +xer_type_decoder_f CHOICE_decode_xer; +xer_type_encoder_f CHOICE_encode_xer; +per_type_decoder_f CHOICE_decode_uper; +per_type_encoder_f CHOICE_encode_uper; +asn_outmost_tag_f CHOICE_outmost_tag; + +#ifdef __cplusplus +} +#endif + +#endif /* _CONSTR_CHOICE_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/constr_SEQUENCE.c b/projects/stargazer/plugins/other/snmp/asn1/constr_SEQUENCE.c new file mode 100644 index 00000000..b7694343 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/constr_SEQUENCE.c @@ -0,0 +1,1251 @@ +/*- + * Copyright (c) 2003, 2004, 2005, 2006 Lev Walkin . + * All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include + +/* + * Number of bytes left for this structure. + * (ctx->left) indicates the number of bytes _transferred_ for the structure. + * (size) contains the number of bytes in the buffer passed. + */ +#define LEFT ((size<(size_t)ctx->left)?size:(size_t)ctx->left) + +/* + * If the subprocessor function returns with an indication that it wants + * more data, it may well be a fatal decoding problem, because the + * size is constrained by the 's L, even if the buffer size allows + * reading more data. + * For example, consider the buffer containing the following TLVs: + * ... + * The TLV length clearly indicates that one byte is expected in V, but + * if the V processor returns with "want more data" even if the buffer + * contains way more data than the V processor have seen. + */ +#define SIZE_VIOLATION (ctx->left >= 0 && (size_t)ctx->left <= size) + +/* + * This macro "eats" the part of the buffer which is definitely "consumed", + * i.e. was correctly converted into local representation or rightfully skipped. + */ +#undef ADVANCE +#define ADVANCE(num_bytes) do { \ + size_t num = num_bytes; \ + ptr = ((const char *)ptr) + num;\ + size -= num; \ + if(ctx->left >= 0) \ + ctx->left -= num; \ + consumed_myself += num; \ + } while(0) + +/* + * Switch to the next phase of parsing. + */ +#undef NEXT_PHASE +#undef PHASE_OUT +#define NEXT_PHASE(ctx) do { \ + ctx->phase++; \ + ctx->step = 0; \ + } while(0) +#define PHASE_OUT(ctx) do { ctx->phase = 10; } while(0) + +/* + * Return a standardized complex structure. + */ +#undef RETURN +#define RETURN(_code) do { \ + rval.code = _code; \ + rval.consumed = consumed_myself;\ + return rval; \ + } while(0) + +/* + * Check whether we are inside the extensions group. + */ +#define IN_EXTENSION_GROUP(specs, memb_idx) \ + ( ((memb_idx) > (specs)->ext_after) \ + &&((memb_idx) < (specs)->ext_before)) + + +/* + * Tags are canonically sorted in the tag2element map. + */ +static int +_t2e_cmp(const void *ap, const void *bp) { + const asn_TYPE_tag2member_t *a = (const asn_TYPE_tag2member_t *)ap; + const asn_TYPE_tag2member_t *b = (const asn_TYPE_tag2member_t *)bp; + + int a_class = BER_TAG_CLASS(a->el_tag); + int b_class = BER_TAG_CLASS(b->el_tag); + + if(a_class == b_class) { + ber_tlv_tag_t a_value = BER_TAG_VALUE(a->el_tag); + ber_tlv_tag_t b_value = BER_TAG_VALUE(b->el_tag); + + if(a_value == b_value) { + if(a->el_no > b->el_no) + return 1; + /* + * Important: we do not check + * for a->el_no <= b->el_no! + */ + return 0; + } else if(a_value < b_value) + return -1; + else + return 1; + } else if(a_class < b_class) { + return -1; + } else { + return 1; + } +} + + +/* + * The decoder of the SEQUENCE type. + */ +asn_dec_rval_t +SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **struct_ptr, const void *ptr, size_t size, int tag_mode) { + /* + * Bring closer parts of structure description. + */ + asn_SEQUENCE_specifics_t *specs = (asn_SEQUENCE_specifics_t *)td->specifics; + asn_TYPE_member_t *elements = td->elements; + + /* + * Parts of the structure being constructed. + */ + void *st = *struct_ptr; /* Target structure. */ + asn_struct_ctx_t *ctx; /* Decoder context */ + + ber_tlv_tag_t tlv_tag; /* T from TLV */ + asn_dec_rval_t rval; /* Return code from subparsers */ + + ssize_t consumed_myself = 0; /* Consumed bytes from ptr */ + int edx; /* SEQUENCE element's index */ + + ASN_DEBUG("Decoding %s as SEQUENCE", td->name); + + /* + * Create the target structure if it is not present already. + */ + if(st == 0) { + st = *struct_ptr = CALLOC(1, specs->struct_size); + if(st == 0) { + RETURN(RC_FAIL); + } + } + + /* + * Restore parsing context. + */ + ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset); + + /* + * Start to parse where left previously + */ + switch(ctx->phase) { + case 0: + /* + * PHASE 0. + * Check that the set of tags associated with given structure + * perfectly fits our expectations. + */ + + rval = ber_check_tags(opt_codec_ctx, td, ctx, ptr, size, + tag_mode, 1, &ctx->left, 0); + if(rval.code != RC_OK) { + ASN_DEBUG("%s tagging check failed: %d", + td->name, rval.code); + return rval; + } + + if(ctx->left >= 0) + ctx->left += rval.consumed; /* ?Substracted below! */ + ADVANCE(rval.consumed); + + NEXT_PHASE(ctx); + + ASN_DEBUG("Structure consumes %ld bytes, buffer %ld", + (long)ctx->left, (long)size); + + /* Fall through */ + case 1: + /* + * PHASE 1. + * From the place where we've left it previously, + * try to decode the next member from the list of + * this structure's elements. + * (ctx->step) stores the member being processed + * between invocations and the microphase {0,1} of parsing + * that member: + * step = ( * 2 + ). + */ + for(edx = (ctx->step >> 1); edx < td->elements_count; + edx++, ctx->step = (ctx->step & ~1) + 2) { + void *memb_ptr; /* Pointer to the member */ + void **memb_ptr2; /* Pointer to that pointer */ + ssize_t tag_len; /* Length of TLV's T */ + int opt_edx_end; /* Next non-optional element */ + int use_bsearch; + int n; + + if(ctx->step & 1) + goto microphase2; + + /* + * MICROPHASE 1: Synchronize decoding. + */ + ASN_DEBUG("In %s SEQUENCE left %d, edx=%d flags=%d" + " opt=%d ec=%d", + td->name, (int)ctx->left, edx, + elements[edx].flags, elements[edx].optional, + td->elements_count); + + if(ctx->left == 0 /* No more stuff is expected */ + && ( + /* Explicit OPTIONAL specification reaches the end */ + (edx + elements[edx].optional + == td->elements_count) + || + /* All extensions are optional */ + (IN_EXTENSION_GROUP(specs, edx) + && specs->ext_before > td->elements_count) + ) + ) { + ASN_DEBUG("End of SEQUENCE %s", td->name); + /* + * Found the legitimate end of the structure. + */ + PHASE_OUT(ctx); + RETURN(RC_OK); + } + + /* + * Fetch the T from TLV. + */ + tag_len = ber_fetch_tag(ptr, LEFT, &tlv_tag); + ASN_DEBUG("Current tag in %s SEQUENCE for element %d " + "(%s) is %s encoded in %d bytes, of frame %ld", + td->name, edx, elements[edx].name, + ber_tlv_tag_string(tlv_tag), (int)tag_len, (long)LEFT); + switch(tag_len) { + case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE); + /* Fall through */ + case -1: RETURN(RC_FAIL); + } + + if(ctx->left < 0 && ((const uint8_t *)ptr)[0] == 0) { + if(LEFT < 2) { + if(SIZE_VIOLATION) + RETURN(RC_FAIL); + else + RETURN(RC_WMORE); + } else if(((const uint8_t *)ptr)[1] == 0) { + ASN_DEBUG("edx = %d, opt = %d, ec=%d", + edx, elements[edx].optional, + td->elements_count); + if((edx + elements[edx].optional + == td->elements_count) + || (IN_EXTENSION_GROUP(specs, edx) + && specs->ext_before + > td->elements_count)) { + /* + * Yeah, baby! Found the terminator + * of the indefinite length structure. + */ + /* + * Proceed to the canonical + * finalization function. + * No advancing is necessary. + */ + goto phase3; + } + } + } + + /* + * Find the next available type with this tag. + */ + use_bsearch = 0; + opt_edx_end = edx + elements[edx].optional + 1; + if(opt_edx_end > td->elements_count) + opt_edx_end = td->elements_count; /* Cap */ + else if(opt_edx_end - edx > 8) { + /* Limit the scope of linear search... */ + opt_edx_end = edx + 8; + use_bsearch = 1; + /* ... and resort to bsearch() */ + } + for(n = edx; n < opt_edx_end; n++) { + if(BER_TAGS_EQUAL(tlv_tag, elements[n].tag)) { + /* + * Found element corresponding to the tag + * being looked at. + * Reposition over the right element. + */ + edx = n; + ctx->step = 1 + 2 * edx; /* Remember! */ + goto microphase2; + } else if(elements[n].flags & ATF_OPEN_TYPE) { + /* + * This is the ANY type, which may bear + * any flag whatsoever. + */ + edx = n; + ctx->step = 1 + 2 * edx; /* Remember! */ + goto microphase2; + } else if(elements[n].tag == (ber_tlv_tag_t)-1) { + use_bsearch = 1; + break; + } + } + if(use_bsearch) { + /* + * Resort to a binary search over + * sorted array of tags. + */ + asn_TYPE_tag2member_t *t2m; + asn_TYPE_tag2member_t key; + key.el_tag = tlv_tag; + key.el_no = edx; + t2m = (asn_TYPE_tag2member_t *)bsearch(&key, + specs->tag2el, specs->tag2el_count, + sizeof(specs->tag2el[0]), _t2e_cmp); + if(t2m) { + asn_TYPE_tag2member_t *best = 0; + asn_TYPE_tag2member_t *t2m_f, *t2m_l; + int edx_max = edx + elements[edx].optional; + /* + * Rewind to the first element with that tag, + * `cause bsearch() does not guarantee order. + */ + t2m_f = t2m + t2m->toff_first; + t2m_l = t2m + t2m->toff_last; + for(t2m = t2m_f; t2m <= t2m_l; t2m++) { + if(t2m->el_no > edx_max) break; + if(t2m->el_no < edx) continue; + best = t2m; + } + if(best) { + edx = best->el_no; + ctx->step = 1 + 2 * edx; + goto microphase2; + } + } + n = opt_edx_end; + } + if(n == opt_edx_end) { + /* + * If tag is unknown, it may be either + * an unknown (thus, incorrect) tag, + * or an extension (...), + * or an end of the indefinite-length structure. + */ + if(!IN_EXTENSION_GROUP(specs, edx)) { + ASN_DEBUG("Unexpected tag %s (at %d)", + ber_tlv_tag_string(tlv_tag), edx); + ASN_DEBUG("Expected tag %s (%s)%s", + ber_tlv_tag_string(elements[edx].tag), + elements[edx].name, + elements[edx].optional + ?" or alternatives":""); + RETURN(RC_FAIL); + } else { + /* Skip this tag */ + ssize_t skip; + + skip = ber_skip_length(opt_codec_ctx, + BER_TLV_CONSTRUCTED(ptr), + (const char *)ptr + tag_len, + LEFT - tag_len); + ASN_DEBUG("Skip length %d in %s", + (int)skip, td->name); + switch(skip) { + case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE); + /* Fall through */ + case -1: RETURN(RC_FAIL); + } + + ADVANCE(skip + tag_len); + ctx->step -= 2; + edx--; + continue; /* Try again with the next tag */ + } + } + + /* + * MICROPHASE 2: Invoke the member-specific decoder. + */ + ctx->step |= 1; /* Confirm entering next microphase */ + microphase2: + ASN_DEBUG("Inside SEQUENCE %s MF2", td->name); + + /* + * Compute the position of the member inside a structure, + * and also a type of containment (it may be contained + * as pointer or using inline inclusion). + */ + if(elements[edx].flags & ATF_POINTER) { + /* Member is a pointer to another structure */ + memb_ptr2 = (void **)((char *)st + elements[edx].memb_offset); + } else { + /* + * A pointer to a pointer + * holding the start of the structure + */ + memb_ptr = (char *)st + elements[edx].memb_offset; + memb_ptr2 = &memb_ptr; + } + /* + * Invoke the member fetch routine according to member's type + */ + rval = elements[edx].type->ber_decoder(opt_codec_ctx, + elements[edx].type, + memb_ptr2, ptr, LEFT, + elements[edx].tag_mode); + ASN_DEBUG("In %s SEQUENCE decoded %d %s of %d " + "in %d bytes rval.code %d, size=%d", + td->name, edx, elements[edx].type->name, + (int)LEFT, (int)rval.consumed, rval.code, (int)size); + switch(rval.code) { + case RC_OK: + break; + case RC_WMORE: /* More data expected */ + if(!SIZE_VIOLATION) { + ADVANCE(rval.consumed); + RETURN(RC_WMORE); + } + ASN_DEBUG("Size violation (c->l=%ld <= s=%ld)", + (long)ctx->left, (long)size); + /* Fall through */ + case RC_FAIL: /* Fatal error */ + RETURN(RC_FAIL); + } /* switch(rval) */ + + ADVANCE(rval.consumed); + } /* for(all structure members) */ + + phase3: + ctx->phase = 3; + case 3: /* 00 and other tags expected */ + case 4: /* only 00's expected */ + + ASN_DEBUG("SEQUENCE %s Leftover: %ld, size = %ld", + td->name, (long)ctx->left, (long)size); + + /* + * Skip everything until the end of the SEQUENCE. + */ + while(ctx->left) { + ssize_t tl, ll; + + tl = ber_fetch_tag(ptr, LEFT, &tlv_tag); + switch(tl) { + case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE); + /* Fall through */ + case -1: RETURN(RC_FAIL); + } + + /* + * If expected <0><0>... + */ + if(ctx->left < 0 + && ((const uint8_t *)ptr)[0] == 0) { + if(LEFT < 2) { + if(SIZE_VIOLATION) + RETURN(RC_FAIL); + else + RETURN(RC_WMORE); + } else if(((const uint8_t *)ptr)[1] == 0) { + /* + * Correctly finished with <0><0>. + */ + ADVANCE(2); + ctx->left++; + ctx->phase = 4; + continue; + } + } + + if(!IN_EXTENSION_GROUP(specs, td->elements_count) + || ctx->phase == 4) { + ASN_DEBUG("Unexpected continuation " + "of a non-extensible type " + "%s (SEQUENCE): %s", + td->name, + ber_tlv_tag_string(tlv_tag)); + RETURN(RC_FAIL); + } + + ll = ber_skip_length(opt_codec_ctx, + BER_TLV_CONSTRUCTED(ptr), + (const char *)ptr + tl, LEFT - tl); + switch(ll) { + case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE); + /* Fall through */ + case -1: RETURN(RC_FAIL); + } + + ADVANCE(tl + ll); + } + + PHASE_OUT(ctx); + } + + RETURN(RC_OK); +} + + +/* + * The DER encoder of the SEQUENCE type. + */ +asn_enc_rval_t +SEQUENCE_encode_der(asn_TYPE_descriptor_t *td, + void *sptr, int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + size_t computed_size = 0; + asn_enc_rval_t erval; + ssize_t ret; + int edx; + + ASN_DEBUG("%s %s as SEQUENCE", + cb?"Encoding":"Estimating", td->name); + + /* + * Gather the length of the underlying members sequence. + */ + for(edx = 0; edx < td->elements_count; edx++) { + asn_TYPE_member_t *elm = &td->elements[edx]; + void *memb_ptr; + if(elm->flags & ATF_POINTER) { + memb_ptr = *(void **)((char *)sptr + elm->memb_offset); + if(!memb_ptr) { + if(elm->optional) continue; + /* Mandatory element is missing */ + _ASN_ENCODE_FAILED; + } + } else { + memb_ptr = (void *)((char *)sptr + elm->memb_offset); + } + erval = elm->type->der_encoder(elm->type, memb_ptr, + elm->tag_mode, elm->tag, + 0, 0); + if(erval.encoded == -1) + return erval; + computed_size += erval.encoded; + ASN_DEBUG("Member %d %s estimated %ld bytes", + edx, elm->name, (long)erval.encoded); + } + + /* + * Encode the TLV for the sequence itself. + */ + ret = der_write_tags(td, computed_size, tag_mode, 1, tag, cb, app_key); + ASN_DEBUG("Wrote tags: %ld (+%ld)", (long)ret, (long)computed_size); + if(ret == -1) + _ASN_ENCODE_FAILED; + erval.encoded = computed_size + ret; + + if(!cb) _ASN_ENCODED_OK(erval); + + /* + * Encode all members. + */ + for(edx = 0; edx < td->elements_count; edx++) { + asn_TYPE_member_t *elm = &td->elements[edx]; + asn_enc_rval_t tmperval; + void *memb_ptr; + + if(elm->flags & ATF_POINTER) { + memb_ptr = *(void **)((char *)sptr + elm->memb_offset); + if(!memb_ptr) continue; + } else { + memb_ptr = (void *)((char *)sptr + elm->memb_offset); + } + tmperval = elm->type->der_encoder(elm->type, memb_ptr, + elm->tag_mode, elm->tag, + cb, app_key); + if(tmperval.encoded == -1) + return tmperval; + computed_size -= tmperval.encoded; + ASN_DEBUG("Member %d %s of SEQUENCE %s encoded in %ld bytes", + edx, elm->name, td->name, (long)tmperval.encoded); + } + + if(computed_size != 0) + /* + * Encoded size is not equal to the computed size. + */ + _ASN_ENCODE_FAILED; + + _ASN_ENCODED_OK(erval); +} + + +#undef XER_ADVANCE +#define XER_ADVANCE(num_bytes) do { \ + size_t num = num_bytes; \ + buf_ptr = ((const char *)buf_ptr) + num;\ + size -= num; \ + consumed_myself += num; \ + } while(0) + +/* + * Decode the XER (XML) data. + */ +asn_dec_rval_t +SEQUENCE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **struct_ptr, const char *opt_mname, + const void *buf_ptr, size_t size) { + /* + * Bring closer parts of structure description. + */ + asn_SEQUENCE_specifics_t *specs + = (asn_SEQUENCE_specifics_t *)td->specifics; + asn_TYPE_member_t *elements = td->elements; + const char *xml_tag = opt_mname ? opt_mname : td->xml_tag; + + /* + * ... and parts of the structure being constructed. + */ + void *st = *struct_ptr; /* Target structure. */ + asn_struct_ctx_t *ctx; /* Decoder context */ + + asn_dec_rval_t rval; /* Return value from a decoder */ + ssize_t consumed_myself = 0; /* Consumed bytes from ptr */ + int edx; /* Element index */ + int edx_end; + + /* + * Create the target structure if it is not present already. + */ + if(st == 0) { + st = *struct_ptr = CALLOC(1, specs->struct_size); + if(st == 0) RETURN(RC_FAIL); + } + + /* + * Restore parsing context. + */ + ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset); + + + /* + * Phases of XER/XML processing: + * Phase 0: Check that the opening tag matches our expectations. + * Phase 1: Processing body and reacting on closing tag. + * Phase 2: Processing inner type. + * Phase 3: Skipping unknown extensions. + * Phase 4: PHASED OUT + */ + for(edx = ctx->step; ctx->phase <= 3;) { + pxer_chunk_type_e ch_type; /* XER chunk type */ + ssize_t ch_size; /* Chunk size */ + xer_check_tag_e tcv; /* Tag check value */ + asn_TYPE_member_t *elm; + int n; + + /* + * Go inside the inner member of a sequence. + */ + if(ctx->phase == 2) { + asn_dec_rval_t tmprval; + void *memb_ptr; /* Pointer to the member */ + void **memb_ptr2; /* Pointer to that pointer */ + + elm = &td->elements[edx]; + + if(elm->flags & ATF_POINTER) { + /* Member is a pointer to another structure */ + memb_ptr2 = (void **)((char *)st + + elm->memb_offset); + } else { + memb_ptr = (char *)st + elm->memb_offset; + memb_ptr2 = &memb_ptr; + } + + /* Invoke the inner type decoder, m.b. multiple times */ + tmprval = elm->type->xer_decoder(opt_codec_ctx, + elm->type, memb_ptr2, elm->name, + buf_ptr, size); + XER_ADVANCE(tmprval.consumed); + if(tmprval.code != RC_OK) + RETURN(tmprval.code); + ctx->phase = 1; /* Back to body processing */ + ctx->step = ++edx; + ASN_DEBUG("XER/SEQUENCE phase => %d, step => %d", + ctx->phase, ctx->step); + /* Fall through */ + } + + /* + * Get the next part of the XML stream. + */ + ch_size = xer_next_token(&ctx->context, buf_ptr, size, + &ch_type); + switch(ch_size) { + case -1: RETURN(RC_FAIL); + case 0: RETURN(RC_WMORE); + default: + switch(ch_type) { + case PXER_COMMENT: /* Got XML comment */ + case PXER_TEXT: /* Ignore free-standing text */ + XER_ADVANCE(ch_size); /* Skip silently */ + continue; + case PXER_TAG: + break; /* Check the rest down there */ + } + } + + tcv = xer_check_tag(buf_ptr, ch_size, xml_tag); + ASN_DEBUG("XER/SEQUENCE: tcv = %d, ph=%d [%s]", + tcv, ctx->phase, xml_tag); + + /* Skip the extensions section */ + if(ctx->phase == 3) { + switch(xer_skip_unknown(tcv, &ctx->left)) { + case -1: + ctx->phase = 4; + RETURN(RC_FAIL); + case 0: + XER_ADVANCE(ch_size); + continue; + case 1: + XER_ADVANCE(ch_size); + ctx->phase = 1; + continue; + case 2: + ctx->phase = 1; + break; + } + } + + switch(tcv) { + case XCT_CLOSING: + if(ctx->phase == 0) break; + ctx->phase = 0; + /* Fall through */ + case XCT_BOTH: + if(ctx->phase == 0) { + if(edx >= td->elements_count + || + /* Explicit OPTIONAL specs reaches the end */ + (edx + elements[edx].optional + == td->elements_count) + || + /* All extensions are optional */ + (IN_EXTENSION_GROUP(specs, edx) + && specs->ext_before + > td->elements_count) + ) { + XER_ADVANCE(ch_size); + ctx->phase = 4; /* Phase out */ + RETURN(RC_OK); + } else { + ASN_DEBUG("Premature end of XER SEQUENCE"); + RETURN(RC_FAIL); + } + } + /* Fall through */ + case XCT_OPENING: + if(ctx->phase == 0) { + XER_ADVANCE(ch_size); + ctx->phase = 1; /* Processing body phase */ + continue; + } + /* Fall through */ + case XCT_UNKNOWN_OP: + case XCT_UNKNOWN_BO: + + ASN_DEBUG("XER/SEQUENCE: tcv=%d, ph=%d, edx=%d", + tcv, ctx->phase, edx); + if(ctx->phase != 1) { + break; /* Really unexpected */ + } + + if(edx < td->elements_count) { + /* + * Search which member corresponds to this tag. + */ + edx_end = edx + elements[edx].optional + 1; + if(edx_end > td->elements_count) + edx_end = td->elements_count; + for(n = edx; n < edx_end; n++) { + elm = &td->elements[n]; + tcv = xer_check_tag(buf_ptr, + ch_size, elm->name); + switch(tcv) { + case XCT_BOTH: + case XCT_OPENING: + /* + * Process this member. + */ + ctx->step = edx = n; + ctx->phase = 2; + break; + case XCT_UNKNOWN_OP: + case XCT_UNKNOWN_BO: + continue; + default: + n = edx_end; + break; /* Phase out */ + } + break; + } + if(n != edx_end) + continue; + } else { + ASN_DEBUG("Out of defined members: %d/%d", + edx, td->elements_count); + } + + /* It is expected extension */ + if(IN_EXTENSION_GROUP(specs, + edx + (edx < td->elements_count + ? elements[edx].optional : 0))) { + ASN_DEBUG("Got anticipated extension at %d", + edx); + /* + * Check for (XCT_BOTH or XCT_UNKNOWN_BO) + * By using a mask. Only record a pure + * tags. + */ + if(tcv & XCT_CLOSING) { + /* Found without body */ + } else { + ctx->left = 1; + ctx->phase = 3; /* Skip ...'s */ + } + XER_ADVANCE(ch_size); + continue; + } + + /* Fall through */ + default: + break; + } + + ASN_DEBUG("Unexpected XML tag in SEQUENCE [%c%c%c%c%c%c]", + size>0?((const char *)buf_ptr)[0]:'.', + size>1?((const char *)buf_ptr)[1]:'.', + size>2?((const char *)buf_ptr)[2]:'.', + size>3?((const char *)buf_ptr)[3]:'.', + size>4?((const char *)buf_ptr)[4]:'.', + size>5?((const char *)buf_ptr)[5]:'.'); + break; + } + + ctx->phase = 4; /* "Phase out" on hard failure */ + RETURN(RC_FAIL); +} + +asn_enc_rval_t +SEQUENCE_encode_xer(asn_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + asn_enc_rval_t er; + int xcan = (flags & XER_F_CANONICAL); + int edx; + + if(!sptr) + _ASN_ENCODE_FAILED; + + er.encoded = 0; + + for(edx = 0; edx < td->elements_count; edx++) { + asn_enc_rval_t tmper; + asn_TYPE_member_t *elm = &td->elements[edx]; + void *memb_ptr; + const char *mname = elm->name; + unsigned int mlen = strlen(mname); + + if(elm->flags & ATF_POINTER) { + memb_ptr = *(void **)((char *)sptr + elm->memb_offset); + if(!memb_ptr) { + if(elm->optional) + continue; + /* Mandatory element is missing */ + _ASN_ENCODE_FAILED; + } + } else { + memb_ptr = (void *)((char *)sptr + elm->memb_offset); + } + + if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel); + _ASN_CALLBACK3("<", 1, mname, mlen, ">", 1); + + /* Print the member itself */ + tmper = elm->type->xer_encoder(elm->type, memb_ptr, + ilevel + 1, flags, cb, app_key); + if(tmper.encoded == -1) return tmper; + + _ASN_CALLBACK3("", 1); + er.encoded += 5 + (2 * mlen) + tmper.encoded; + } + + if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel - 1); + + _ASN_ENCODED_OK(er); +cb_failed: + _ASN_ENCODE_FAILED; +} + +int +SEQUENCE_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel, + asn_app_consume_bytes_f *cb, void *app_key) { + int edx; + int ret; + + if(!sptr) return (cb("", 8, app_key) < 0) ? -1 : 0; + + /* Dump preamble */ + if(cb(td->name, strlen(td->name), app_key) < 0 + || cb(" ::= {", 6, app_key) < 0) + return -1; + + for(edx = 0; edx < td->elements_count; edx++) { + asn_TYPE_member_t *elm = &td->elements[edx]; + const void *memb_ptr; + + if(elm->flags & ATF_POINTER) { + memb_ptr = *(const void * const *)((const char *)sptr + elm->memb_offset); + if(!memb_ptr) { + if(elm->optional) continue; + /* Print line */ + /* Fall through */ + } + } else { + memb_ptr = (const void *)((const char *)sptr + elm->memb_offset); + } + + /* Indentation */ + _i_INDENT(1); + + /* Print the member's name and stuff */ + if(cb(elm->name, strlen(elm->name), app_key) < 0 + || cb(": ", 2, app_key) < 0) + return -1; + + /* Print the member itself */ + ret = elm->type->print_struct(elm->type, memb_ptr, ilevel + 1, + cb, app_key); + if(ret) return ret; + } + + ilevel--; + _i_INDENT(1); + + return (cb("}", 1, app_key) < 0) ? -1 : 0; +} + +void +SEQUENCE_free(asn_TYPE_descriptor_t *td, void *sptr, int contents_only) { + int edx; + + if(!td || !sptr) + return; + + ASN_DEBUG("Freeing %s as SEQUENCE", td->name); + + for(edx = 0; edx < td->elements_count; edx++) { + asn_TYPE_member_t *elm = &td->elements[edx]; + void *memb_ptr; + if(elm->flags & ATF_POINTER) { + memb_ptr = *(void **)((char *)sptr + elm->memb_offset); + if(memb_ptr) + ASN_STRUCT_FREE(*elm->type, memb_ptr); + } else { + memb_ptr = (void *)((char *)sptr + elm->memb_offset); + ASN_STRUCT_FREE_CONTENTS_ONLY(*elm->type, memb_ptr); + } + } + + if(!contents_only) { + FREEMEM(sptr); + } +} + +int +SEQUENCE_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + int edx; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + /* + * Iterate over structure members and check their validity. + */ + for(edx = 0; edx < td->elements_count; edx++) { + asn_TYPE_member_t *elm = &td->elements[edx]; + const void *memb_ptr; + + if(elm->flags & ATF_POINTER) { + memb_ptr = *(const void * const *)((const char *)sptr + elm->memb_offset); + if(!memb_ptr) { + if(elm->optional) + continue; + _ASN_CTFAIL(app_key, td, + "%s: mandatory element %s absent (%s:%d)", + td->name, elm->name, __FILE__, __LINE__); + return -1; + } + } else { + memb_ptr = (const void *)((const char *)sptr + elm->memb_offset); + } + + if(elm->memb_constraints) { + int ret = elm->memb_constraints(elm->type, memb_ptr, + ctfailcb, app_key); + if(ret) return ret; + } else { + int ret = elm->type->check_constraints(elm->type, + memb_ptr, ctfailcb, app_key); + if(ret) return ret; + /* + * Cannot inherit it earlier: + * need to make sure we get the updated version. + */ + elm->memb_constraints = elm->type->check_constraints; + } + } + + return 0; +} + +asn_dec_rval_t +SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) { + asn_SEQUENCE_specifics_t *specs = (asn_SEQUENCE_specifics_t *)td->specifics; + void *st = *sptr; /* Target structure. */ + int extpresent = 0; /* Extension additions are present */ + uint8_t *opres; /* Presence of optional root members */ + asn_per_data_t opmd; + asn_dec_rval_t rv; + int edx; + + (void)constraints; + + if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx)) + _ASN_DECODE_FAILED; + + if(!st) { + st = *sptr = CALLOC(1, specs->struct_size); + if(!st) _ASN_DECODE_FAILED; + } + + ASN_DEBUG("Decoding %s as SEQUENCE (UPER)", td->name); + + /* Handle extensions */ + if(specs->ext_before >= 0) { + extpresent = per_get_few_bits(pd, 1); + if(extpresent < 0) _ASN_DECODE_STARVED; + } + + /* Prepare a place and read-in the presence bitmap */ + if(specs->roms_count) { + opres = (uint8_t *)MALLOC(((specs->roms_count + 7) >> 3) + 1); + if(!opres) _ASN_DECODE_FAILED; + /* Get the presence map */ + if(per_get_many_bits(pd, opres, 0, specs->roms_count)) { + FREEMEM(opres); + _ASN_DECODE_STARVED; + } + opmd.buffer = opres; + opmd.nboff = 0; + opmd.nbits = specs->roms_count; + ASN_DEBUG("Read in presence bitmap for %s of %d bits (%x..)", + td->name, specs->roms_count, *opres); + } else { + opres = 0; + memset(&opmd, 0, sizeof opmd); + } + + /* + * Get the sequence ROOT elements. + */ + for(edx = 0; edx < ((specs->ext_before < 0) + ? td->elements_count : specs->ext_before + 1); edx++) { + asn_TYPE_member_t *elm = &td->elements[edx]; + void *memb_ptr; /* Pointer to the member */ + void **memb_ptr2; /* Pointer to that pointer */ + + /* Fetch the pointer to this member */ + if(elm->flags & ATF_POINTER) { + memb_ptr2 = (void **)((char *)st + elm->memb_offset); + } else { + memb_ptr = (char *)st + elm->memb_offset; + memb_ptr2 = &memb_ptr; + } + + /* Deal with optionality */ + if(elm->optional) { + int present = per_get_few_bits(&opmd, 1); + ASN_DEBUG("Member %s->%s is optional, p=%d (%d->%d)", + td->name, elm->name, present, + (int)opmd.nboff, (int)opmd.nbits); + if(present == 0) { + /* This element is not present */ + if(elm->default_value) { + /* Fill-in DEFAULT */ + if(elm->default_value(1, memb_ptr2)) { + FREEMEM(opres); + _ASN_DECODE_FAILED; + } + } + /* The member is just not present */ + continue; + } + /* Fall through */ + } + + /* Fetch the member from the stream */ + ASN_DEBUG("Decoding member %s in %s", elm->name, td->name); + rv = elm->type->uper_decoder(opt_codec_ctx, elm->type, + elm->per_constraints, memb_ptr2, pd); + if(rv.code != RC_OK) { + ASN_DEBUG("Failed decode %s in %s", + elm->name, td->name); + FREEMEM(opres); + return rv; + } + } + + /* + * Deal with extensions. + */ + if(extpresent) { + ASN_DEBUG("Extensibility for %s: NOT IMPLEMENTED", td->name); + _ASN_DECODE_FAILED; + } else { + for(edx = specs->roms_count; edx < specs->roms_count + + specs->aoms_count; edx++) { + asn_TYPE_member_t *elm = &td->elements[edx]; + void *memb_ptr; /* Pointer to the member */ + void **memb_ptr2; /* Pointer to that pointer */ + + if(!elm->default_value) continue; + + /* Fetch the pointer to this member */ + if(elm->flags & ATF_POINTER) { + memb_ptr2 = (void **)((char *)st + + elm->memb_offset); + } else { + memb_ptr = (char *)st + elm->memb_offset; + memb_ptr2 = &memb_ptr; + } + + /* Set default value */ + if(elm->default_value(1, memb_ptr2)) { + FREEMEM(opres); + _ASN_DECODE_FAILED; + } + } + } + + rv.consumed = 0; + rv.code = RC_OK; + FREEMEM(opres); + return rv; +} + +asn_enc_rval_t +SEQUENCE_encode_uper(asn_TYPE_descriptor_t *td, + asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) { + asn_SEQUENCE_specifics_t *specs + = (asn_SEQUENCE_specifics_t *)td->specifics; + asn_enc_rval_t er; + int edx; + int i; + + (void)constraints; + + if(!sptr) + _ASN_ENCODE_FAILED; + + er.encoded = 0; + + ASN_DEBUG("Encoding %s as SEQUENCE (UPER)", td->name); + if(specs->ext_before >= 0) + _ASN_ENCODE_FAILED; /* We don't encode extensions yet */ + + /* Encode a presence bitmap */ + for(i = 0; i < specs->roms_count; i++) { + asn_TYPE_member_t *elm; + void *memb_ptr; /* Pointer to the member */ + void **memb_ptr2; /* Pointer to that pointer */ + int present; + + edx = specs->oms[i]; + elm = &td->elements[edx]; + + /* Fetch the pointer to this member */ + if(elm->flags & ATF_POINTER) { + memb_ptr2 = (void **)((char *)sptr + elm->memb_offset); + present = (*memb_ptr2 != 0); + } else { + memb_ptr = (void *)((char *)sptr + elm->memb_offset); + memb_ptr2 = &memb_ptr; + present = 1; + } + + /* Eliminate default values */ + if(present && elm->default_value + && elm->default_value(0, memb_ptr2) == 1) + present = 0; + + ASN_DEBUG("Element %s %s %s->%s is %s", + elm->flags & ATF_POINTER ? "ptr" : "inline", + elm->default_value ? "def" : "wtv", + td->name, elm->name, present ? "present" : "absent"); + if(per_put_few_bits(po, present, 1)) + _ASN_ENCODE_FAILED; + } + + /* + * Get the sequence ROOT elements. + */ + for(edx = 0; edx < ((specs->ext_before < 0) + ? td->elements_count : specs->ext_before + 1); edx++) { + asn_TYPE_member_t *elm = &td->elements[edx]; + void *memb_ptr; /* Pointer to the member */ + void **memb_ptr2; /* Pointer to that pointer */ + + /* Fetch the pointer to this member */ + if(elm->flags & ATF_POINTER) { + memb_ptr2 = (void **)((char *)sptr + elm->memb_offset); + if(!*memb_ptr2) { + ASN_DEBUG("Element %s %d not present", + elm->name, edx); + if(elm->optional) + continue; + /* Mandatory element is missing */ + _ASN_ENCODE_FAILED; + } + } else { + memb_ptr = (void *)((char *)sptr + elm->memb_offset); + memb_ptr2 = &memb_ptr; + } + + /* Eliminate default values */ + if(elm->default_value && elm->default_value(0, memb_ptr2) == 1) + continue; + + er = elm->type->uper_encoder(elm->type, elm->per_constraints, + *memb_ptr2, po); + if(er.encoded == -1) + return er; + } + + _ASN_ENCODED_OK(er); +} + diff --git a/projects/stargazer/plugins/other/snmp/asn1/constr_SEQUENCE.h b/projects/stargazer/plugins/other/snmp/asn1/constr_SEQUENCE.h new file mode 100644 index 00000000..5f589d5c --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/constr_SEQUENCE.h @@ -0,0 +1,60 @@ +/*- + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _CONSTR_SEQUENCE_H_ +#define _CONSTR_SEQUENCE_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct asn_SEQUENCE_specifics_s { + /* + * Target structure description. + */ + int struct_size; /* Size of the target structure. */ + int ctx_offset; /* Offset of the asn_struct_ctx_t member */ + + /* + * Tags to members mapping table (sorted). + */ + asn_TYPE_tag2member_t *tag2el; + int tag2el_count; + + /* + * Optional members of the extensions root (roms) or additions (aoms). + * Meaningful for PER. + */ + int *oms; /* Optional MemberS */ + int roms_count; /* Root optional members count */ + int aoms_count; /* Additions optional members count */ + + /* + * Description of an extensions group. + */ + int ext_after; /* Extensions start after this member */ + int ext_before; /* Extensions stop before this member */ +} asn_SEQUENCE_specifics_t; + + +/* + * A set specialized functions dealing with the SEQUENCE type. + */ +asn_struct_free_f SEQUENCE_free; +asn_struct_print_f SEQUENCE_print; +asn_constr_check_f SEQUENCE_constraint; +ber_type_decoder_f SEQUENCE_decode_ber; +der_type_encoder_f SEQUENCE_encode_der; +xer_type_decoder_f SEQUENCE_decode_xer; +xer_type_encoder_f SEQUENCE_encode_xer; +per_type_decoder_f SEQUENCE_decode_uper; +per_type_encoder_f SEQUENCE_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _CONSTR_SEQUENCE_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/constr_SEQUENCE_OF.c b/projects/stargazer/plugins/other/snmp/asn1/constr_SEQUENCE_OF.c new file mode 100644 index 00000000..aa101176 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/constr_SEQUENCE_OF.c @@ -0,0 +1,208 @@ +/*- + * Copyright (c) 2003, 2004, 2006 Lev Walkin . + * All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include +#include + +/* + * The DER encoder of the SEQUENCE OF type. + */ +asn_enc_rval_t +SEQUENCE_OF_encode_der(asn_TYPE_descriptor_t *td, void *ptr, + int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + asn_TYPE_member_t *elm = td->elements; + asn_anonymous_sequence_ *list = _A_SEQUENCE_FROM_VOID(ptr); + size_t computed_size = 0; + ssize_t encoding_size = 0; + asn_enc_rval_t erval; + int edx; + + ASN_DEBUG("Estimating size of SEQUENCE OF %s", td->name); + + /* + * Gather the length of the underlying members sequence. + */ + for(edx = 0; edx < list->count; edx++) { + void *memb_ptr = list->array[edx]; + if(!memb_ptr) continue; + erval = elm->type->der_encoder(elm->type, memb_ptr, + 0, elm->tag, + 0, 0); + if(erval.encoded == -1) + return erval; + computed_size += erval.encoded; + } + + /* + * Encode the TLV for the sequence itself. + */ + encoding_size = der_write_tags(td, computed_size, tag_mode, 1, tag, + cb, app_key); + if(encoding_size == -1) { + erval.encoded = -1; + erval.failed_type = td; + erval.structure_ptr = ptr; + return erval; + } + + computed_size += encoding_size; + if(!cb) { + erval.encoded = computed_size; + _ASN_ENCODED_OK(erval); + } + + ASN_DEBUG("Encoding members of SEQUENCE OF %s", td->name); + + /* + * Encode all members. + */ + for(edx = 0; edx < list->count; edx++) { + void *memb_ptr = list->array[edx]; + if(!memb_ptr) continue; + erval = elm->type->der_encoder(elm->type, memb_ptr, + 0, elm->tag, + cb, app_key); + if(erval.encoded == -1) + return erval; + encoding_size += erval.encoded; + } + + if(computed_size != (size_t)encoding_size) { + /* + * Encoded size is not equal to the computed size. + */ + erval.encoded = -1; + erval.failed_type = td; + erval.structure_ptr = ptr; + } else { + erval.encoded = computed_size; + erval.structure_ptr = 0; + erval.failed_type = 0; + } + + return erval; +} + +asn_enc_rval_t +SEQUENCE_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + asn_enc_rval_t er; + asn_SET_OF_specifics_t *specs = (asn_SET_OF_specifics_t *)td->specifics; + asn_TYPE_member_t *elm = td->elements; + asn_anonymous_sequence_ *list = _A_SEQUENCE_FROM_VOID(sptr); + const char *mname = specs->as_XMLValueList + ? 0 : ((*elm->name) ? elm->name : elm->type->xml_tag); + unsigned int mlen = mname ? strlen(mname) : 0; + int xcan = (flags & XER_F_CANONICAL); + int i; + + if(!sptr) _ASN_ENCODE_FAILED; + + er.encoded = 0; + + for(i = 0; i < list->count; i++) { + asn_enc_rval_t tmper; + void *memb_ptr = list->array[i]; + if(!memb_ptr) continue; + + if(mname) { + if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel); + _ASN_CALLBACK3("<", 1, mname, mlen, ">", 1); + } + + tmper = elm->type->xer_encoder(elm->type, memb_ptr, + ilevel + 1, flags, cb, app_key); + if(tmper.encoded == -1) return tmper; + if(tmper.encoded == 0 && specs->as_XMLValueList) { + const char *name = elm->type->xml_tag; + size_t len = strlen(name); + if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel + 1); + _ASN_CALLBACK3("<", 1, name, len, "/>", 2); + } + + if(mname) { + _ASN_CALLBACK3("", 1); + er.encoded += 5; + } + + er.encoded += (2 * mlen) + tmper.encoded; + } + + if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel - 1); + + _ASN_ENCODED_OK(er); +cb_failed: + _ASN_ENCODE_FAILED; +} + +asn_enc_rval_t +SEQUENCE_OF_encode_uper(asn_TYPE_descriptor_t *td, + asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) { + asn_anonymous_sequence_ *list; + asn_per_constraint_t *ct; + asn_enc_rval_t er; + asn_TYPE_member_t *elm = td->elements; + int seq; + + if(!sptr) _ASN_ENCODE_FAILED; + list = _A_SEQUENCE_FROM_VOID(sptr); + + er.encoded = 0; + + ASN_DEBUG("Encoding %s as SEQUENCE OF (%d)", td->name, list->count); + + if(constraints) ct = &constraints->size; + else if(td->per_constraints) ct = &td->per_constraints->size; + else ct = 0; + + /* If extensible constraint, check if size is in root */ + if(ct) { + int not_in_root = (list->count < ct->lower_bound + || list->count > ct->upper_bound); + ASN_DEBUG("lb %ld ub %ld %s", + ct->lower_bound, ct->upper_bound, + ct->flags & APC_EXTENSIBLE ? "ext" : "fix"); + if(ct->flags & APC_EXTENSIBLE) { + /* Declare whether size is in extension root */ + if(per_put_few_bits(po, not_in_root, 1)) + _ASN_ENCODE_FAILED; + if(not_in_root) ct = 0; + } else if(not_in_root && ct->effective_bits >= 0) + _ASN_ENCODE_FAILED; + } + + if(ct && ct->effective_bits >= 0) { + /* X.691, #19.5: No length determinant */ + if(per_put_few_bits(po, list->count - ct->lower_bound, + ct->effective_bits)) + _ASN_ENCODE_FAILED; + } + + for(seq = -1; seq < list->count;) { + ssize_t mayEncode; + if(seq < 0) seq = 0; + if(ct && ct->effective_bits >= 0) { + mayEncode = list->count; + } else { + mayEncode = uper_put_length(po, list->count - seq); + if(mayEncode < 0) _ASN_ENCODE_FAILED; + } + + while(mayEncode--) { + void *memb_ptr = list->array[seq++]; + if(!memb_ptr) _ASN_ENCODE_FAILED; + er = elm->type->uper_encoder(elm->type, + elm->per_constraints, memb_ptr, po); + if(er.encoded == -1) + _ASN_ENCODE_FAILED; + } + } + + _ASN_ENCODED_OK(er); +} + diff --git a/projects/stargazer/plugins/other/snmp/asn1/constr_SEQUENCE_OF.h b/projects/stargazer/plugins/other/snmp/asn1/constr_SEQUENCE_OF.h new file mode 100644 index 00000000..e2272f32 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/constr_SEQUENCE_OF.h @@ -0,0 +1,33 @@ +/*- + * Copyright (c) 2003, 2005 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _CONSTR_SEQUENCE_OF_H_ +#define _CONSTR_SEQUENCE_OF_H_ + +#include +#include /* Implemented using SET OF */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * A set specialized functions dealing with the SEQUENCE OF type. + * Generally implemented using SET OF. + */ +#define SEQUENCE_OF_free SET_OF_free +#define SEQUENCE_OF_print SET_OF_print +#define SEQUENCE_OF_constraint SET_OF_constraint +#define SEQUENCE_OF_decode_ber SET_OF_decode_ber +#define SEQUENCE_OF_decode_xer SET_OF_decode_xer +#define SEQUENCE_OF_decode_uper SET_OF_decode_uper +der_type_encoder_f SEQUENCE_OF_encode_der; +xer_type_encoder_f SEQUENCE_OF_encode_xer; +per_type_encoder_f SEQUENCE_OF_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _CONSTR_SET_OF_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/constr_SET_OF.c b/projects/stargazer/plugins/other/snmp/asn1/constr_SET_OF.c new file mode 100644 index 00000000..09f27db5 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/constr_SET_OF.c @@ -0,0 +1,942 @@ +/*- + * Copyright (c) 2003, 2004, 2005 Lev Walkin . + * All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include +#include + +/* + * Number of bytes left for this structure. + * (ctx->left) indicates the number of bytes _transferred_ for the structure. + * (size) contains the number of bytes in the buffer passed. + */ +#define LEFT ((size<(size_t)ctx->left)?size:(size_t)ctx->left) + +/* + * If the subprocessor function returns with an indication that it wants + * more data, it may well be a fatal decoding problem, because the + * size is constrained by the 's L, even if the buffer size allows + * reading more data. + * For example, consider the buffer containing the following TLVs: + * ... + * The TLV length clearly indicates that one byte is expected in V, but + * if the V processor returns with "want more data" even if the buffer + * contains way more data than the V processor have seen. + */ +#define SIZE_VIOLATION (ctx->left >= 0 && (size_t)ctx->left <= size) + +/* + * This macro "eats" the part of the buffer which is definitely "consumed", + * i.e. was correctly converted into local representation or rightfully skipped. + */ +#undef ADVANCE +#define ADVANCE(num_bytes) do { \ + size_t num = num_bytes; \ + ptr = ((const char *)ptr) + num;\ + size -= num; \ + if(ctx->left >= 0) \ + ctx->left -= num; \ + consumed_myself += num; \ + } while(0) + +/* + * Switch to the next phase of parsing. + */ +#undef NEXT_PHASE +#undef PHASE_OUT +#define NEXT_PHASE(ctx) do { \ + ctx->phase++; \ + ctx->step = 0; \ + } while(0) +#define PHASE_OUT(ctx) do { ctx->phase = 10; } while(0) + +/* + * Return a standardized complex structure. + */ +#undef RETURN +#define RETURN(_code) do { \ + rval.code = _code; \ + rval.consumed = consumed_myself;\ + return rval; \ + } while(0) + +/* + * The decoder of the SET OF type. + */ +asn_dec_rval_t +SET_OF_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **struct_ptr, const void *ptr, size_t size, int tag_mode) { + /* + * Bring closer parts of structure description. + */ + asn_SET_OF_specifics_t *specs = (asn_SET_OF_specifics_t *)td->specifics; + asn_TYPE_member_t *elm = td->elements; /* Single one */ + + /* + * Parts of the structure being constructed. + */ + void *st = *struct_ptr; /* Target structure. */ + asn_struct_ctx_t *ctx; /* Decoder context */ + + ber_tlv_tag_t tlv_tag; /* T from TLV */ + asn_dec_rval_t rval; /* Return code from subparsers */ + + ssize_t consumed_myself = 0; /* Consumed bytes from ptr */ + + ASN_DEBUG("Decoding %s as SET OF", td->name); + + /* + * Create the target structure if it is not present already. + */ + if(st == 0) { + st = *struct_ptr = CALLOC(1, specs->struct_size); + if(st == 0) { + RETURN(RC_FAIL); + } + } + + /* + * Restore parsing context. + */ + ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset); + + /* + * Start to parse where left previously + */ + switch(ctx->phase) { + case 0: + /* + * PHASE 0. + * Check that the set of tags associated with given structure + * perfectly fits our expectations. + */ + + rval = ber_check_tags(opt_codec_ctx, td, ctx, ptr, size, + tag_mode, 1, &ctx->left, 0); + if(rval.code != RC_OK) { + ASN_DEBUG("%s tagging check failed: %d", + td->name, rval.code); + return rval; + } + + if(ctx->left >= 0) + ctx->left += rval.consumed; /* ?Substracted below! */ + ADVANCE(rval.consumed); + + ASN_DEBUG("Structure consumes %ld bytes, " + "buffer %ld", (long)ctx->left, (long)size); + + NEXT_PHASE(ctx); + /* Fall through */ + case 1: + /* + * PHASE 1. + * From the place where we've left it previously, + * try to decode the next item. + */ + for(;; ctx->step = 0) { + ssize_t tag_len; /* Length of TLV's T */ + + if(ctx->step & 1) + goto microphase2; + + /* + * MICROPHASE 1: Synchronize decoding. + */ + + if(ctx->left == 0) { + ASN_DEBUG("End of SET OF %s", td->name); + /* + * No more things to decode. + * Exit out of here. + */ + PHASE_OUT(ctx); + RETURN(RC_OK); + } + + /* + * Fetch the T from TLV. + */ + tag_len = ber_fetch_tag(ptr, LEFT, &tlv_tag); + switch(tag_len) { + case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE); + /* Fall through */ + case -1: RETURN(RC_FAIL); + } + + if(ctx->left < 0 && ((const uint8_t *)ptr)[0] == 0) { + if(LEFT < 2) { + if(SIZE_VIOLATION) + RETURN(RC_FAIL); + else + RETURN(RC_WMORE); + } else if(((const uint8_t *)ptr)[1] == 0) { + /* + * Found the terminator of the + * indefinite length structure. + */ + break; + } + } + + /* Outmost tag may be unknown and cannot be fetched/compared */ + if(elm->tag != (ber_tlv_tag_t)-1) { + if(BER_TAGS_EQUAL(tlv_tag, elm->tag)) { + /* + * The new list member of expected type has arrived. + */ + } else { + ASN_DEBUG("Unexpected tag %s fixed SET OF %s", + ber_tlv_tag_string(tlv_tag), td->name); + ASN_DEBUG("%s SET OF has tag %s", + td->name, ber_tlv_tag_string(elm->tag)); + RETURN(RC_FAIL); + } + } + + /* + * MICROPHASE 2: Invoke the member-specific decoder. + */ + ctx->step |= 1; /* Confirm entering next microphase */ + microphase2: + + /* + * Invoke the member fetch routine according to member's type + */ + rval = elm->type->ber_decoder(opt_codec_ctx, + elm->type, &ctx->ptr, ptr, LEFT, 0); + ASN_DEBUG("In %s SET OF %s code %d consumed %d", + td->name, elm->type->name, + rval.code, (int)rval.consumed); + switch(rval.code) { + case RC_OK: + { + asn_anonymous_set_ *list = _A_SET_FROM_VOID(st); + if(ASN_SET_ADD(list, ctx->ptr) != 0) + RETURN(RC_FAIL); + else + ctx->ptr = 0; + } + break; + case RC_WMORE: /* More data expected */ + if(!SIZE_VIOLATION) { + ADVANCE(rval.consumed); + RETURN(RC_WMORE); + } + /* Fall through */ + case RC_FAIL: /* Fatal error */ + RETURN(RC_FAIL); + } /* switch(rval) */ + + ADVANCE(rval.consumed); + } /* for(all list members) */ + + NEXT_PHASE(ctx); + case 2: + /* + * Read in all "end of content" TLVs. + */ + while(ctx->left < 0) { + if(LEFT < 2) { + if(LEFT > 0 && ((const char *)ptr)[0] != 0) { + /* Unexpected tag */ + RETURN(RC_FAIL); + } else { + RETURN(RC_WMORE); + } + } + if(((const char *)ptr)[0] == 0 + && ((const char *)ptr)[1] == 0) { + ADVANCE(2); + ctx->left++; + } else { + RETURN(RC_FAIL); + } + } + + PHASE_OUT(ctx); + } + + RETURN(RC_OK); +} + +/* + * Internally visible buffer holding a single encoded element. + */ +struct _el_buffer { + uint8_t *buf; + size_t length; + size_t size; +}; +/* Append bytes to the above structure */ +static int _el_addbytes(const void *buffer, size_t size, void *el_buf_ptr) { + struct _el_buffer *el_buf = (struct _el_buffer *)el_buf_ptr; + + if(el_buf->length + size > el_buf->size) + return -1; + + memcpy(el_buf->buf + el_buf->length, buffer, size); + + el_buf->length += size; + return 0; +} +static int _el_buf_cmp(const void *ap, const void *bp) { + const struct _el_buffer *a = (const struct _el_buffer *)ap; + const struct _el_buffer *b = (const struct _el_buffer *)bp; + int ret; + size_t common_len; + + if(a->length < b->length) + common_len = a->length; + else + common_len = b->length; + + ret = memcmp(a->buf, b->buf, common_len); + if(ret == 0) { + if(a->length < b->length) + ret = -1; + else if(a->length > b->length) + ret = 1; + } + + return ret; +} + +/* + * The DER encoder of the SET OF type. + */ +asn_enc_rval_t +SET_OF_encode_der(asn_TYPE_descriptor_t *td, void *ptr, + int tag_mode, ber_tlv_tag_t tag, + asn_app_consume_bytes_f *cb, void *app_key) { + asn_TYPE_member_t *elm = td->elements; + asn_TYPE_descriptor_t *elm_type = elm->type; + der_type_encoder_f *der_encoder = elm_type->der_encoder; + asn_anonymous_set_ *list = _A_SET_FROM_VOID(ptr); + size_t computed_size = 0; + ssize_t encoding_size = 0; + struct _el_buffer *encoded_els; + ssize_t eels_count = 0; + size_t max_encoded_len = 1; + asn_enc_rval_t erval; + int ret; + int edx; + + ASN_DEBUG("Estimating size for SET OF %s", td->name); + + /* + * Gather the length of the underlying members sequence. + */ + for(edx = 0; edx < list->count; edx++) { + void *memb_ptr = list->array[edx]; + if(!memb_ptr) continue; + erval = der_encoder(elm_type, memb_ptr, 0, elm->tag, 0, 0); + if(erval.encoded == -1) + return erval; + computed_size += erval.encoded; + + /* Compute maximum encoding's size */ + if(max_encoded_len < (size_t)erval.encoded) + max_encoded_len = erval.encoded; + } + + /* + * Encode the TLV for the sequence itself. + */ + encoding_size = der_write_tags(td, computed_size, tag_mode, 1, tag, + cb, app_key); + if(encoding_size == -1) { + erval.encoded = -1; + erval.failed_type = td; + erval.structure_ptr = ptr; + return erval; + } + computed_size += encoding_size; + + if(!cb || list->count == 0) { + erval.encoded = computed_size; + _ASN_ENCODED_OK(erval); + } + + /* + * DER mandates dynamic sorting of the SET OF elements + * according to their encodings. Build an array of the + * encoded elements. + */ + encoded_els = (struct _el_buffer *)MALLOC( + list->count * sizeof(encoded_els[0])); + if(encoded_els == NULL) { + erval.encoded = -1; + erval.failed_type = td; + erval.structure_ptr = ptr; + return erval; + } + + ASN_DEBUG("Encoding members of %s SET OF", td->name); + + /* + * Encode all members. + */ + for(edx = 0; edx < list->count; edx++) { + void *memb_ptr = list->array[edx]; + struct _el_buffer *encoded_el = &encoded_els[eels_count]; + + if(!memb_ptr) continue; + + /* + * Prepare space for encoding. + */ + encoded_el->buf = (uint8_t *)MALLOC(max_encoded_len); + if(encoded_el->buf) { + encoded_el->length = 0; + encoded_el->size = max_encoded_len; + } else { + for(edx--; edx >= 0; edx--) + FREEMEM(encoded_els[edx].buf); + FREEMEM(encoded_els); + erval.encoded = -1; + erval.failed_type = td; + erval.structure_ptr = ptr; + return erval; + } + + /* + * Encode the member into the prepared space. + */ + erval = der_encoder(elm_type, memb_ptr, 0, elm->tag, + _el_addbytes, encoded_el); + if(erval.encoded == -1) { + for(; edx >= 0; edx--) + FREEMEM(encoded_els[edx].buf); + FREEMEM(encoded_els); + return erval; + } + encoding_size += erval.encoded; + eels_count++; + } + + /* + * Sort the encoded elements according to their encoding. + */ + qsort(encoded_els, eels_count, sizeof(encoded_els[0]), _el_buf_cmp); + + /* + * Report encoded elements to the application. + * Dispose of temporary sorted members table. + */ + ret = 0; + for(edx = 0; edx < eels_count; edx++) { + struct _el_buffer *encoded_el = &encoded_els[edx]; + /* Report encoded chunks to the application */ + if(ret == 0 + && cb(encoded_el->buf, encoded_el->length, app_key) < 0) + ret = -1; + FREEMEM(encoded_el->buf); + } + FREEMEM(encoded_els); + + if(ret || computed_size != (size_t)encoding_size) { + /* + * Standard callback failed, or + * encoded size is not equal to the computed size. + */ + erval.encoded = -1; + erval.failed_type = td; + erval.structure_ptr = ptr; + } else { + erval.encoded = computed_size; + } + + _ASN_ENCODED_OK(erval); +} + +#undef XER_ADVANCE +#define XER_ADVANCE(num_bytes) do { \ + size_t num = num_bytes; \ + buf_ptr = ((const char *)buf_ptr) + num;\ + size -= num; \ + consumed_myself += num; \ + } while(0) + +/* + * Decode the XER (XML) data. + */ +asn_dec_rval_t +SET_OF_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **struct_ptr, const char *opt_mname, + const void *buf_ptr, size_t size) { + /* + * Bring closer parts of structure description. + */ + asn_SET_OF_specifics_t *specs = (asn_SET_OF_specifics_t *)td->specifics; + asn_TYPE_member_t *element = td->elements; + const char *elm_tag; + const char *xml_tag = opt_mname ? opt_mname : td->xml_tag; + + /* + * ... and parts of the structure being constructed. + */ + void *st = *struct_ptr; /* Target structure. */ + asn_struct_ctx_t *ctx; /* Decoder context */ + + asn_dec_rval_t rval; /* Return value from a decoder */ + ssize_t consumed_myself = 0; /* Consumed bytes from ptr */ + + /* + * Create the target structure if it is not present already. + */ + if(st == 0) { + st = *struct_ptr = CALLOC(1, specs->struct_size); + if(st == 0) RETURN(RC_FAIL); + } + + /* Which tag is expected for the downstream */ + if(specs->as_XMLValueList) { + elm_tag = (specs->as_XMLValueList == 1) ? 0 : ""; + } else { + elm_tag = (*element->name) + ? element->name : element->type->xml_tag; + } + + /* + * Restore parsing context. + */ + ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset); + + /* + * Phases of XER/XML processing: + * Phase 0: Check that the opening tag matches our expectations. + * Phase 1: Processing body and reacting on closing tag. + * Phase 2: Processing inner type. + */ + for(; ctx->phase <= 2;) { + pxer_chunk_type_e ch_type; /* XER chunk type */ + ssize_t ch_size; /* Chunk size */ + xer_check_tag_e tcv; /* Tag check value */ + + /* + * Go inside the inner member of a set. + */ + if(ctx->phase == 2) { + asn_dec_rval_t tmprval; + + /* Invoke the inner type decoder, m.b. multiple times */ + ASN_DEBUG("XER/SET OF element [%s]", elm_tag); + tmprval = element->type->xer_decoder(opt_codec_ctx, + element->type, &ctx->ptr, elm_tag, + buf_ptr, size); + if(tmprval.code == RC_OK) { + asn_anonymous_set_ *list = _A_SET_FROM_VOID(st); + if(ASN_SET_ADD(list, ctx->ptr) != 0) + RETURN(RC_FAIL); + ctx->ptr = 0; + XER_ADVANCE(tmprval.consumed); + } else { + XER_ADVANCE(tmprval.consumed); + RETURN(tmprval.code); + } + ctx->phase = 1; /* Back to body processing */ + ASN_DEBUG("XER/SET OF phase => %d", ctx->phase); + /* Fall through */ + } + + /* + * Get the next part of the XML stream. + */ + ch_size = xer_next_token(&ctx->context, + buf_ptr, size, &ch_type); + switch(ch_size) { + case -1: RETURN(RC_FAIL); + case 0: RETURN(RC_WMORE); + default: + switch(ch_type) { + case PXER_COMMENT: /* Got XML comment */ + case PXER_TEXT: /* Ignore free-standing text */ + XER_ADVANCE(ch_size); /* Skip silently */ + continue; + case PXER_TAG: + break; /* Check the rest down there */ + } + } + + tcv = xer_check_tag(buf_ptr, ch_size, xml_tag); + ASN_DEBUG("XER/SET OF: tcv = %d, ph=%d t=%s", + tcv, ctx->phase, xml_tag); + switch(tcv) { + case XCT_CLOSING: + if(ctx->phase == 0) break; + ctx->phase = 0; + /* Fall through */ + case XCT_BOTH: + if(ctx->phase == 0) { + /* No more things to decode */ + XER_ADVANCE(ch_size); + ctx->phase = 3; /* Phase out */ + RETURN(RC_OK); + } + /* Fall through */ + case XCT_OPENING: + if(ctx->phase == 0) { + XER_ADVANCE(ch_size); + ctx->phase = 1; /* Processing body phase */ + continue; + } + /* Fall through */ + case XCT_UNKNOWN_OP: + case XCT_UNKNOWN_BO: + + ASN_DEBUG("XER/SET OF: tcv=%d, ph=%d", tcv, ctx->phase); + if(ctx->phase == 1) { + /* + * Process a single possible member. + */ + ctx->phase = 2; + continue; + } + /* Fall through */ + default: + break; + } + + ASN_DEBUG("Unexpected XML tag in SET OF"); + break; + } + + ctx->phase = 3; /* "Phase out" on hard failure */ + RETURN(RC_FAIL); +} + + + +typedef struct xer_tmp_enc_s { + void *buffer; + size_t offset; + size_t size; +} xer_tmp_enc_t; +static int +SET_OF_encode_xer_callback(const void *buffer, size_t size, void *key) { + xer_tmp_enc_t *t = (xer_tmp_enc_t *)key; + if(t->offset + size >= t->size) { + size_t newsize = (t->size << 2) + size; + void *p = REALLOC(t->buffer, newsize); + if(!p) return -1; + t->buffer = p; + t->size = newsize; + } + memcpy((char *)t->buffer + t->offset, buffer, size); + t->offset += size; + return 0; +} +static int +SET_OF_xer_order(const void *aptr, const void *bptr) { + const xer_tmp_enc_t *a = (const xer_tmp_enc_t *)aptr; + const xer_tmp_enc_t *b = (const xer_tmp_enc_t *)bptr; + size_t minlen = a->offset; + int ret; + if(b->offset < minlen) minlen = b->offset; + /* Well-formed UTF-8 has this nice lexicographical property... */ + ret = memcmp(a->buffer, b->buffer, minlen); + if(ret != 0) return ret; + if(a->offset == b->offset) + return 0; + if(a->offset == minlen) + return -1; + return 1; +} + + +asn_enc_rval_t +SET_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + asn_enc_rval_t er; + asn_SET_OF_specifics_t *specs = (asn_SET_OF_specifics_t *)td->specifics; + asn_TYPE_member_t *elm = td->elements; + asn_anonymous_set_ *list = _A_SET_FROM_VOID(sptr); + const char *mname = specs->as_XMLValueList + ? 0 : ((*elm->name) ? elm->name : elm->type->xml_tag); + size_t mlen = mname ? strlen(mname) : 0; + int xcan = (flags & XER_F_CANONICAL); + xer_tmp_enc_t *encs = 0; + size_t encs_count = 0; + void *original_app_key = app_key; + asn_app_consume_bytes_f *original_cb = cb; + int i; + + if(!sptr) _ASN_ENCODE_FAILED; + + if(xcan) { + encs = (xer_tmp_enc_t *)MALLOC(list->count * sizeof(encs[0])); + if(!encs) _ASN_ENCODE_FAILED; + cb = SET_OF_encode_xer_callback; + } + + er.encoded = 0; + + for(i = 0; i < list->count; i++) { + asn_enc_rval_t tmper; + + void *memb_ptr = list->array[i]; + if(!memb_ptr) continue; + + if(encs) { + memset(&encs[encs_count], 0, sizeof(encs[0])); + app_key = &encs[encs_count]; + encs_count++; + } + + if(mname) { + if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel); + _ASN_CALLBACK3("<", 1, mname, mlen, ">", 1); + } + + if(!xcan && specs->as_XMLValueList == 1) + _i_ASN_TEXT_INDENT(1, ilevel + 1); + tmper = elm->type->xer_encoder(elm->type, memb_ptr, + ilevel + (specs->as_XMLValueList != 2), + flags, cb, app_key); + if(tmper.encoded == -1) { + td = tmper.failed_type; + sptr = tmper.structure_ptr; + goto cb_failed; + } + if(tmper.encoded == 0 && specs->as_XMLValueList) { + const char *name = elm->type->xml_tag; + size_t len = strlen(name); + _ASN_CALLBACK3("<", 1, name, len, "/>", 2); + } + + if(mname) { + _ASN_CALLBACK3("", 1); + er.encoded += 5; + } + + er.encoded += (2 * mlen) + tmper.encoded; + } + + if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel - 1); + + if(encs) { + xer_tmp_enc_t *enc = encs; + xer_tmp_enc_t *end = encs + encs_count; + ssize_t control_size = 0; + + cb = original_cb; + app_key = original_app_key; + qsort(encs, encs_count, sizeof(encs[0]), SET_OF_xer_order); + + for(; enc < end; enc++) { + _ASN_CALLBACK(enc->buffer, enc->offset); + FREEMEM(enc->buffer); + enc->buffer = 0; + control_size += enc->offset; + } + assert(control_size == er.encoded); + } + + goto cleanup; +cb_failed: + er.encoded = -1; + er.failed_type = td; + er.structure_ptr = sptr; +cleanup: + if(encs) { + while(encs_count-- > 0) { + if(encs[encs_count].buffer) + FREEMEM(encs[encs_count].buffer); + } + FREEMEM(encs); + } + _ASN_ENCODED_OK(er); +} + +int +SET_OF_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel, + asn_app_consume_bytes_f *cb, void *app_key) { + asn_TYPE_member_t *elm = td->elements; + const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr); + int ret; + int i; + + if(!sptr) return (cb("", 8, app_key) < 0) ? -1 : 0; + + /* Dump preamble */ + if(cb(td->name, strlen(td->name), app_key) < 0 + || cb(" ::= {", 6, app_key) < 0) + return -1; + + for(i = 0; i < list->count; i++) { + const void *memb_ptr = list->array[i]; + if(!memb_ptr) continue; + + _i_INDENT(1); + + ret = elm->type->print_struct(elm->type, memb_ptr, + ilevel + 1, cb, app_key); + if(ret) return ret; + } + + ilevel--; + _i_INDENT(1); + + return (cb("}", 1, app_key) < 0) ? -1 : 0; +} + +void +SET_OF_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) { + if(td && ptr) { + asn_TYPE_member_t *elm = td->elements; + asn_anonymous_set_ *list = _A_SET_FROM_VOID(ptr); + int i; + + /* + * Could not use set_of_empty() because of (*free) + * incompatibility. + */ + for(i = 0; i < list->count; i++) { + void *memb_ptr = list->array[i]; + if(memb_ptr) + ASN_STRUCT_FREE(*elm->type, memb_ptr); + } + list->count = 0; /* No meaningful elements left */ + + asn_set_empty(list); /* Remove (list->array) */ + + if(!contents_only) { + FREEMEM(ptr); + } + } +} + +int +SET_OF_constraint(asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + asn_TYPE_member_t *elm = td->elements; + asn_constr_check_f *constr; + const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr); + int i; + + if(!sptr) { + _ASN_CTFAIL(app_key, td, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + constr = elm->memb_constraints; + if(!constr) constr = elm->type->check_constraints; + + /* + * Iterate over the members of an array. + * Validate each in turn, until one fails. + */ + for(i = 0; i < list->count; i++) { + const void *memb_ptr = list->array[i]; + int ret; + + if(!memb_ptr) continue; + + ret = constr(elm->type, memb_ptr, ctfailcb, app_key); + if(ret) return ret; + } + + /* + * Cannot inherit it eralier: + * need to make sure we get the updated version. + */ + if(!elm->memb_constraints) + elm->memb_constraints = elm->type->check_constraints; + + return 0; +} + +asn_dec_rval_t +SET_OF_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) { + asn_dec_rval_t rv; + asn_SET_OF_specifics_t *specs = (asn_SET_OF_specifics_t *)td->specifics; + asn_TYPE_member_t *elm = td->elements; /* Single one */ + void *st = *sptr; + asn_anonymous_set_ *list; + asn_per_constraint_t *ct; + int repeat = 0; + ssize_t nelems; + + if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx)) + _ASN_DECODE_FAILED; + + /* + * Create the target structure if it is not present already. + */ + if(!st) { + st = *sptr = CALLOC(1, specs->struct_size); + if(!st) _ASN_DECODE_FAILED; + } + list = _A_SET_FROM_VOID(st); + + /* Figure out which constraints to use */ + if(constraints) ct = &constraints->size; + else if(td->per_constraints) ct = &td->per_constraints->size; + else ct = 0; + + if(ct && ct->flags & APC_EXTENSIBLE) { + int value = per_get_few_bits(pd, 1); + if(value < 0) _ASN_DECODE_STARVED; + if(value) ct = 0; /* Not restricted! */ + } + + if(ct && ct->effective_bits >= 0) { + /* X.691, #19.5: No length determinant */ + nelems = per_get_few_bits(pd, ct->effective_bits); + ASN_DEBUG("Preparing to fetch %ld+%ld elements from %s", + (long)nelems, ct->lower_bound, td->name); + if(nelems < 0) _ASN_DECODE_STARVED; + nelems += ct->lower_bound; + } else { + nelems = -1; + } + + do { + int i; + if(nelems < 0) { + nelems = uper_get_length(pd, + ct ? ct->effective_bits : -1, &repeat); + ASN_DEBUG("Got to decode %d elements (eff %d)", + (int)nelems, (int)ct ? ct->effective_bits : -1); + if(nelems < 0) _ASN_DECODE_STARVED; + } + + for(i = 0; i < nelems; i++) { + void *ptr = 0; + ASN_DEBUG("SET OF %s decoding", elm->type->name); + rv = elm->type->uper_decoder(opt_codec_ctx, elm->type, + elm->per_constraints, &ptr, pd); + ASN_DEBUG("%s SET OF %s decoded %d, %p", + td->name, elm->type->name, rv.code, ptr); + if(rv.code == RC_OK) { + if(ASN_SET_ADD(list, ptr) == 0) + continue; + ASN_DEBUG("Failed to add element into %s", + td->name); + /* Fall through */ + rv.code == RC_FAIL; + } else { + ASN_DEBUG("Failed decoding %s of %s (SET OF)", + elm->type->name, td->name); + } + if(ptr) ASN_STRUCT_FREE(*elm->type, ptr); + return rv; + } + + nelems = -1; /* Allow uper_get_length() */ + } while(repeat); + + ASN_DEBUG("Decoded %s as SET OF", td->name); + + rv.code = RC_OK; + rv.consumed = 0; + return rv; +} + diff --git a/projects/stargazer/plugins/other/snmp/asn1/constr_SET_OF.h b/projects/stargazer/plugins/other/snmp/asn1/constr_SET_OF.h new file mode 100644 index 00000000..bcd09662 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/constr_SET_OF.h @@ -0,0 +1,42 @@ +/*- + * Copyright (c) 2003 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _CONSTR_SET_OF_H_ +#define _CONSTR_SET_OF_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct asn_SET_OF_specifics_s { + /* + * Target structure description. + */ + int struct_size; /* Size of the target structure. */ + int ctx_offset; /* Offset of the asn_struct_ctx_t member */ + + /* XER-specific stuff */ + int as_XMLValueList; /* The member type must be encoded like this */ +} asn_SET_OF_specifics_t; + +/* + * A set specialized functions dealing with the SET OF type. + */ +asn_struct_free_f SET_OF_free; +asn_struct_print_f SET_OF_print; +asn_constr_check_f SET_OF_constraint; +ber_type_decoder_f SET_OF_decode_ber; +der_type_encoder_f SET_OF_encode_der; +xer_type_decoder_f SET_OF_decode_xer; +xer_type_encoder_f SET_OF_encode_xer; +per_type_decoder_f SET_OF_decode_uper; +per_type_encoder_f SET_OF_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _CONSTR_SET_OF_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/constr_TYPE.c b/projects/stargazer/plugins/other/snmp/asn1/constr_TYPE.c new file mode 100644 index 00000000..4bc88d44 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/constr_TYPE.c @@ -0,0 +1,77 @@ +/*- + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include +#include + +/* + * Version of the ASN.1 infrastructure shipped with compiler. + */ +int get_asn1c_environment_version() { return ASN1C_ENVIRONMENT_VERSION; } + +static asn_app_consume_bytes_f _print2fp; + +/* + * Return the outmost tag of the type. + */ +ber_tlv_tag_t +asn_TYPE_outmost_tag(asn_TYPE_descriptor_t *type_descriptor, + const void *struct_ptr, int tag_mode, ber_tlv_tag_t tag) { + + if(tag_mode) + return tag; + + if(type_descriptor->tags_count) + return type_descriptor->tags[0]; + + return type_descriptor->outmost_tag(type_descriptor, struct_ptr, 0, 0); +} + +/* + * Print the target language's structure in human readable form. + */ +int +asn_fprint(FILE *stream, asn_TYPE_descriptor_t *td, const void *struct_ptr) { + if(!stream) stream = stdout; + if(!td || !struct_ptr) { + errno = EINVAL; + return -1; + } + + /* Invoke type-specific printer */ + if(td->print_struct(td, struct_ptr, 1, _print2fp, stream)) + return -1; + + /* Terminate the output */ + if(_print2fp("\n", 1, stream)) + return -1; + + return fflush(stream); +} + +/* Dump the data into the specified stdio stream */ +static int +_print2fp(const void *buffer, size_t size, void *app_key) { + FILE *stream = (FILE *)app_key; + + if(fwrite(buffer, 1, size, stream) != size) + return -1; + + return 0; +} + + +/* + * Some compilers do not support variable args macros. + * This function is a replacement of ASN_DEBUG() macro. + */ +void ASN_DEBUG_f(const char *fmt, ...); +void ASN_DEBUG_f(const char *fmt, ...) { + va_list ap; + va_start(ap, fmt); + vfprintf(stderr, fmt, ap); + fprintf(stderr, "\n"); + va_end(ap); +} diff --git a/projects/stargazer/plugins/other/snmp/asn1/constr_TYPE.h b/projects/stargazer/plugins/other/snmp/asn1/constr_TYPE.h new file mode 100644 index 00000000..95507c80 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/constr_TYPE.h @@ -0,0 +1,180 @@ +/*- + * Copyright (c) 2003, 2004, 2005, 2006 Lev Walkin . + * All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +/* + * This file contains the declaration structure called "ASN.1 Type Definition", + * which holds all information necessary for encoding and decoding routines. + * This structure even contains pointer to these encoding and decoding routines + * for each defined ASN.1 type. + */ +#ifndef _CONSTR_TYPE_H_ +#define _CONSTR_TYPE_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +struct asn_TYPE_descriptor_s; /* Forward declaration */ +struct asn_TYPE_member_s; /* Forward declaration */ + +/* + * This type provides the context information for various ASN.1 routines, + * primarily ones doing decoding. A member _asn_ctx of this type must be + * included into certain target language's structures, such as compound types. + */ +typedef struct asn_struct_ctx_s { + short phase; /* Decoding phase */ + short step; /* Elementary step of a phase */ + int context; /* Other context information */ + void *ptr; /* Decoder-specific stuff (stack elements) */ + ber_tlv_len_t left; /* Number of bytes left, -1 for indefinite */ +} asn_struct_ctx_t; + +#include /* Basic Encoding Rules decoder */ +#include /* Distinguished Encoding Rules encoder */ +#include /* Decoder of XER (XML, text) */ +#include /* Encoder into XER (XML, text) */ +#include /* Packet Encoding Rules decoder */ +#include /* Packet Encoding Rules encoder */ +#include /* Subtype constraints support */ + +/* + * Free the structure according to its specification. + * If (free_contents_only) is set, the wrapper structure itself (struct_ptr) + * will not be freed. (It may be useful in case the structure is allocated + * statically or arranged on the stack, yet its elements are allocated + * dynamically.) + */ +typedef void (asn_struct_free_f)( + struct asn_TYPE_descriptor_s *type_descriptor, + void *struct_ptr, int free_contents_only); +#define ASN_STRUCT_FREE(asn_DEF, ptr) (asn_DEF).free_struct(&(asn_DEF),ptr,0) +#define ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF, ptr) \ + (asn_DEF).free_struct(&(asn_DEF),ptr,1) + +/* + * Print the structure according to its specification. + */ +typedef int (asn_struct_print_f)( + struct asn_TYPE_descriptor_s *type_descriptor, + const void *struct_ptr, + int level, /* Indentation level */ + asn_app_consume_bytes_f *callback, void *app_key); + +/* + * Return the outmost tag of the type. + * If the type is untagged CHOICE, the dynamic operation is performed. + * NOTE: This function pointer type is only useful internally. + * Do not use it in your application. + */ +typedef ber_tlv_tag_t (asn_outmost_tag_f)( + struct asn_TYPE_descriptor_s *type_descriptor, + const void *struct_ptr, int tag_mode, ber_tlv_tag_t tag); +/* The instance of the above function type; used internally. */ +asn_outmost_tag_f asn_TYPE_outmost_tag; + + +/* + * The definitive description of the destination language's structure. + */ +typedef struct asn_TYPE_descriptor_s { + char *name; /* A name of the ASN.1 type. "" in some cases. */ + char *xml_tag; /* Name used in XML tag */ + + /* + * Generalized functions for dealing with the specific type. + * May be directly invoked by applications. + */ + asn_struct_free_f *free_struct; /* Free the structure */ + asn_struct_print_f *print_struct; /* Human readable output */ + asn_constr_check_f *check_constraints; /* Constraints validator */ + ber_type_decoder_f *ber_decoder; /* Generic BER decoder */ + der_type_encoder_f *der_encoder; /* Canonical DER encoder */ + xer_type_decoder_f *xer_decoder; /* Generic XER decoder */ + xer_type_encoder_f *xer_encoder; /* [Canonical] XER encoder */ + per_type_decoder_f *uper_decoder; /* Unaligned PER decoder */ + per_type_encoder_f *uper_encoder; /* Unaligned PER encoder */ + + /*********************************************************************** + * Internally useful members. Not to be used by applications directly. * + **********************************************************************/ + + /* + * Tags that are expected to occur. + */ + asn_outmost_tag_f *outmost_tag; /* */ + ber_tlv_tag_t *tags; /* Effective tags sequence for this type */ + int tags_count; /* Number of tags which are expected */ + ber_tlv_tag_t *all_tags;/* Every tag for BER/containment */ + int all_tags_count; /* Number of tags */ + + asn_per_constraints_t *per_constraints; /* PER compiled constraints */ + + /* + * An ASN.1 production type members (members of SEQUENCE, SET, CHOICE). + */ + struct asn_TYPE_member_s *elements; + int elements_count; + + /* + * Additional information describing the type, used by appropriate + * functions above. + */ + void *specifics; +} asn_TYPE_descriptor_t; + +/* + * This type describes an element of the constructed type, + * i.e. SEQUENCE, SET, CHOICE, etc. + */ + enum asn_TYPE_flags_e { + ATF_NOFLAGS, + ATF_POINTER = 0x01, /* Represented by the pointer */ + ATF_OPEN_TYPE = 0x02 /* ANY type, without meaningful tag */ + }; +typedef struct asn_TYPE_member_s { + enum asn_TYPE_flags_e flags; /* Element's presentation flags */ + int optional; /* Following optional members, including current */ + int memb_offset; /* Offset of the element */ + ber_tlv_tag_t tag; /* Outmost (most immediate) tag */ + int tag_mode; /* IMPLICIT/no/EXPLICIT tag at current level */ + asn_TYPE_descriptor_t *type; /* Member type descriptor */ + asn_constr_check_f *memb_constraints; /* Constraints validator */ + asn_per_constraints_t *per_constraints; /* PER compiled constraints */ + int (*default_value)(int setval, void **sptr); /* DEFAULT */ + char *name; /* ASN.1 identifier of the element */ +} asn_TYPE_member_t; + +/* + * BER tag to element number mapping. + */ +typedef struct asn_TYPE_tag2member_s { + ber_tlv_tag_t el_tag; /* Outmost tag of the member */ + int el_no; /* Index of the associated member, base 0 */ + int toff_first; /* First occurence of the el_tag, relative */ + int toff_last; /* Last occurence of the el_tag, relatvie */ +} asn_TYPE_tag2member_t; + +/* + * This function is a wrapper around (td)->print_struct, which prints out + * the contents of the target language's structure (struct_ptr) into the + * file pointer (stream) in human readable form. + * RETURN VALUES: + * 0: The structure is printed. + * -1: Problem dumping the structure. + * (See also xer_fprint() in xer_encoder.h) + */ +int asn_fprint(FILE *stream, /* Destination stream descriptor */ + asn_TYPE_descriptor_t *td, /* ASN.1 type descriptor */ + const void *struct_ptr); /* Structure to be printed */ + +#ifdef __cplusplus +} +#endif + +#endif /* _CONSTR_TYPE_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/constraints.c b/projects/stargazer/plugins/other/snmp/asn1/constraints.c new file mode 100644 index 00000000..1bdda73e --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/constraints.c @@ -0,0 +1,93 @@ +#include "asn_internal.h" +#include "constraints.h" + +int +asn_generic_no_constraint(asn_TYPE_descriptor_t *type_descriptor, + const void *struct_ptr, asn_app_constraint_failed_f *cb, void *key) { + + (void)type_descriptor; /* Unused argument */ + (void)struct_ptr; /* Unused argument */ + (void)cb; /* Unused argument */ + (void)key; /* Unused argument */ + + /* Nothing to check */ + return 0; +} + +int +asn_generic_unknown_constraint(asn_TYPE_descriptor_t *type_descriptor, + const void *struct_ptr, asn_app_constraint_failed_f *cb, void *key) { + + (void)type_descriptor; /* Unused argument */ + (void)struct_ptr; /* Unused argument */ + (void)cb; /* Unused argument */ + (void)key; /* Unused argument */ + + /* Unknown how to check */ + return 0; +} + +struct errbufDesc { + asn_TYPE_descriptor_t *failed_type; + const void *failed_struct_ptr; + char *errbuf; + size_t errlen; +}; + +static void +_asn_i_ctfailcb(void *key, asn_TYPE_descriptor_t *td, const void *sptr, const char *fmt, ...) { + struct errbufDesc *arg = key; + va_list ap; + ssize_t vlen; + ssize_t maxlen; + + arg->failed_type = td; + arg->failed_struct_ptr = sptr; + + maxlen = arg->errlen; + if(maxlen <= 0) + return; + + va_start(ap, fmt); + vlen = vsnprintf(arg->errbuf, maxlen, fmt, ap); + va_end(ap); + if(vlen >= maxlen) { + arg->errbuf[maxlen-1] = '\0'; /* Ensuring libc correctness */ + arg->errlen = maxlen - 1; /* Not counting termination */ + return; + } else if(vlen >= 0) { + arg->errbuf[vlen] = '\0'; /* Ensuring libc correctness */ + arg->errlen = vlen; /* Not counting termination */ + } else { + /* + * The libc on this system is broken. + */ + vlen = sizeof("") - 1; + maxlen--; + arg->errlen = vlen < maxlen ? vlen : maxlen; + memcpy(arg->errbuf, "", arg->errlen); + arg->errbuf[arg->errlen] = 0; + } + + return; +} + +int +asn_check_constraints(asn_TYPE_descriptor_t *type_descriptor, + const void *struct_ptr, char *errbuf, size_t *errlen) { + struct errbufDesc arg; + int ret; + + arg.failed_type = 0; + arg.failed_struct_ptr = 0; + arg.errbuf = errbuf; + arg.errlen = errlen ? *errlen : 0; + + ret = type_descriptor->check_constraints(type_descriptor, + struct_ptr, _asn_i_ctfailcb, &arg); + if(ret == -1 && errlen) + *errlen = arg.errlen; + + return ret; +} + diff --git a/projects/stargazer/plugins/other/snmp/asn1/constraints.h b/projects/stargazer/plugins/other/snmp/asn1/constraints.h new file mode 100644 index 00000000..5032345e --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/constraints.h @@ -0,0 +1,63 @@ +/*- + * Copyright (c) 2004, 2006 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _ASN1_CONSTRAINTS_VALIDATOR_H_ +#define _ASN1_CONSTRAINTS_VALIDATOR_H_ + +#include /* Platform-dependent types */ + +#ifdef __cplusplus +extern "C" { +#endif + +struct asn_TYPE_descriptor_s; /* Forward declaration */ + +/* + * Validate the structure according to the ASN.1 constraints. + * If errbuf and errlen are given, they shall be pointing to the appropriate + * buffer space and its length before calling this function. Alternatively, + * they could be passed as NULL's. If constraints validation fails, + * errlen will contain the actual number of bytes taken from the errbuf + * to encode an error message (properly 0-terminated). + * + * RETURN VALUES: + * This function returns 0 in case all ASN.1 constraints are met + * and -1 if one or more constraints were failed. + */ +int +asn_check_constraints(struct asn_TYPE_descriptor_s *type_descriptor, + const void *struct_ptr, /* Target language's structure */ + char *errbuf, /* Returned error description */ + size_t *errlen /* Length of the error description */ + ); + + +/* + * Generic type for constraint checking callback, + * associated with every type descriptor. + */ +typedef int (asn_constr_check_f)( + struct asn_TYPE_descriptor_s *type_descriptor, + const void *struct_ptr, + asn_app_constraint_failed_f *optional_callback, /* Log the error */ + void *optional_app_key /* Opaque key passed to a callback */ + ); + +/******************************* + * INTERNALLY USEFUL FUNCTIONS * + *******************************/ + +asn_constr_check_f asn_generic_no_constraint; /* No constraint whatsoever */ +asn_constr_check_f asn_generic_unknown_constraint; /* Not fully supported */ + +/* + * Invoke the callback with a complete error message. + */ +#define _ASN_CTFAIL if(ctfailcb) ctfailcb + +#ifdef __cplusplus +} +#endif + +#endif /* _ASN1_CONSTRAINTS_VALIDATOR_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/converter-sample.c b/projects/stargazer/plugins/other/snmp/asn1/converter-sample.c new file mode 100644 index 00000000..6317d8a5 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/converter-sample.c @@ -0,0 +1,725 @@ +/* + * Generic converter template for a selected ASN.1 type. + * Copyright (c) 2005, 2006 Lev Walkin . All rights reserved. + * + * To compile with your own ASN.1 type, please redefine the PDU as shown: + * + * cc -DPDU=MyCustomType -o myDecoder.o -c converter-sample.c + */ +#ifdef HAVE_CONFIG_H +#include +#endif +#include +#include +#include /* for atoi(3) */ +#include /* for getopt(3) */ +#include /* for strerror(3) */ +#include /* for EX_* exit codes */ +#include /* for assert(3) */ +#include /* for errno */ + +#include +#include /* for _ASN_DEFAULT_STACK_MAX */ + +/* Convert "Type" defined by -DPDU into "asn_DEF_Type" */ +#define ASN_DEF_PDU(t) asn_DEF_ ## t +#define DEF_PDU_Type(t) ASN_DEF_PDU(t) +#define PDU_Type DEF_PDU_Type(PDU) + +extern asn_TYPE_descriptor_t PDU_Type; /* ASN.1 type to be decoded */ +#ifdef ASN_PDU_COLLECTION /* Generated by asn1c: -pdu=... */ +extern asn_TYPE_descriptor_t *asn_pdu_collection[]; +#endif + +/* + * Open file and parse its contens. + */ +static void *data_decode_from_file(asn_TYPE_descriptor_t *asnTypeOfPDU, + FILE *file, const char *name, ssize_t suggested_bufsize, int first_pdu); +static int write_out(const void *buffer, size_t size, void *key); +static FILE *argument_to_file(char *av[], int idx); +static char *argument_to_name(char *av[], int idx); + + int opt_debug; /* -d (or -dd) */ +static int opt_check; /* -c (constraints checking) */ +static int opt_stack; /* -s (maximum stack size) */ +static int opt_ippad; /* -per-padded (PER input is byte-padded) */ +static int opt_onepdu; /* -1 (decode single PDU) */ + +/* Input data format selector */ +static enum input_format { + INP_BER, /* -iber: BER input */ + INP_XER, /* -ixer: XER input */ + INP_PER /* -iper: Unaligned PER input */ +} iform; /* -i */ + +/* Output data format selector */ +static enum output_format { + OUT_XER, /* -oxer: XER (XML) output */ + OUT_DER, /* -oder: DER (BER) output */ + OUT_PER, /* -oper: Unaligned PER output */ + OUT_TEXT, /* -otext: semi-structured text */ + OUT_NULL /* -onull: No pretty-printing */ +} oform; /* -o */ + +/* Debug output function */ +static inline void +DEBUG(const char *fmt, ...) { + va_list ap; + if(!opt_debug) return; + fprintf(stderr, "AD: "); + va_start(ap, fmt); + vfprintf(stderr, fmt, ap); + va_end(ap); + fprintf(stderr, "\n"); +} + +int +main(int ac, char *av[]) { + static asn_TYPE_descriptor_t *pduType = &PDU_Type; + ssize_t suggested_bufsize = 8192; /* close or equal to stdio buffer */ + int number_of_iterations = 1; + int num; + int ch; + + /* Figure out if Unaligned PER needs to be default */ + if(pduType->uper_decoder) + iform = INP_PER; + + /* + * Pocess the command-line argments. + */ + while((ch = getopt(ac, av, "i:o:1b:cdn:p:hs:")) != -1) + switch(ch) { + case 'i': + if(optarg[0] == 'b') { iform = INP_BER; break; } + if(optarg[0] == 'x') { iform = INP_XER; break; } + if(pduType->uper_decoder + && optarg[0] == 'p') { iform = INP_PER; break; } + fprintf(stderr, "-i: '%s': improper format selector\n", + optarg); + exit(EX_UNAVAILABLE); + case 'o': + if(optarg[0] == 'd') { oform = OUT_DER; break; } + if(pduType->uper_encoder + && optarg[0] == 'p') { oform = OUT_PER; break; } + if(optarg[0] == 'x') { oform = OUT_XER; break; } + if(optarg[0] == 't') { oform = OUT_TEXT; break; } + if(optarg[0] == 'n') { oform = OUT_NULL; break; } + fprintf(stderr, "-o: '%s': improper format selector\n", + optarg); + exit(EX_UNAVAILABLE); + case '1': + opt_onepdu = 1; + break; + case 'b': + suggested_bufsize = atoi(optarg); + if(suggested_bufsize < 1 + || suggested_bufsize > 16 * 1024 * 1024) { + fprintf(stderr, + "-b %s: Improper buffer size (1..16M)\n", + optarg); + exit(EX_UNAVAILABLE); + } + break; + case 'c': + opt_check = 1; + break; + case 'd': + opt_debug++; /* Double -dd means ASN.1 debug */ + break; + case 'n': + number_of_iterations = atoi(optarg); + if(number_of_iterations < 1) { + fprintf(stderr, + "-n %s: Improper iterations count\n", optarg); + exit(EX_UNAVAILABLE); + } + break; + case 'p': + if(strcmp(optarg, "er-padded") == 0) { + opt_ippad = 1; + break; + } +#ifdef ASN_PDU_COLLECTION + if(strcmp(optarg, "list") == 0) { + asn_TYPE_descriptor_t **pdu = asn_pdu_collection; + fprintf(stderr, "Available PDU types:\n"); + for(; *pdu; pdu++) printf("%s\n", (*pdu)->name); + exit(0); + } else if(optarg[0] >= 'A' && optarg[0] <= 'Z') { + asn_TYPE_descriptor_t **pdu = asn_pdu_collection; + while(*pdu && strcmp((*pdu)->name, optarg)) pdu++; + if(*pdu) { pduType = *pdu; break; } + fprintf(stderr, "-p %s: Unrecognized PDU\n", optarg); + } +#endif /* ASN_PDU_COLLECTION */ + fprintf(stderr, "-p %s: Unrecognized option\n", optarg); + exit(EX_UNAVAILABLE); + case 's': + opt_stack = atoi(optarg); + if(opt_stack < 0) { + fprintf(stderr, + "-s %s: Non-negative value expected\n", + optarg); + exit(EX_UNAVAILABLE); + } + break; + case 'h': + default: + fprintf(stderr, "Usage: %s [options] ...\n", av[0]); + fprintf(stderr, "Where options are:\n"); + if(pduType->uper_decoder) + fprintf(stderr, + " -iper Input is in Unaligned PER (Packed Encoding Rules) (DEFAULT)\n"); + fprintf(stderr, + " -iber Input is in BER (Basic Encoding Rules)%s\n", + iform == INP_PER ? "" : " (DEFAULT)"); + fprintf(stderr, + " -ixer Input is in XER (XML Encoding Rules)\n"); + if(pduType->uper_encoder) + fprintf(stderr, + " -oper Output in Unaligned PER (Packed Encoding Rules)\n"); + fprintf(stderr, + " -oder Output in DER (Distinguished Encoding Rules)\n" + " -oxer Output in XER (XML Encoding Rules) (DEFAULT)\n" + " -otext Output in plain semi-structured text (dump)\n" + " -onull Verify (decode) input, but do not output\n"); + if(pduType->uper_decoder) + fprintf(stderr, + " -per-padded Assume PER PDUs are byte-padded (-iper)\n"); +#ifdef ASN_PDU_COLLECTION + fprintf(stderr, + " -p Specify PDU type to decode\n" + " -p list List available PDUs\n"); +#endif /* ASN_PDU_COLLECTION */ + fprintf(stderr, + " -1 Decode only the first PDU in file\n" + " -b Set the i/o buffer size (default is %ld)\n" + " -c Check ASN.1 constraints after decoding\n" + " -d Enable debugging (-dd is even better)\n" + " -n Process files times\n" + " -s Set the stack usage limit (default is %d)\n" + , (long)suggested_bufsize, _ASN_DEFAULT_STACK_MAX); + exit(EX_USAGE); + } + + ac -= optind; + av += optind; + + if(ac < 1) { + fprintf(stderr, "%s: No input files specified. " + "Try '-h' for more information\n", + av[-optind]); + exit(EX_USAGE); + } + + setvbuf(stdout, 0, _IOLBF, 0); + + for(num = 0; num < number_of_iterations; num++) { + int ac_i; + /* + * Process all files in turn. + */ + for(ac_i = 0; ac_i < ac; ac_i++) { + asn_enc_rval_t erv; + void *structure; /* Decoded structure */ + FILE *file = argument_to_file(av, ac_i); + char *name = argument_to_name(av, ac_i); + int first_pdu; + + for(first_pdu = 1; first_pdu || !opt_onepdu; first_pdu = 0) { + /* + * Decode the encoded structure from file. + */ + structure = data_decode_from_file(pduType, + file, name, suggested_bufsize, first_pdu); + if(!structure) { + if(errno) { + /* Error message is already printed */ + exit(EX_DATAERR); + } else { + /* EOF */ + break; + } + } + + /* Check ASN.1 constraints */ + if(opt_check) { + char errbuf[128]; + size_t errlen = sizeof(errbuf); + if(asn_check_constraints(pduType, structure, + errbuf, &errlen)) { + fprintf(stderr, "%s: ASN.1 constraint " + "check failed: %s\n", name, errbuf); + exit(EX_DATAERR); + } + } + + switch(oform) { + case OUT_NULL: + fprintf(stderr, "%s: decoded successfully\n", name); + break; + case OUT_TEXT: /* -otext */ + asn_fprint(stdout, pduType, structure); + break; + case OUT_XER: /* -oxer */ + if(xer_fprint(stdout, pduType, structure)) { + fprintf(stderr, + "%s: Cannot convert %s into XML\n", + name, pduType->name); + exit(EX_UNAVAILABLE); + } + break; + case OUT_DER: + erv = der_encode(pduType, structure, write_out, stdout); + if(erv.encoded < 0) { + fprintf(stderr, + "%s: Cannot convert %s into DER\n", + name, pduType->name); + exit(EX_UNAVAILABLE); + } + DEBUG("Encoded in %ld bytes of DER", (long)erv.encoded); + break; + case OUT_PER: + erv = uper_encode(pduType, structure, write_out, stdout); + if(erv.encoded < 0) { + fprintf(stderr, + "%s: Cannot convert %s into Unaligned PER\n", + name, pduType->name); + exit(EX_UNAVAILABLE); + } + DEBUG("Encoded in %ld bits of UPER", (long)erv.encoded); + break; + } + + ASN_STRUCT_FREE(*pduType, structure); + } + + if(file && file != stdin) + fclose(file); + } + } + + return 0; +} + +static struct dynamic_buffer { + uint8_t *data; /* Pointer to the data bytes */ + size_t offset; /* Offset from the start */ + size_t length; /* Length of meaningful contents */ + size_t unbits; /* Unused bits in the last byte */ + size_t allocated; /* Allocated memory for data */ + int nreallocs; /* Number of data reallocations */ + off_t bytes_shifted; /* Number of bytes ever shifted */ +} DynamicBuffer; + +static void +buffer_dump() { + uint8_t *p = DynamicBuffer.data + DynamicBuffer.offset; + uint8_t *e = p + DynamicBuffer.length - (DynamicBuffer.unbits ? 1 : 0); + if(!opt_debug) return; + DEBUG("Buffer: { d=%p, o=%ld, l=%ld, u=%ld, a=%ld, s=%ld }", + DynamicBuffer.data, + (long)DynamicBuffer.offset, + (long)DynamicBuffer.length, + (long)DynamicBuffer.unbits, + (long)DynamicBuffer.allocated, + (long)DynamicBuffer.bytes_shifted); + for(; p < e; p++) { + fprintf(stderr, " %c%c%c%c%c%c%c%c", + ((*p >> 7) & 1) ? '1' : '0', + ((*p >> 6) & 1) ? '1' : '0', + ((*p >> 5) & 1) ? '1' : '0', + ((*p >> 4) & 1) ? '1' : '0', + ((*p >> 3) & 1) ? '1' : '0', + ((*p >> 2) & 1) ? '1' : '0', + ((*p >> 1) & 1) ? '1' : '0', + ((*p >> 0) & 1) ? '1' : '0'); + } + if(DynamicBuffer.unbits) { + int shift; + fprintf(stderr, " "); + for(shift = 7; shift >= DynamicBuffer.unbits; shift--) + fprintf(stderr, "%c", ((*p >> shift) & 1) ? '1' : '0'); + fprintf(stderr, " %d:%d\n", + DynamicBuffer.length - 1, 8 - DynamicBuffer.unbits); + } else { + fprintf(stderr, " %d\n", DynamicBuffer.length); + } +} + +/* + * Move the buffer content left N bits, possibly joining it with + * preceeding content. + */ +static void +buffer_shift_left(size_t offset, int bits) { + uint8_t *ptr = DynamicBuffer.data + DynamicBuffer.offset + offset; + uint8_t *end = DynamicBuffer.data + DynamicBuffer.offset + + DynamicBuffer.length - 1; + + if(!bits) return; + + DEBUG("Shifting left %d bits off %ld (o=%ld, u=%ld, l=%ld)", + bits, (long)offset, + (long)DynamicBuffer.offset, + (long)DynamicBuffer.unbits, + (long)DynamicBuffer.length); + + if(offset) { + int right; + right = ptr[0] >> (8 - bits); + + DEBUG("oleft: %c%c%c%c%c%c%c%c", + ((ptr[-1] >> 7) & 1) ? '1' : '0', + ((ptr[-1] >> 6) & 1) ? '1' : '0', + ((ptr[-1] >> 5) & 1) ? '1' : '0', + ((ptr[-1] >> 4) & 1) ? '1' : '0', + ((ptr[-1] >> 3) & 1) ? '1' : '0', + ((ptr[-1] >> 2) & 1) ? '1' : '0', + ((ptr[-1] >> 1) & 1) ? '1' : '0', + ((ptr[-1] >> 0) & 1) ? '1' : '0'); + + DEBUG("oriht: %c%c%c%c%c%c%c%c", + ((ptr[0] >> 7) & 1) ? '1' : '0', + ((ptr[0] >> 6) & 1) ? '1' : '0', + ((ptr[0] >> 5) & 1) ? '1' : '0', + ((ptr[0] >> 4) & 1) ? '1' : '0', + ((ptr[0] >> 3) & 1) ? '1' : '0', + ((ptr[0] >> 2) & 1) ? '1' : '0', + ((ptr[0] >> 1) & 1) ? '1' : '0', + ((ptr[0] >> 0) & 1) ? '1' : '0'); + + DEBUG("mriht: %c%c%c%c%c%c%c%c", + ((right >> 7) & 1) ? '1' : '0', + ((right >> 6) & 1) ? '1' : '0', + ((right >> 5) & 1) ? '1' : '0', + ((right >> 4) & 1) ? '1' : '0', + ((right >> 3) & 1) ? '1' : '0', + ((right >> 2) & 1) ? '1' : '0', + ((right >> 1) & 1) ? '1' : '0', + ((right >> 0) & 1) ? '1' : '0'); + + ptr[-1] = (ptr[-1] & (0xff << bits)) | right; + + DEBUG("after: %c%c%c%c%c%c%c%c", + ((ptr[-1] >> 7) & 1) ? '1' : '0', + ((ptr[-1] >> 6) & 1) ? '1' : '0', + ((ptr[-1] >> 5) & 1) ? '1' : '0', + ((ptr[-1] >> 4) & 1) ? '1' : '0', + ((ptr[-1] >> 3) & 1) ? '1' : '0', + ((ptr[-1] >> 2) & 1) ? '1' : '0', + ((ptr[-1] >> 1) & 1) ? '1' : '0', + ((ptr[-1] >> 0) & 1) ? '1' : '0'); + } + + buffer_dump(); + + for(; ptr < end; ptr++) { + int right = ptr[1] >> (8 - bits); + *ptr = (*ptr << bits) | right; + } + *ptr <<= bits; + + DEBUG("Unbits [%d=>", (int)DynamicBuffer.unbits); + if(DynamicBuffer.unbits == 0) { + DynamicBuffer.unbits += bits; + } else { + DynamicBuffer.unbits += bits; + if(DynamicBuffer.unbits > 7) { + DynamicBuffer.unbits -= 8; + DynamicBuffer.length--; + DynamicBuffer.bytes_shifted++; + } + } + DEBUG("Unbits =>%d]", (int)DynamicBuffer.unbits); + + buffer_dump(); + + DEBUG("Shifted. Now (o=%ld, u=%ld l=%ld)", + (long)DynamicBuffer.offset, + (long)DynamicBuffer.unbits, + (long)DynamicBuffer.length); + + +} + +/* + * Ensure that the buffer contains at least this amount of free space. + */ +static void add_bytes_to_buffer(const void *data2add, size_t bytes) { + + if(bytes == 0) return; + + DEBUG("=> add_bytes(%ld) { o=%ld l=%ld u=%ld, s=%ld }", + (long)bytes, + (long)DynamicBuffer.offset, + (long)DynamicBuffer.length, + (long)DynamicBuffer.unbits, + (long)DynamicBuffer.allocated); + + if(DynamicBuffer.allocated + >= (DynamicBuffer.offset + DynamicBuffer.length + bytes)) { + DEBUG("\tNo buffer reallocation is necessary"); + } else if(bytes <= DynamicBuffer.offset) { + DEBUG("\tContents shifted by %ld", DynamicBuffer.offset); + + /* Shift the buffer contents */ + memmove(DynamicBuffer.data, + DynamicBuffer.data + DynamicBuffer.offset, + DynamicBuffer.length); + DynamicBuffer.bytes_shifted += DynamicBuffer.offset; + DynamicBuffer.offset = 0; + } else { + size_t newsize = (DynamicBuffer.allocated << 2) + bytes; + void *p = MALLOC(newsize); + if(!p) { + perror("malloc()"); + exit(EX_OSERR); + } + memcpy(p, + DynamicBuffer.data + DynamicBuffer.offset, + DynamicBuffer.length); + FREEMEM(DynamicBuffer.data); + DynamicBuffer.data = (char *)p; + DynamicBuffer.offset = 0; + DynamicBuffer.allocated = newsize; + DynamicBuffer.nreallocs++; + DEBUG("\tBuffer reallocated to %ld (%d time)", + newsize, DynamicBuffer.nreallocs); + } + + memcpy(DynamicBuffer.data + + DynamicBuffer.offset + DynamicBuffer.length, + data2add, bytes); + DynamicBuffer.length += bytes; + if(DynamicBuffer.unbits) { + int bits = DynamicBuffer.unbits; + DynamicBuffer.unbits = 0; + buffer_shift_left(DynamicBuffer.length - bytes, bits); + } + + DEBUG("<= add_bytes(%ld) { o=%ld l=%ld u=%ld, s=%ld }", + (long)bytes, + (long)DynamicBuffer.offset, + (long)DynamicBuffer.length, + (long)DynamicBuffer.unbits, + (long)DynamicBuffer.allocated); +} + +static void * +data_decode_from_file(asn_TYPE_descriptor_t *pduType, FILE *file, const char *name, ssize_t suggested_bufsize, int on_first_pdu) { + static uint8_t *fbuf; + static ssize_t fbuf_size; + static asn_codec_ctx_t s_codec_ctx; + asn_codec_ctx_t *opt_codec_ctx = 0; + void *structure = 0; + asn_dec_rval_t rval; + size_t old_offset; + size_t new_offset; + int tolerate_eof; + size_t rd; + + if(!file) { + fprintf(stderr, "%s: %s\n", name, strerror(errno)); + errno = EINVAL; + return 0; + } + + if(opt_stack) { + s_codec_ctx.max_stack_size = opt_stack; + opt_codec_ctx = &s_codec_ctx; + } + + DEBUG("Processing %s", name); + + /* prepare the file buffer */ + if(fbuf_size != suggested_bufsize) { + fbuf = (char *)REALLOC(fbuf, suggested_bufsize); + if(!fbuf) { + perror("realloc()"); + exit(EX_OSERR); + } + fbuf_size = suggested_bufsize; + } + + if(on_first_pdu) { + DynamicBuffer.offset = 0; + DynamicBuffer.length = 0; + DynamicBuffer.unbits = 0; + DynamicBuffer.allocated = 0; + DynamicBuffer.bytes_shifted = 0; + DynamicBuffer.nreallocs = 0; + } + + old_offset = DynamicBuffer.bytes_shifted + DynamicBuffer.offset; + + /* Pretend immediate EOF */ + rval.code = RC_WMORE; + rval.consumed = 0; + + for(tolerate_eof = 1; /* Allow EOF first time buffer is non-empty */ + (rd = fread(fbuf, 1, fbuf_size, file)) + || feof(file) == 0 + || (tolerate_eof && DynamicBuffer.length) + ;) { + int ecbits = 0; /* Extra consumed bits in case of PER */ + char *i_bptr; + size_t i_size; + + /* + * Copy the data over, or use the original buffer. + */ + if(DynamicBuffer.allocated) { + /* Append new data into the existing dynamic buffer */ + add_bytes_to_buffer(fbuf, rd); + i_bptr = DynamicBuffer.data + DynamicBuffer.offset; + i_size = DynamicBuffer.length; + } else { + i_bptr = fbuf; + i_size = rd; + } + + DEBUG("Decoding %ld bytes", (long)i_size); + + switch(iform) { + case INP_BER: + rval = ber_decode(opt_codec_ctx, pduType, + (void **)&structure, i_bptr, i_size); + break; + case INP_XER: + rval = xer_decode(opt_codec_ctx, pduType, + (void **)&structure, i_bptr, i_size); + break; + case INP_PER: + rval = uper_decode(opt_codec_ctx, pduType, + (void **)&structure, i_bptr, i_size, 0, + DynamicBuffer.unbits); + ecbits = rval.consumed % 8; /* Extra bits */ + rval.consumed /= 8; /* Convert to value in bytes! */ + /* Check if input is byte-padded at the end */ + if(opt_ippad && ecbits && rval.code == RC_OK) { + rval.consumed++; + ecbits = 0; + } + break; + } + DEBUG("decode(%ld) consumed %ld+%db (%ld), code %d", + (long)DynamicBuffer.length, + (long)rval.consumed, ecbits, (long)i_size, + rval.code); + + if(DynamicBuffer.allocated == 0) { + /* + * Flush remainder into the intermediate buffer. + */ + if(rval.code != RC_FAIL && rval.consumed < rd) { + add_bytes_to_buffer(fbuf + rval.consumed, + rd - rval.consumed); + buffer_shift_left(0, ecbits); + DynamicBuffer.bytes_shifted = rval.consumed; + rval.consumed = 0; + ecbits = 0; + } + } + + /* + * Adjust position inside the source buffer. + */ + if(DynamicBuffer.allocated) { + DynamicBuffer.offset += rval.consumed; + DynamicBuffer.length -= rval.consumed; + } else { + DynamicBuffer.bytes_shifted += rval.consumed; + } + + switch(rval.code) { + case RC_OK: + if(ecbits) buffer_shift_left(0, ecbits); + DEBUG("RC_OK, finishing up with %ld+%d", + (long)rval.consumed, ecbits); + return structure; + case RC_WMORE: + DEBUG("RC_WMORE, continuing read=%ld, cons=%ld " + " with %ld..%ld-%ld..%ld", + (long)rd, + (long)rval.consumed, + (long)DynamicBuffer.offset, + (long)DynamicBuffer.length, + (long)DynamicBuffer.unbits, + (long)DynamicBuffer.allocated); + if(!rd) tolerate_eof--; + continue; + case RC_FAIL: + break; + } + break; + } + + /* Clean up partially decoded structure */ + ASN_STRUCT_FREE(*pduType, structure); + + new_offset = DynamicBuffer.bytes_shifted + DynamicBuffer.offset; + + /* + * Print a message and return failure only if not EOF, + * unless this is our first PDU (empty file). + */ + if(on_first_pdu + || DynamicBuffer.length + || new_offset - old_offset > ((iform == INP_XER)?sizeof("\r\n")-1:0) + ) { + DEBUG("ofp %d, no=%ld, oo=%ld, dbl=%ld", + on_first_pdu, (long)new_offset, (long)old_offset, + (long)DynamicBuffer.length); + fprintf(stderr, "%s: " + "Decode failed past byte %ld: %s\n", + name, (long)new_offset, + (rval.code == RC_WMORE) + ? "Unexpected end of input" + : "Input processing error"); +#ifndef ENOMSG +#define ENOMSG EINVAL +#endif +#ifndef EBADMSG +#define EBADMSG EINVAL +#endif + errno = (rval.code == RC_WMORE) ? ENOMSG : EBADMSG; + } else { + /* Got EOF after a few successful PDUs */ + errno = 0; + } + + return 0; +} + +/* Dump the buffer out to the specified FILE */ +static int write_out(const void *buffer, size_t size, void *key) { + FILE *fp = (FILE *)key; + return (fwrite(buffer, 1, size, fp) == size) ? 0 : -1; +} + +static int argument_is_stdin(char *av[], int idx) { + if(strcmp(av[idx], "-")) { + return 0; /* Certainly not */ + } else { + /* This might be , unless `./program -- -` */ + if(strcmp(av[-1], "--")) + return 1; + else + return 0; + } +} + +static FILE *argument_to_file(char *av[], int idx) { + return argument_is_stdin(av, idx) + ? stdin + : fopen(av[idx], "r"); +} + +static char *argument_to_name(char *av[], int idx) { + return argument_is_stdin(av, idx) + ? "standard input" + : av[idx]; +} diff --git a/projects/stargazer/plugins/other/snmp/asn1/der_encoder.c b/projects/stargazer/plugins/other/snmp/asn1/der_encoder.c new file mode 100644 index 00000000..6c859e1b --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/der_encoder.c @@ -0,0 +1,199 @@ +/*- + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include + +static ssize_t der_write_TL(ber_tlv_tag_t tag, ber_tlv_len_t len, + asn_app_consume_bytes_f *cb, void *app_key, int constructed); + +/* + * The DER encoder of any type. + */ +asn_enc_rval_t +der_encode(asn_TYPE_descriptor_t *type_descriptor, void *struct_ptr, + asn_app_consume_bytes_f *consume_bytes, void *app_key) { + + ASN_DEBUG("DER encoder invoked for %s", + type_descriptor->name); + + /* + * Invoke type-specific encoder. + */ + return type_descriptor->der_encoder(type_descriptor, + struct_ptr, /* Pointer to the destination structure */ + 0, 0, + consume_bytes, app_key); +} + +/* + * Argument type and callback necessary for der_encode_to_buffer(). + */ +typedef struct enc_to_buf_arg { + void *buffer; + size_t left; +} enc_to_buf_arg; +static int encode_to_buffer_cb(const void *buffer, size_t size, void *key) { + enc_to_buf_arg *arg = (enc_to_buf_arg *)key; + + if(arg->left < size) + return -1; /* Data exceeds the available buffer size */ + + memcpy(arg->buffer, buffer, size); + arg->buffer = ((char *)arg->buffer) + size; + arg->left -= size; + + return 0; +} + +/* + * A variant of the der_encode() which encodes the data into the provided buffer + */ +asn_enc_rval_t +der_encode_to_buffer(asn_TYPE_descriptor_t *type_descriptor, void *struct_ptr, + void *buffer, size_t buffer_size) { + enc_to_buf_arg arg; + asn_enc_rval_t ec; + + arg.buffer = buffer; + arg.left = buffer_size; + + ec = type_descriptor->der_encoder(type_descriptor, + struct_ptr, /* Pointer to the destination structure */ + 0, 0, encode_to_buffer_cb, &arg); + if(ec.encoded != -1) { + assert(ec.encoded == (ssize_t)(buffer_size - arg.left)); + /* Return the encoded contents size */ + } + return ec; +} + + +/* + * Write out leading TL[v] sequence according to the type definition. + */ +ssize_t +der_write_tags(asn_TYPE_descriptor_t *sd, + size_t struct_length, + int tag_mode, int last_tag_form, + ber_tlv_tag_t tag, /* EXPLICIT or IMPLICIT tag */ + asn_app_consume_bytes_f *cb, + void *app_key) { + ber_tlv_tag_t *tags; /* Copy of tags stream */ + int tags_count; /* Number of tags */ + size_t overall_length; + ssize_t *lens; + int i; + + ASN_DEBUG("Writing tags (%s, tm=%d, tc=%d, tag=%s, mtc=%d)", + sd->name, tag_mode, sd->tags_count, + ber_tlv_tag_string(tag), + tag_mode + ?(sd->tags_count+1 + -((tag_mode == -1) && sd->tags_count)) + :sd->tags_count + ); + + if(tag_mode) { + /* + * Instead of doing shaman dance like we do in ber_check_tags(), + * allocate a small array on the stack + * and initialize it appropriately. + */ + int stag_offset; + tags = (ber_tlv_tag_t *)alloca((sd->tags_count + 1) * sizeof(ber_tlv_tag_t)); + if(!tags) { /* Can fail on !x86 */ + errno = ENOMEM; + return -1; + } + tags_count = sd->tags_count + + 1 /* EXPLICIT or IMPLICIT tag is given */ + - ((tag_mode == -1) && sd->tags_count); + /* Copy tags over */ + tags[0] = tag; + stag_offset = -1 + ((tag_mode == -1) && sd->tags_count); + for(i = 1; i < tags_count; i++) + tags[i] = sd->tags[i + stag_offset]; + } else { + tags = sd->tags; + tags_count = sd->tags_count; + } + + /* No tags to write */ + if(tags_count == 0) + return 0; + + lens = (ssize_t *)alloca(tags_count * sizeof(lens[0])); + if(!lens) { + errno = ENOMEM; + return -1; + } + + /* + * Array of tags is initialized. + * Now, compute the size of the TLV pairs, from right to left. + */ + overall_length = struct_length; + for(i = tags_count - 1; i >= 0; --i) { + lens[i] = der_write_TL(tags[i], overall_length, 0, 0, 0); + if(lens[i] == -1) return -1; + overall_length += lens[i]; + lens[i] = overall_length - lens[i]; + } + + if(!cb) return overall_length - struct_length; + + ASN_DEBUG("%s %s TL sequence (%d elements)", + cb?"Encoding":"Estimating", sd->name, tags_count); + + /* + * Encode the TL sequence for real. + */ + for(i = 0; i < tags_count; i++) { + ssize_t len; + int _constr; + + /* Check if this tag happens to be constructed */ + _constr = (last_tag_form || i < (tags_count - 1)); + + len = der_write_TL(tags[i], lens[i], cb, app_key, _constr); + if(len == -1) return -1; + } + + return overall_length - struct_length; +} + +static ssize_t +der_write_TL(ber_tlv_tag_t tag, ber_tlv_len_t len, + asn_app_consume_bytes_f *cb, void *app_key, + int constructed) { + uint8_t buf[32]; + size_t size = 0; + int buf_size = cb?sizeof(buf):0; + ssize_t tmp; + + /* Serialize tag (T from TLV) into possibly zero-length buffer */ + tmp = ber_tlv_tag_serialize(tag, buf, buf_size); + if(tmp == -1 || tmp > (ssize_t)sizeof(buf)) return -1; + size += tmp; + + /* Serialize length (L from TLV) into possibly zero-length buffer */ + tmp = der_tlv_length_serialize(len, buf+size, buf_size?buf_size-size:0); + if(tmp == -1) return -1; + size += tmp; + + if(size > sizeof(buf)) + return -1; + + /* + * If callback is specified, invoke it, and check its return value. + */ + if(cb) { + if(constructed) *buf |= 0x20; + if(cb(buf, size, app_key) < 0) + return -1; + } + + return size; +} diff --git a/projects/stargazer/plugins/other/snmp/asn1/der_encoder.h b/projects/stargazer/plugins/other/snmp/asn1/der_encoder.h new file mode 100644 index 00000000..4e2fb06c --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/der_encoder.h @@ -0,0 +1,67 @@ +/*- + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _DER_ENCODER_H_ +#define _DER_ENCODER_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +struct asn_TYPE_descriptor_s; /* Forward declaration */ + +/* + * The DER encoder of any type. May be invoked by the application. + */ +asn_enc_rval_t der_encode(struct asn_TYPE_descriptor_s *type_descriptor, + void *struct_ptr, /* Structure to be encoded */ + asn_app_consume_bytes_f *consume_bytes_cb, + void *app_key /* Arbitrary callback argument */ + ); + +/* A variant of der_encode() which encodes data into the pre-allocated buffer */ +asn_enc_rval_t der_encode_to_buffer( + struct asn_TYPE_descriptor_s *type_descriptor, + void *struct_ptr, /* Structure to be encoded */ + void *buffer, /* Pre-allocated buffer */ + size_t buffer_size /* Initial buffer size (maximum) */ + ); + +/* + * Type of the generic DER encoder. + */ +typedef asn_enc_rval_t (der_type_encoder_f)( + struct asn_TYPE_descriptor_s *type_descriptor, + void *struct_ptr, /* Structure to be encoded */ + int tag_mode, /* {-1,0,1}: IMPLICIT, no, EXPLICIT */ + ber_tlv_tag_t tag, + asn_app_consume_bytes_f *consume_bytes_cb, /* Callback */ + void *app_key /* Arbitrary callback argument */ + ); + + +/******************************* + * INTERNALLY USEFUL FUNCTIONS * + *******************************/ + +/* + * Write out leading TL[v] sequence according to the type definition. + */ +ssize_t der_write_tags( + struct asn_TYPE_descriptor_s *type_descriptor, + size_t struct_length, + int tag_mode, /* {-1,0,1}: IMPLICIT, no, EXPLICIT */ + int last_tag_form, /* {0,!0}: prim, constructed */ + ber_tlv_tag_t tag, + asn_app_consume_bytes_f *consume_bytes_cb, + void *app_key + ); + +#ifdef __cplusplus +} +#endif + +#endif /* _DER_ENCODER_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/per_decoder.c b/projects/stargazer/plugins/other/snmp/asn1/per_decoder.c new file mode 100644 index 00000000..16dee369 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/per_decoder.c @@ -0,0 +1,55 @@ +#include +#include +#include + +asn_dec_rval_t +uper_decode(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, void **sptr, const void *buffer, size_t size, int skip_bits, int unused_bits) { + asn_codec_ctx_t s_codec_ctx; + asn_dec_rval_t rval; + asn_per_data_t pd; + + if(skip_bits < 0 || skip_bits > 7 + || unused_bits < 0 || unused_bits > 7 + || (unused_bits > 0 && !size)) + _ASN_DECODE_FAILED; + + /* + * Stack checker requires that the codec context + * must be allocated on the stack. + */ + if(opt_codec_ctx) { + if(opt_codec_ctx->max_stack_size) { + s_codec_ctx = *opt_codec_ctx; + opt_codec_ctx = &s_codec_ctx; + } + } else { + /* If context is not given, be security-conscious anyway */ + memset(&s_codec_ctx, 0, sizeof(s_codec_ctx)); + s_codec_ctx.max_stack_size = _ASN_DEFAULT_STACK_MAX; + opt_codec_ctx = &s_codec_ctx; + } + + /* Fill in the position indicator */ + pd.buffer = (const uint8_t *)buffer; + pd.nboff = skip_bits; + pd.nbits = 8 * size - unused_bits; /* 8 is CHAR_BIT from */ + if(pd.nboff > pd.nbits) + _ASN_DECODE_FAILED; + + /* + * Invoke type-specific decoder. + */ + if(!td->uper_decoder) + _ASN_DECODE_FAILED; /* PER is not compiled in */ + rval = td->uper_decoder(opt_codec_ctx, td, 0, sptr, &pd); + if(rval.code == RC_OK) { + /* Return the number of consumed bits */ + rval.consumed = ((pd.buffer - (const uint8_t *)buffer) << 3) + + pd.nboff - skip_bits; + } else { + /* PER codec is not a restartable */ + rval.consumed = 0; + } + return rval; +} + diff --git a/projects/stargazer/plugins/other/snmp/asn1/per_decoder.h b/projects/stargazer/plugins/other/snmp/asn1/per_decoder.h new file mode 100644 index 00000000..26aaf594 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/per_decoder.h @@ -0,0 +1,44 @@ +/*- + * Copyright (c) 2005 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _PER_DECODER_H_ +#define _PER_DECODER_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +struct asn_TYPE_descriptor_s; /* Forward declaration */ + +/* + * Unaligned PER decoder of any ASN.1 type. May be invoked by the application. + */ +asn_dec_rval_t uper_decode(struct asn_codec_ctx_s *opt_codec_ctx, + struct asn_TYPE_descriptor_s *type_descriptor, /* Type to decode */ + void **struct_ptr, /* Pointer to a target structure's pointer */ + const void *buffer, /* Data to be decoded */ + size_t size, /* Size of data buffer */ + int skip_bits, /* Number of unused leading bits, 0..7 */ + int unused_bits /* Number of unused tailing bits, 0..7 */ + ); + + +/* + * Type of the type-specific PER decoder function. + */ +typedef asn_dec_rval_t (per_type_decoder_f)(asn_codec_ctx_t *opt_codec_ctx, + struct asn_TYPE_descriptor_s *type_descriptor, + asn_per_constraints_t *constraints, + void **struct_ptr, + asn_per_data_t *per_data + ); + +#ifdef __cplusplus +} +#endif + +#endif /* _PER_DECODER_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/per_encoder.c b/projects/stargazer/plugins/other/snmp/asn1/per_encoder.c new file mode 100644 index 00000000..614dd233 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/per_encoder.c @@ -0,0 +1,95 @@ +#include +#include +#include + +/* Flush partially filled buffer */ +static int _uper_encode_flush_outp(asn_per_outp_t *po); + +asn_enc_rval_t +uper_encode(asn_TYPE_descriptor_t *td, void *sptr, asn_app_consume_bytes_f *cb, void *app_key) { + asn_per_outp_t po; + asn_enc_rval_t er; + + /* + * Invoke type-specific encoder. + */ + if(!td || !td->uper_encoder) + _ASN_ENCODE_FAILED; /* PER is not compiled in */ + + po.buffer = po.tmpspace; + po.nboff = 0; + po.nbits = 8 * sizeof(po.tmpspace); + po.outper = cb; + po.op_key = app_key; + po.flushed_bytes = 0; + + er = td->uper_encoder(td, 0, sptr, &po); + if(er.encoded != -1) { + size_t bits_to_flush; + + bits_to_flush = ((po.buffer - po.tmpspace) << 3) + po.nboff; + + /* Set number of bits encoded to a firm value */ + er.encoded = (po.flushed_bytes << 3) + bits_to_flush; + + if(_uper_encode_flush_outp(&po)) + _ASN_ENCODE_FAILED; + } + + return er; +} + +/* + * Argument type and callback necessary for uper_encode_to_buffer(). + */ +typedef struct enc_to_buf_arg { + void *buffer; + size_t left; +} enc_to_buf_arg; +static int encode_to_buffer_cb(const void *buffer, size_t size, void *key) { + enc_to_buf_arg *arg = (enc_to_buf_arg *)key; + + if(arg->left < size) + return -1; /* Data exceeds the available buffer size */ + + memcpy(arg->buffer, buffer, size); + arg->buffer = ((char *)arg->buffer) + size; + arg->left -= size; + + return 0; +} + +asn_enc_rval_t +uper_encode_to_buffer(asn_TYPE_descriptor_t *td, void *sptr, void *buffer, size_t buffer_size) { + enc_to_buf_arg key; + + /* + * Invoke type-specific encoder. + */ + if(!td || !td->uper_encoder) + _ASN_ENCODE_FAILED; /* PER is not compiled in */ + + key.buffer = buffer; + key.left = buffer_size; + + ASN_DEBUG("Encoding \"%s\" using UNALIGNED PER", td->name); + + return uper_encode(td, sptr, encode_to_buffer_cb, &key); +} + +static int +_uper_encode_flush_outp(asn_per_outp_t *po) { + uint8_t *buf; + + if(po->nboff == 0 && po->buffer == po->tmpspace) + return 0; + + buf = po->buffer + (po->nboff >> 3); + /* Make sure we account for the last, partially filled */ + if(po->nboff & 0x07) { + buf[0] &= 0xff << (8 - (po->nboff & 0x07)); + buf++; + } + + return po->outper(po->tmpspace, buf - po->tmpspace, po->op_key); +} diff --git a/projects/stargazer/plugins/other/snmp/asn1/per_encoder.h b/projects/stargazer/plugins/other/snmp/asn1/per_encoder.h new file mode 100644 index 00000000..9ac130b7 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/per_encoder.h @@ -0,0 +1,49 @@ +/*- + * Copyright (c) 2006 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _PER_ENCODER_H_ +#define _PER_ENCODER_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +struct asn_TYPE_descriptor_s; /* Forward declaration */ + +/* + * Unaligned PER encoder of any ASN.1 type. May be invoked by the application. + */ +asn_enc_rval_t uper_encode(struct asn_TYPE_descriptor_s *type_descriptor, + void *struct_ptr, /* Structure to be encoded */ + asn_app_consume_bytes_f *consume_bytes_cb, /* Data collector */ + void *app_key /* Arbitrary callback argument */ +); + +/* A variant of uper_encode() which encodes data into the existing buffer */ +asn_enc_rval_t uper_encode_to_buffer( + struct asn_TYPE_descriptor_s *type_descriptor, + void *struct_ptr, /* Structure to be encoded */ + void *buffer, /* Pre-allocated buffer */ + size_t buffer_size /* Initial buffer size (max) */ +); + + +/* + * Type of the generic PER encoder function. + */ +typedef asn_enc_rval_t (per_type_encoder_f)( + struct asn_TYPE_descriptor_s *type_descriptor, + asn_per_constraints_t *constraints, + void *struct_ptr, + asn_per_outp_t *per_output +); + +#ifdef __cplusplus +} +#endif + +#endif /* _PER_ENCODER_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/per_support.c b/projects/stargazer/plugins/other/snmp/asn1/per_support.c new file mode 100644 index 00000000..c8344193 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/per_support.c @@ -0,0 +1,318 @@ +/* + * Copyright (c) 2005, 2006 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include +#include + +/* + * Extract a small number of bits (<= 31) from the specified PER data pointer. + */ +int32_t +per_get_few_bits(asn_per_data_t *pd, int nbits) { + size_t off; /* Next after last bit offset */ + uint32_t accum; + const uint8_t *buf; + + if(nbits < 0 || pd->nboff + nbits > pd->nbits) + return -1; + + ASN_DEBUG("[PER get %d bits from %p+%d bits]", + nbits, pd->buffer, pd->nboff); + + /* + * Normalize position indicator. + */ + if(pd->nboff >= 8) { + pd->buffer += (pd->nboff >> 3); + pd->nbits -= (pd->nboff & ~0x07); + pd->nboff &= 0x07; + } + off = (pd->nboff += nbits); + buf = pd->buffer; + + /* + * Extract specified number of bits. + */ + if(off <= 8) + accum = nbits ? (buf[0]) >> (8 - off) : 0; + else if(off <= 16) + accum = ((buf[0] << 8) + buf[1]) >> (16 - off); + else if(off <= 24) + accum = ((buf[0] << 16) + (buf[1] << 8) + buf[2]) >> (24 - off); + else if(off <= 31) + accum = ((buf[0] << 24) + (buf[1] << 16) + + (buf[2] << 8) + (buf[3])) >> (32 - off); + else if(nbits <= 31) { + asn_per_data_t tpd = *pd; + /* Here are we with our 31-bits limit plus 1..7 bits offset. */ + tpd.nboff -= nbits; + accum = per_get_few_bits(&tpd, nbits - 24) << 24; + accum |= per_get_few_bits(&tpd, 24); + } else { + pd->nboff -= nbits; /* Oops, revert back */ + return -1; + } + + return (accum & (((uint32_t)1 << nbits) - 1)); +} + +/* + * Extract a large number of bits from the specified PER data pointer. + */ +int +per_get_many_bits(asn_per_data_t *pd, uint8_t *dst, int alright, int nbits) { + int32_t value; + + if(alright && (nbits & 7)) { + /* Perform right alignment of a first few bits */ + value = per_get_few_bits(pd, nbits & 0x07); + if(value < 0) return -1; + *dst++ = value; /* value is already right-aligned */ + nbits &= ~7; + } + + while(nbits) { + if(nbits >= 24) { + value = per_get_few_bits(pd, 24); + if(value < 0) return -1; + *(dst++) = value >> 16; + *(dst++) = value >> 8; + *(dst++) = value; + nbits -= 24; + } else { + value = per_get_few_bits(pd, nbits); + if(value < 0) return -1; + if(nbits & 7) { /* implies left alignment */ + value <<= 8 - (nbits & 7), + nbits += 8 - (nbits & 7); + if(nbits > 24) + *dst++ = value >> 24; + } + if(nbits > 16) + *dst++ = value >> 16; + if(nbits > 8) + *dst++ = value >> 8; + *dst++ = value; + break; + } + } + + return 0; +} + +/* + * Get the length "n" from the stream. + */ +ssize_t +uper_get_length(asn_per_data_t *pd, int ebits, int *repeat) { + ssize_t value; + + *repeat = 0; + + if(ebits >= 0) return per_get_few_bits(pd, ebits); + + value = per_get_few_bits(pd, 8); + if(value < 0) return -1; + if((value & 128) == 0) /* #10.9.3.6 */ + return (value & 0x7F); + if((value & 64) == 0) { /* #10.9.3.7 */ + value = ((value & 63) << 8) | per_get_few_bits(pd, 8); + if(value < 0) return -1; + return value; + } + value &= 63; /* this is "m" from X.691, #10.9.3.8 */ + if(value < 1 || value > 4) + return -1; + *repeat = 1; + return (16384 * value); +} + +/* + * Get the normally small non-negative whole number. + * X.691, #10.6 + */ +ssize_t +uper_get_nsnnwn(asn_per_data_t *pd) { + ssize_t value; + + value = per_get_few_bits(pd, 7); + if(value & 64) { /* implicit (value < 0) */ + value &= 63; + value <<= 2; + value |= per_get_few_bits(pd, 2); + if(value & 128) /* implicit (value < 0) */ + return -1; + if(value == 0) + return 0; + if(value >= 3) + return -1; + value = per_get_few_bits(pd, 8 * value); + return value; + } + + return value; +} + +/* + * Put the normally small non-negative whole number. + * X.691, #10.6 + */ +int +uper_put_nsnnwn(asn_per_outp_t *po, int n) { + int bytes; + + if(n <= 63) { + if(n < 0) return -1; + return per_put_few_bits(po, n, 7); + } + if(n < 256) + bytes = 1; + else if(n < 65536) + bytes = 2; + else if(n < 256 * 65536) + bytes = 3; + else + return -1; /* This is not a "normally small" value */ + if(per_put_few_bits(po, bytes, 8)) + return -1; + + return per_put_few_bits(po, n, 8 * bytes); +} + + +/* + * Put a small number of bits (<= 31). + */ +int +per_put_few_bits(asn_per_outp_t *po, uint32_t bits, int obits) { + size_t off; /* Next after last bit offset */ + size_t omsk; /* Existing last byte meaningful bits mask */ + uint8_t *buf; + + if(obits <= 0 || obits >= 32) return obits ? -1 : 0; + + ASN_DEBUG("[PER put %d bits to %p+%d bits]", + obits, po->buffer, po->nboff); + + /* + * Normalize position indicator. + */ + if(po->nboff >= 8) { + po->buffer += (po->nboff >> 3); + po->nbits -= (po->nboff & ~0x07); + po->nboff &= 0x07; + } + + /* + * Flush whole-bytes output, if necessary. + */ + if(po->nboff + obits > po->nbits) { + int complete_bytes = (po->buffer - po->tmpspace); + if(po->outper(po->buffer, complete_bytes, po->op_key) < 0) + return -1; + if(po->nboff) + po->tmpspace[0] = po->buffer[0]; + po->buffer = po->tmpspace; + po->nbits = 8 * sizeof(po->tmpspace); + po->flushed_bytes += complete_bytes; + } + + /* + * Now, due to sizeof(tmpspace), we are guaranteed large enough space. + */ + buf = po->buffer; + omsk = ~((1 << (8 - po->nboff)) - 1); + off = (po->nboff += obits); + + /* Clear data of debris before meaningful bits */ + bits &= (((uint32_t)1 << obits) - 1); + + ASN_DEBUG("[PER out %d %u/%x (t=%d,o=%d) %x&%x=%x]", obits, bits, bits, + po->nboff - obits, off, buf[0], omsk&0xff, buf[0] & omsk); + + if(off <= 8) /* Completely within 1 byte */ + bits <<= (8 - off), + buf[0] = (buf[0] & omsk) | bits; + else if(off <= 16) + bits <<= (16 - off), + buf[0] = (buf[0] & omsk) | (bits >> 8), + buf[1] = bits; + else if(off <= 24) + bits <<= (24 - off), + buf[0] = (buf[0] & omsk) | (bits >> 16), + buf[1] = bits >> 8, + buf[2] = bits; + else if(off <= 31) + bits <<= (32 - off), + buf[0] = (buf[0] & omsk) | (bits >> 24), + buf[1] = bits >> 16, + buf[2] = bits >> 8, + buf[3] = bits; + else { + ASN_DEBUG("->[PER out split %d]", obits); + per_put_few_bits(po, bits >> 8, 24); + per_put_few_bits(po, bits, obits - 24); + ASN_DEBUG("<-[PER out split %d]", obits); + } + + ASN_DEBUG("[PER out %u/%x => %02x buf+%d]", + bits, bits, buf[0], po->buffer - po->tmpspace); + + return 0; +} + + +/* + * Output a large number of bits. + */ +int +per_put_many_bits(asn_per_outp_t *po, const uint8_t *src, int nbits) { + + while(nbits) { + uint32_t value; + + if(nbits >= 24) { + value = (src[0] << 16) | (src[1] << 8) | src[2]; + src += 3; + nbits -= 24; + if(per_put_few_bits(po, value, 24)) + return -1; + } else { + value = src[0]; + if(nbits > 8) + value = (value << 8) | src[1]; + if(nbits > 16) + value = (value << 8) | src[2]; + if(nbits & 0x07) + value >>= (8 - (nbits & 0x07)); + if(per_put_few_bits(po, value, nbits)) + return -1; + break; + } + } + + return 0; +} + +/* + * Put the length "n" (or part of it) into the stream. + */ +ssize_t +uper_put_length(asn_per_outp_t *po, size_t length) { + + if(length <= 127) /* #10.9.3.6 */ + return per_put_few_bits(po, length, 8) + ? -1 : (ssize_t)length; + else if(length < 16384) /* #10.9.3.7 */ + return per_put_few_bits(po, length|0x8000, 16) + ? -1 : (ssize_t)length; + + length >>= 14; + if(length > 4) length = 4; + + return per_put_few_bits(po, 0xC0 | length, 8) + ? -1 : (ssize_t)(length << 14); +} + diff --git a/projects/stargazer/plugins/other/snmp/asn1/per_support.h b/projects/stargazer/plugins/other/snmp/asn1/per_support.h new file mode 100644 index 00000000..420bb83c --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/per_support.h @@ -0,0 +1,105 @@ +/* + * Copyright (c) 2005, 2006 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _PER_SUPPORT_H_ +#define _PER_SUPPORT_H_ + +#include /* Platform-specific types */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Pre-computed PER constraints. + */ +typedef struct asn_per_constraint_s { + enum asn_per_constraint_flags { + APC_UNCONSTRAINED = 0x0, /* No PER visible constraints */ + APC_SEMI_CONSTRAINED = 0x1, /* Constrained at "lb" */ + APC_CONSTRAINED = 0x2, /* Fully constrained */ + APC_EXTENSIBLE = 0x4 /* May have extension */ + } flags; + int range_bits; /* Full number of bits in the range */ + int effective_bits; /* Effective bits */ + long lower_bound; /* "lb" value */ + long upper_bound; /* "ub" value */ +} asn_per_constraint_t; +typedef struct asn_per_constraints_s { + asn_per_constraint_t value; + asn_per_constraint_t size; +} asn_per_constraints_t; + +/* + * This structure describes a position inside an incoming PER bit stream. + */ +typedef struct asn_per_data_s { + const uint8_t *buffer; /* Pointer to the octet stream */ + size_t nboff; /* Bit offset to the meaningful bit */ + size_t nbits; /* Number of bits in the stream */ +} asn_per_data_t; + +/* + * Extract a small number of bits (<= 31) from the specified PER data pointer. + * This function returns -1 if the specified number of bits could not be + * extracted due to EOD or other conditions. + */ +int32_t per_get_few_bits(asn_per_data_t *per_data, int get_nbits); + +/* + * Extract a large number of bits from the specified PER data pointer. + * This function returns -1 if the specified number of bits could not be + * extracted due to EOD or other conditions. + */ +int per_get_many_bits(asn_per_data_t *pd, uint8_t *dst, int right_align, + int get_nbits); + +/* + * Get the length "n" from the Unaligned PER stream. + */ +ssize_t uper_get_length(asn_per_data_t *pd, + int effective_bound_bits, + int *repeat); + +/* + * Get the normally small non-negative whole number. + */ +ssize_t uper_get_nsnnwn(asn_per_data_t *pd); + +/* + * This structure supports forming PER output. + */ +typedef struct asn_per_outp_s { + uint8_t *buffer; /* Pointer into the (tmpspace) */ + size_t nboff; /* Bit offset to the meaningful bit */ + size_t nbits; /* Number of bits left in (tmpspace) */ + uint8_t tmpspace[32]; /* Preliminary storage to hold data */ + int (*outper)(const void *data, size_t size, void *op_key); + void *op_key; /* Key for (outper) data callback */ + size_t flushed_bytes; /* Bytes already flushed through (outper) */ +} asn_per_outp_t; + +/* Output a small number of bits (<= 31) */ +int per_put_few_bits(asn_per_outp_t *per_data, uint32_t bits, int obits); + +/* Output a large number of bits */ +int per_put_many_bits(asn_per_outp_t *po, const uint8_t *src, int put_nbits); + +/* + * Put the length "n" to the Unaligned PER stream. + * This function returns the number of units which may be flushed + * in the next units saving iteration. + */ +ssize_t uper_put_length(asn_per_outp_t *po, size_t whole_length); + +/* + * Put the normally small non-negative whole number. + */ +int uper_put_nsnnwn(asn_per_outp_t *po, int n); + +#ifdef __cplusplus +} +#endif + +#endif /* _PER_SUPPORT_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/xer_decoder.c b/projects/stargazer/plugins/other/snmp/asn1/xer_decoder.c new file mode 100644 index 00000000..161dc78c --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/xer_decoder.c @@ -0,0 +1,363 @@ +/* + * Copyright (c) 2004, 2005 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include +#include /* XER/XML parsing support */ + + +/* + * Decode the XER encoding of a given type. + */ +asn_dec_rval_t +xer_decode(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, + void **struct_ptr, const void *buffer, size_t size) { + asn_codec_ctx_t s_codec_ctx; + + /* + * Stack checker requires that the codec context + * must be allocated on the stack. + */ + if(opt_codec_ctx) { + if(opt_codec_ctx->max_stack_size) { + s_codec_ctx = *opt_codec_ctx; + opt_codec_ctx = &s_codec_ctx; + } + } else { + /* If context is not given, be security-conscious anyway */ + memset(&s_codec_ctx, 0, sizeof(s_codec_ctx)); + s_codec_ctx.max_stack_size = _ASN_DEFAULT_STACK_MAX; + opt_codec_ctx = &s_codec_ctx; + } + + /* + * Invoke type-specific decoder. + */ + return td->xer_decoder(opt_codec_ctx, td, struct_ptr, 0, buffer, size); +} + + + +struct xer__cb_arg { + pxml_chunk_type_e chunk_type; + size_t chunk_size; + const void *chunk_buf; + int callback_not_invoked; +}; + +static int +xer__token_cb(pxml_chunk_type_e type, const void *_chunk_data, size_t _chunk_size, void *key) { + struct xer__cb_arg *arg = (struct xer__cb_arg *)key; + arg->chunk_type = type; + arg->chunk_size = _chunk_size; + arg->chunk_buf = _chunk_data; + arg->callback_not_invoked = 0; + return -1; /* Terminate the XML parsing */ +} + +/* + * Fetch the next token from the XER/XML stream. + */ +ssize_t +xer_next_token(int *stateContext, const void *buffer, size_t size, pxer_chunk_type_e *ch_type) { + struct xer__cb_arg arg; + int new_stateContext = *stateContext; + ssize_t ret; + + arg.callback_not_invoked = 1; + ret = pxml_parse(&new_stateContext, buffer, size, xer__token_cb, &arg); + if(ret < 0) return -1; + if(arg.callback_not_invoked) { + assert(ret == 0); /* No data was consumed */ + return 0; /* Try again with more data */ + } else { + assert(arg.chunk_size); + assert(arg.chunk_buf == buffer); + } + + /* + * Translate the XML chunk types into more convenient ones. + */ + switch(arg.chunk_type) { + case PXML_TEXT: + *ch_type = PXER_TEXT; + break; + case PXML_TAG: return 0; /* Want more */ + case PXML_TAG_END: + *ch_type = PXER_TAG; + break; + case PXML_COMMENT: + case PXML_COMMENT_END: + *ch_type = PXER_COMMENT; + break; + } + + *stateContext = new_stateContext; + return arg.chunk_size; +} + +#define CSLASH 0x2f /* '/' */ +#define LANGLE 0x3c /* '<' */ +#define RANGLE 0x3e /* '>' */ + +xer_check_tag_e +xer_check_tag(const void *buf_ptr, int size, const char *need_tag) { + const char *buf = (const char *)buf_ptr; + const char *end; + xer_check_tag_e ct = XCT_OPENING; + + if(size < 2 || buf[0] != LANGLE || buf[size-1] != RANGLE) { + if(size >= 2) + ASN_DEBUG("Broken XML tag: \"%c...%c\"", buf[0], buf[size - 1]); + return XCT_BROKEN; + } + + /* + * Determine the tag class. + */ + if(buf[1] == CSLASH) { + buf += 2; /* advance past "" */ + ct = XCT_CLOSING; + if(size > 0 && buf[size-1] == CSLASH) + return XCT_BROKEN; /* */ + } else { + buf++; /* advance past "<" */ + size -= 2; /* strip "<" and ">" */ + if(size > 0 && buf[size-1] == CSLASH) { + ct = XCT_BOTH; + size--; /* One more, for "/" */ + } + } + + /* Sometimes we don't care about the tag */ + if(!need_tag || !*need_tag) + return (xer_check_tag_e)(XCT__UNK__MASK | ct); + + /* + * Determine the tag name. + */ + for(end = buf + size; buf < end; buf++, need_tag++) { + int b = *buf, n = *need_tag; + if(b != n) { + if(n == 0) { + switch(b) { + case 0x09: case 0x0a: case 0x0c: case 0x0d: + case 0x20: + /* "": whitespace is normal */ + return ct; + } + } + return (xer_check_tag_e)(XCT__UNK__MASK | ct); + } + if(b == 0) + return XCT_BROKEN; /* Embedded 0 in buf?! */ + } + if(*need_tag) + return (xer_check_tag_e)(XCT__UNK__MASK | ct); + + return ct; +} + + +#undef ADVANCE +#define ADVANCE(num_bytes) do { \ + size_t num = (num_bytes); \ + buf_ptr = ((const char *)buf_ptr) + num; \ + size -= num; \ + consumed_myself += num; \ + } while(0) + +#undef RETURN +#define RETURN(_code) do { \ + rval.code = _code; \ + rval.consumed = consumed_myself; \ + if(rval.code != RC_OK) \ + ASN_DEBUG("Failed with %d", rval.code); \ + return rval; \ + } while(0) + +#define XER_GOT_BODY(chunk_buf, chunk_size, size) do { \ + ssize_t converted_size = body_receiver \ + (struct_key, chunk_buf, chunk_size, \ + (size_t)chunk_size < size); \ + if(converted_size == -1) RETURN(RC_FAIL); \ + if(converted_size == 0 \ + && size == (size_t)chunk_size) \ + RETURN(RC_WMORE); \ + chunk_size = converted_size; \ + } while(0) +#define XER_GOT_EMPTY() do { \ + if(body_receiver(struct_key, 0, 0, size > 0) == -1) \ + RETURN(RC_FAIL); \ + } while(0) + +/* + * Generalized function for decoding the primitive values. + */ +asn_dec_rval_t +xer_decode_general(asn_codec_ctx_t *opt_codec_ctx, + asn_struct_ctx_t *ctx, /* Type decoder context */ + void *struct_key, + const char *xml_tag, /* Expected XML tag */ + const void *buf_ptr, size_t size, + int (*opt_unexpected_tag_decoder) + (void *struct_key, const void *chunk_buf, size_t chunk_size), + ssize_t (*body_receiver) + (void *struct_key, const void *chunk_buf, size_t chunk_size, + int have_more) + ) { + + asn_dec_rval_t rval; + ssize_t consumed_myself = 0; + + (void)opt_codec_ctx; + + /* + * Phases of XER/XML processing: + * Phase 0: Check that the opening tag matches our expectations. + * Phase 1: Processing body and reacting on closing tag. + */ + if(ctx->phase > 1) RETURN(RC_FAIL); + for(;;) { + pxer_chunk_type_e ch_type; /* XER chunk type */ + ssize_t ch_size; /* Chunk size */ + xer_check_tag_e tcv; /* Tag check value */ + + /* + * Get the next part of the XML stream. + */ + ch_size = xer_next_token(&ctx->context, buf_ptr, size, + &ch_type); + switch(ch_size) { + case -1: RETURN(RC_FAIL); + case 0: + RETURN(RC_WMORE); + default: + switch(ch_type) { + case PXER_COMMENT: /* Got XML comment */ + ADVANCE(ch_size); /* Skip silently */ + continue; + case PXER_TEXT: + if(ctx->phase == 0) { + /* + * We have to ignore whitespace here, + * but in order to be forward compatible + * with EXTENDED-XER (EMBED-VALUES, #25) + * any text is just ignored here. + */ + } else { + XER_GOT_BODY(buf_ptr, ch_size, size); + } + ADVANCE(ch_size); + continue; + case PXER_TAG: + break; /* Check the rest down there */ + } + } + + assert(ch_type == PXER_TAG && size); + + tcv = xer_check_tag(buf_ptr, ch_size, xml_tag); + /* + * Phase 0: + * Expecting the opening tag + * for the type being processed. + * Phase 1: + * Waiting for the closing XML tag. + */ + switch(tcv) { + case XCT_BOTH: + if(ctx->phase) break; + /* Finished decoding of an empty element */ + XER_GOT_EMPTY(); + ADVANCE(ch_size); + ctx->phase = 2; /* Phase out */ + RETURN(RC_OK); + case XCT_OPENING: + if(ctx->phase) break; + ADVANCE(ch_size); + ctx->phase = 1; /* Processing body phase */ + continue; + case XCT_CLOSING: + if(!ctx->phase) break; + ADVANCE(ch_size); + ctx->phase = 2; /* Phase out */ + RETURN(RC_OK); + case XCT_UNKNOWN_BO: + /* + * Certain tags in the body may be expected. + */ + if(opt_unexpected_tag_decoder + && opt_unexpected_tag_decoder(struct_key, + buf_ptr, ch_size) >= 0) { + /* Tag's processed fine */ + ADVANCE(ch_size); + if(!ctx->phase) { + /* We are not expecting + * the closing tag anymore. */ + ctx->phase = 2; /* Phase out */ + RETURN(RC_OK); + } + continue; + } + /* Fall through */ + default: + break; /* Unexpected tag */ + } + + ASN_DEBUG("Unexpected XML tag (expected \"%s\")", xml_tag); + break; /* Dark and mysterious things have just happened */ + } + + RETURN(RC_FAIL); +} + + +int +xer_is_whitespace(const void *chunk_buf, size_t chunk_size) { + const char *p = (const char *)chunk_buf; + const char *pend = p + chunk_size; + + for(; p < pend; p++) { + switch(*p) { + /* X.693, #8.1.4 + * HORISONTAL TAB (9) + * LINE FEED (10) + * CARRIAGE RETURN (13) + * SPACE (32) + */ + case 0x09: case 0x0a: case 0x0d: case 0x20: + break; + default: + return 0; + } + } + return 1; /* All whitespace */ +} + +/* + * This is a vastly simplified, non-validating XML tree skipper. + */ +int +xer_skip_unknown(xer_check_tag_e tcv, ber_tlv_len_t *depth) { + assert(*depth > 0); + switch(tcv) { + case XCT_BOTH: + case XCT_UNKNOWN_BO: + /* These negate each other. */ + return 0; + case XCT_OPENING: + case XCT_UNKNOWN_OP: + ++(*depth); + return 0; + case XCT_CLOSING: + case XCT_UNKNOWN_CL: + if(--(*depth) == 0) + return (tcv == XCT_CLOSING) ? 2 : 1; + return 0; + default: + return -1; + } +} diff --git a/projects/stargazer/plugins/other/snmp/asn1/xer_decoder.h b/projects/stargazer/plugins/other/snmp/asn1/xer_decoder.h new file mode 100644 index 00000000..cf0d846f --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/xer_decoder.h @@ -0,0 +1,106 @@ +/*- + * Copyright (c) 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _XER_DECODER_H_ +#define _XER_DECODER_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +struct asn_TYPE_descriptor_s; /* Forward declaration */ + +/* + * The XER decoder of any ASN.1 type. May be invoked by the application. + */ +asn_dec_rval_t xer_decode(struct asn_codec_ctx_s *opt_codec_ctx, + struct asn_TYPE_descriptor_s *type_descriptor, + void **struct_ptr, /* Pointer to a target structure's pointer */ + const void *buffer, /* Data to be decoded */ + size_t size /* Size of data buffer */ + ); + +/* + * Type of the type-specific XER decoder function. + */ +typedef asn_dec_rval_t (xer_type_decoder_f)(asn_codec_ctx_t *opt_codec_ctx, + struct asn_TYPE_descriptor_s *type_descriptor, + void **struct_ptr, + const char *opt_mname, /* Member name */ + const void *buf_ptr, size_t size + ); + +/******************************* + * INTERNALLY USEFUL FUNCTIONS * + *******************************/ + +/* + * Generalized function for decoding the primitive values. + * Used by more specialized functions, such as OCTET_STRING_decode_xer_utf8 + * and others. This function should not be used by applications, as its API + * is subject to changes. + */ +asn_dec_rval_t xer_decode_general(asn_codec_ctx_t *opt_codec_ctx, + asn_struct_ctx_t *ctx, /* Type decoder context */ + void *struct_key, /* Treated as opaque pointer */ + const char *xml_tag, /* Expected XML tag name */ + const void *buf_ptr, size_t size, + int (*opt_unexpected_tag_decoder) + (void *struct_key, const void *chunk_buf, size_t chunk_size), + ssize_t (*body_receiver) + (void *struct_key, const void *chunk_buf, size_t chunk_size, + int have_more) + ); + + +/* + * Fetch the next XER (XML) token from the stream. + * The function returns the number of bytes occupied by the chunk type, + * returned in the _ch_type. The _ch_type is only set (and valid) when + * the return value is greater than 0. + */ + typedef enum pxer_chunk_type { + PXER_TAG, /* Complete XER tag */ + PXER_TEXT, /* Plain text between XER tags */ + PXER_COMMENT /* A comment, may be part of */ + } pxer_chunk_type_e; +ssize_t xer_next_token(int *stateContext, + const void *buffer, size_t size, pxer_chunk_type_e *_ch_type); + +/* + * This function checks the buffer against the tag name is expected to occur. + */ + typedef enum xer_check_tag { + XCT_BROKEN = 0, /* The tag is broken */ + XCT_OPENING = 1, /* This is the tag */ + XCT_CLOSING = 2, /* This is the tag */ + XCT_BOTH = 3, /* This is the tag */ + XCT__UNK__MASK = 4, /* Mask of everything unexpected */ + XCT_UNKNOWN_OP = 5, /* Unexpected tag */ + XCT_UNKNOWN_CL = 6, /* Unexpected tag */ + XCT_UNKNOWN_BO = 7 /* Unexpected tag */ + } xer_check_tag_e; +xer_check_tag_e xer_check_tag(const void *buf_ptr, int size, + const char *need_tag); + +/* + * Check whether this buffer consists of entirely XER whitespace characters. + * RETURN VALUES: + * 1: Whitespace or empty string + * 0: Non-whitespace + */ +int xer_is_whitespace(const void *chunk_buf, size_t chunk_size); + +/* + * Skip the series of anticipated extensions. + */ +int xer_skip_unknown(xer_check_tag_e tcv, ber_tlv_len_t *depth); + +#ifdef __cplusplus +} +#endif + +#endif /* _XER_DECODER_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/xer_encoder.c b/projects/stargazer/plugins/other/snmp/asn1/xer_encoder.c new file mode 100644 index 00000000..aa7cf040 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/xer_encoder.c @@ -0,0 +1,67 @@ +/*- + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include +#include + +/* + * The XER encoder of any type. May be invoked by the application. + */ +asn_enc_rval_t +xer_encode(asn_TYPE_descriptor_t *td, void *sptr, + enum xer_encoder_flags_e xer_flags, + asn_app_consume_bytes_f *cb, void *app_key) { + asn_enc_rval_t er, tmper; + const char *mname; + size_t mlen; + int xcan = (xer_flags & XER_F_CANONICAL) ? 1 : 2; + + if(!td || !sptr) goto cb_failed; + + mname = td->xml_tag; + mlen = strlen(mname); + + _ASN_CALLBACK3("<", 1, mname, mlen, ">", 1); + + tmper = td->xer_encoder(td, sptr, 1, xer_flags, cb, app_key); + if(tmper.encoded == -1) return tmper; + + _ASN_CALLBACK3("\n", xcan); + + er.encoded = 4 + xcan + (2 * mlen) + tmper.encoded; + + _ASN_ENCODED_OK(er); +cb_failed: + _ASN_ENCODE_FAILED; +} + +/* + * This is a helper function for xer_fprint, which directs all incoming data + * into the provided file descriptor. + */ +static int +xer__print2fp(const void *buffer, size_t size, void *app_key) { + FILE *stream = (FILE *)app_key; + + if(fwrite(buffer, 1, size, stream) != size) + return -1; + + return 0; +} + +int +xer_fprint(FILE *stream, asn_TYPE_descriptor_t *td, void *sptr) { + asn_enc_rval_t er; + + if(!stream) stream = stdout; + if(!td || !sptr) + return -1; + + er = xer_encode(td, sptr, XER_F_BASIC, xer__print2fp, stream); + if(er.encoded == -1) + return -1; + + return fflush(stream); +} diff --git a/projects/stargazer/plugins/other/snmp/asn1/xer_encoder.h b/projects/stargazer/plugins/other/snmp/asn1/xer_encoder.h new file mode 100644 index 00000000..055e73c0 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/xer_encoder.h @@ -0,0 +1,59 @@ +/*- + * Copyright (c) 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _XER_ENCODER_H_ +#define _XER_ENCODER_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +struct asn_TYPE_descriptor_s; /* Forward declaration */ + +/* Flags used by the xer_encode() and (*xer_type_encoder_f), defined below */ +enum xer_encoder_flags_e { + /* Mode of encoding */ + XER_F_BASIC = 0x01, /* BASIC-XER (pretty-printing) */ + XER_F_CANONICAL = 0x02 /* Canonical XER (strict rules) */ +}; + +/* + * The XER encoder of any type. May be invoked by the application. + */ +asn_enc_rval_t xer_encode(struct asn_TYPE_descriptor_s *type_descriptor, + void *struct_ptr, /* Structure to be encoded */ + enum xer_encoder_flags_e xer_flags, + asn_app_consume_bytes_f *consume_bytes_cb, + void *app_key /* Arbitrary callback argument */ + ); + +/* + * The variant of the above function which dumps the BASIC-XER (XER_F_BASIC) + * output into the chosen file pointer. + * RETURN VALUES: + * 0: The structure is printed. + * -1: Problem printing the structure. + * WARNING: No sensible errno value is returned. + */ +int xer_fprint(FILE *stream, struct asn_TYPE_descriptor_s *td, void *sptr); + +/* + * Type of the generic XER encoder. + */ +typedef asn_enc_rval_t (xer_type_encoder_f)( + struct asn_TYPE_descriptor_s *type_descriptor, + void *struct_ptr, /* Structure to be encoded */ + int ilevel, /* Level of indentation */ + enum xer_encoder_flags_e xer_flags, + asn_app_consume_bytes_f *consume_bytes_cb, /* Callback */ + void *app_key /* Arbitrary callback argument */ + ); + +#ifdef __cplusplus +} +#endif + +#endif /* _XER_ENCODER_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/asn1/xer_support.c b/projects/stargazer/plugins/other/snmp/asn1/xer_support.c new file mode 100644 index 00000000..9e34e692 --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/xer_support.c @@ -0,0 +1,233 @@ +/* + * Copyright (c) 2003, 2004 X/IO Labs, xiolabs.com. + * Copyright (c) 2003, 2004, 2005 Lev Walkin . + * All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#include +#include + +/* Parser states */ +typedef enum { + ST_TEXT, + ST_TAG_START, + ST_TAG_BODY, + ST_TAG_QUOTE_WAIT, + ST_TAG_QUOTED_STRING, + ST_TAG_UNQUOTED_STRING, + ST_COMMENT_WAIT_DASH1, /* ""[0] */ + ST_COMMENT_CLO_RT /* "-->"[1] */ +} pstate_e; + +static pxml_chunk_type_e final_chunk_type[] = { + PXML_TEXT, + PXML_TAG_END, + PXML_COMMENT_END, + PXML_TAG_END, + PXML_COMMENT_END, +}; + + +static int +_charclass[256] = { + 0,0,0,0,0,0,0,0, 0,1,1,0,1,1,0,0, + 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, + 1,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, + 2,2,2,2,2,2,2,2, 2,2,0,0,0,0,0,0, /* 01234567 89 */ + 0,3,3,3,3,3,3,3, 3,3,3,3,3,3,3,3, /* ABCDEFG HIJKLMNO */ + 3,3,3,3,3,3,3,3, 3,3,3,0,0,0,0,0, /* PQRSTUVW XYZ */ + 0,3,3,3,3,3,3,3, 3,3,3,3,3,3,3,3, /* abcdefg hijklmno */ + 3,3,3,3,3,3,3,3, 3,3,3,0,0,0,0,0 /* pqrstuvw xyz */ +}; +#define WHITESPACE(c) (_charclass[(unsigned char)(c)] == 1) +#define ALNUM(c) (_charclass[(unsigned char)(c)] >= 2) +#define ALPHA(c) (_charclass[(unsigned char)(c)] == 3) + +/* Aliases for characters, ASCII/UTF-8 */ +#define EXCLAM 0x21 /* '!' */ +#define CQUOTE 0x22 /* '"' */ +#define CDASH 0x2d /* '-' */ +#define CSLASH 0x2f /* '/' */ +#define LANGLE 0x3c /* '<' */ +#define CEQUAL 0x3d /* '=' */ +#define RANGLE 0x3e /* '>' */ +#define CQUEST 0x3f /* '?' */ + +/* Invoke token callback */ +#define TOKEN_CB_CALL(type, _ns, _current_too, _final) do { \ + int _ret; \ + pstate_e ns = _ns; \ + ssize_t _sz = (p - chunk_start) + _current_too; \ + if (!_sz) { \ + /* Shortcut */ \ + state = _ns; \ + break; \ + } \ + _ret = cb(type, chunk_start, _sz, key); \ + if(_ret < _sz) { \ + if(_current_too && _ret == -1) \ + state = ns; \ + goto finish; \ + } \ + chunk_start = p + _current_too; \ + state = ns; \ + } while(0) + +#define TOKEN_CB(_type, _ns, _current_too) \ + TOKEN_CB_CALL(_type, _ns, _current_too, 0) + +#define TOKEN_CB_FINAL(_type, _ns, _current_too) \ + TOKEN_CB_CALL(final_chunk_type[_type], _ns, _current_too, 1) + +/* + * Parser itself + */ +ssize_t pxml_parse(int *stateContext, const void *xmlbuf, size_t size, pxml_callback_f *cb, void *key) { + pstate_e state = (pstate_e)*stateContext; + const char *chunk_start = (const char *)xmlbuf; + const char *p = chunk_start; + const char *end = p + size; + + for(; p < end; p++) { + int C = *(const unsigned char *)p; + switch(state) { + case ST_TEXT: + /* + * Initial state: we're in the middle of some text, + * or just have started. + */ + if (C == LANGLE) + /* We're now in the tag, probably */ + TOKEN_CB(PXML_TEXT, ST_TAG_START, 0); + break; + case ST_TAG_START: + if (ALPHA(C) || (C == CSLASH)) + state = ST_TAG_BODY; + else if (C == EXCLAM) + state = ST_COMMENT_WAIT_DASH1; + else + /* + * Not characters and not whitespace. + * Must be something like "3 < 4". + */ + TOKEN_CB(PXML_TEXT, ST_TEXT, 1);/* Flush as data */ + break; + case ST_TAG_BODY: + switch(C) { + case RANGLE: + /* End of the tag */ + TOKEN_CB_FINAL(PXML_TAG, ST_TEXT, 1); + break; + case LANGLE: + /* + * The previous tag wasn't completed, but still + * recognized as valid. (Mozilla-compatible) + */ + TOKEN_CB_FINAL(PXML_TAG, ST_TAG_START, 0); + break; + case CEQUAL: + state = ST_TAG_QUOTE_WAIT; + break; + } + break; + case ST_TAG_QUOTE_WAIT: + /* + * State after the equal sign ("=") in the tag. + */ + switch(C) { + case CQUOTE: + state = ST_TAG_QUOTED_STRING; + break; + case RANGLE: + /* End of the tag */ + TOKEN_CB_FINAL(PXML_TAG, ST_TEXT, 1); + break; + default: + if(!WHITESPACE(C)) + /* Unquoted string value */ + state = ST_TAG_UNQUOTED_STRING; + } + break; + case ST_TAG_QUOTED_STRING: + /* + * Tag attribute's string value in quotes. + */ + if(C == CQUOTE) { + /* Return back to the tag state */ + state = ST_TAG_BODY; + } + break; + case ST_TAG_UNQUOTED_STRING: + if(C == RANGLE) { + /* End of the tag */ + TOKEN_CB_FINAL(PXML_TAG, ST_TEXT, 1); + } else if(WHITESPACE(C)) { + /* Return back to the tag state */ + state = ST_TAG_BODY; + } + break; + case ST_COMMENT_WAIT_DASH1: + if(C == CDASH) { + state = ST_COMMENT_WAIT_DASH2; + } else { + /* Some ordinary tag. */ + state = ST_TAG_BODY; + } + break; + case ST_COMMENT_WAIT_DASH2: + if(C == CDASH) { + /* Seen "<--" */ + state = ST_COMMENT; + } else { + /* Some ordinary tag */ + state = ST_TAG_BODY; + } + break; + case ST_COMMENT: + if(C == CDASH) { + state = ST_COMMENT_CLO_DASH2; + } + break; + case ST_COMMENT_CLO_DASH2: + if(C == CDASH) { + state = ST_COMMENT_CLO_RT; + } else { + /* This is not an end of a comment */ + state = ST_COMMENT; + } + break; + case ST_COMMENT_CLO_RT: + if(C == RANGLE) { + TOKEN_CB_FINAL(PXML_COMMENT, ST_TEXT, 1); + } else if(C == CDASH) { + /* Maintain current state, still waiting for '>' */ + } else { + state = ST_COMMENT; + } + break; + } /* switch(*ptr) */ + } /* for() */ + + /* + * Flush the partially processed chunk, state permitting. + */ + if(p - chunk_start) { + switch (state) { + case ST_COMMENT: + TOKEN_CB(PXML_COMMENT, state, 0); + break; + case ST_TEXT: + TOKEN_CB(PXML_TEXT, state, 0); + break; + default: break; /* a no-op */ + } + } + +finish: + *stateContext = (int)state; + return chunk_start - (const char *)xmlbuf; +} + diff --git a/projects/stargazer/plugins/other/snmp/asn1/xer_support.h b/projects/stargazer/plugins/other/snmp/asn1/xer_support.h new file mode 100644 index 00000000..8b01944a --- /dev/null +++ b/projects/stargazer/plugins/other/snmp/asn1/xer_support.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2003, 2004 X/IO Labs, xiolabs.com. + * Copyright (c) 2003, 2004 Lev Walkin . All rights reserved. + * Redistribution and modifications are permitted subject to BSD license. + */ +#ifndef _XER_SUPPORT_H_ +#define _XER_SUPPORT_H_ + +#include /* Platform-specific types */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Types of data transferred to the application. + */ +typedef enum { + PXML_TEXT, /* Plain text between XML tags. */ + PXML_TAG, /* A tag, starting with '<'. */ + PXML_COMMENT, /* An XML comment, including "". */ + /* + * The following chunk types are reported if the chunk + * terminates the specified XML element. + */ + PXML_TAG_END, /* Tag ended */ + PXML_COMMENT_END /* Comment ended */ +} pxml_chunk_type_e; + +/* + * Callback function that is called by the parser when parsed data is + * available. The _opaque is the pointer to a field containing opaque user + * data specified in pxml_create() call. The chunk type is _type and the text + * data is the piece of buffer identified by _bufid (as supplied to + * pxml_feed() call) starting at offset _offset and of _size bytes size. + * The chunk is NOT '\0'-terminated. + */ +typedef int (pxml_callback_f)(pxml_chunk_type_e _type, + const void *_chunk_data, size_t _chunk_size, void *_key); + +/* + * Parse the given buffer as it were a chunk of XML data. + * Invoke the specified callback each time the meaninful data is found. + * This function returns number of bytes consumed from the bufer. + * It will always be lesser than or equal to the specified _size. + * The next invocation of this function must account the difference. + */ +ssize_t pxml_parse(int *_stateContext, const void *_buf, size_t _size, + pxml_callback_f *cb, void *_key); + +#ifdef __cplusplus +} +#endif + +#endif /* _XER_SUPPORT_H_ */ diff --git a/projects/stargazer/plugins/other/snmp/snmp.cpp b/projects/stargazer/plugins/other/snmp/snmp.cpp new file mode 100644 index 00000000..e69de29b -- 2.43.2