ASN.1 Tools for C — Enhancements History

ASN.1 Tools for C - version 11.3.1 (latest version)

  • The following new 3GPP Release 18 samples have been created for the 5G and LTE protocols:
    • 5g_e1ap_r18 TS 37.483 V18.0.0 (2023-12)
    • 5g_f1ap_r18 TS 38.473 V18.0.0 (2023-12)
    • 5g_ngap_r18 TS 38.413 V18.0.0 (2023-12)
    • 5g_rrc_r18 TS 38.331 V18.0.0 (2023-12)
    • 5g_xnap_r18 TS 38.423 V18.0.0 (2023-12)
    • lte_rrc_cv2x_r18 TS 36.331 V18.0.0 (2023-12)
    • lte_rrc_nb_iot_r18 TS 36.331 V18.0.0 (2023-12)
    • lte_rrc_r18 TS 36.331 V18.0.0 (2023-12)
    • lte_s1ap_nb_iot_r18 TS 36.413 V18.0.0 (2023-12)
    • lte_s1ap_r18 TS 36.413 V18.0.0 (2023-12)
    • lte_x2ap_nb_iot_r18 TS 36.423 V18.0.0 (2023-12)
    • lte_x2ap_r18 TS 36.423 V18.0.0 (2023-12)

ASN.1 Tools for C - version 11.3

ASN.1 Tools for C - version 11.2

  • The ASN.1/C Tools now includes ASN.1 Studio v10.4.
  • The following changes have been made to the ASN.1 compiler:
    • Additional RTOED code is now generated to enable or disable support for the Memory Handling API. To enable support for the RTOED Memory Handling API, specify the -DOSS_RTOED_MEMORY_HANDLES_SUPPORTED option when you compile the RTOED code file for your application. By default, RTOED Memory Handling API support is disabled, which can reduce the application code size by approximately 4Kb.
    • The -2015 compiler option is now an alias of the new -2021 compiler option.
    • The ASN1.Version compiler directive now accepts "2021" as an argument.
  • The TOED/RTOED runtime supports the following new functions:
    • ossBinary2AVN(), which is used to convert data encoded in ASN.1 binary form (e.g., BER, PER, DER, OER, etc.) to ASN.1 value notation (AVN) text encoding.
    • ossAVN2Binary(), which is used to convert data encoded in ASN.1 value notation (AVN) to ASN.1 binary form (e.g., BER, PER, DER, OER, etc.).
  • The IAAPI supports the following new functions:
    • ossASN2CSV(), which converts an ASN.1 encoded PDU to Comma-Separated-Value format.
    • ossCSV2ASN(), which converts an encoded PDU from Comma-Separated-Value format to ASN.1.
  • The ASN.1 Standards repository now includes ASN.1 specifications for 3GPP Release 17, as follows:
    • 5g_e1ap_r17 TS 37.483 V17.1.0 (2022-06)
    • 5g_f1ap_r17 TS 38.473 V17.1.0 (2022-06)
    • 5g_ngap_r17 TS 38.413 V17.1.1 (2022-06)
    • 5g_rrc_r17 TS 38.331 V17.1.0 (2022-07)
    • 5g_xnap_r17 TS 38.423 V17.1.0 (2022-06)
    • lte_lcsap_r17 TS 29.171 V17.0.0 (2022-03)
    • lte_lppa_r17 TS 36.455 V17.0.0 (2022-04)
    • lte_m2ap_r17 TS 36.443 V17.0.1 (2022-04)
    • lte_m3ap_r17 TS 36.444 V17.0.0 (2022-04)
    • lte_rrc_cv2x_r17 TS 36.331 V17.1.0 (2022-07)
    • lte_rrc_nb_iot_r17 TS 36.331 V17.1.0 (2022-07)
    • lte_rrc_r17 TS 36.331 V17.1.0 (2022-07)
    • lte_s1ap_nb_iot_r17 TS 36.413 V17.1.0 (2022-06)
    • lte_s1ap_r17 TS 36.413 V17.1.0 (2022-06)
    • lte_sbcap_r17 TS 29.168 V17.1.0 (2021-12)
    • lte_slmap_r17 TS 36.459 V17.0.0 (2022-04)
    • lte_x2ap_nb_iot_r17 TS 36.423 V17.1.0 (2022-06)
    • lte_x2ap_r17 TS 36.423 V17.1.0 (2022-06)
    • lte_xwap_r17 TS 36.463 V17.0.0 (2022-04)
    • umts_rrc_r17 TS 25.331 V17.1.0 (2022-07)

ASN.1 Tools for C - version

ASN.1 Tools for C - version 11.1

  • The ASN.1/C Tools now includes ASN.1 Studio v10.2.
  • The Time-Optimized runtime (TOED) now supports the ASN.1 Value Notation encoding rules (AVN). The new -avn compiler option instructs the compiler to generate encoding/decoding code for AVN. When the OSS_ASN1_VALUE_NOTATION rules are set by the ossSetEncodingRules() API function, the ossDecode() function decodes a PDU value represented in ASN.1 value notation text format and the ossEncode() function encodes an in-memory PDU value to this format. ASN.1 value notation text format is similar to the format produced by the ossPrintPDU() API function.
    The ossGetAVNFlags() and ossSetAVNFlags() API functions and the OSS_AVN_DECODE_CONTAINED_IN_HEX and OSS_AVN_RESOLVE_OPEN_TYPE_BY_NAME C-compiler macros are introduced to control the AVN encoder/decoder behavior.
    NOTE: Support of ASN.1 Value Notation encoding rules is a chargeable feature in non-evaluation licenses. Contact Sales to obtain pricing information.
  • The OSS TOED runtime supports the ossUnknownExtensionFound(OssGlobal *world) API function, which allows you to detect whether the last PDU decoded by the ossDecode() function contained at least one unknown SEQUENCE, SET, or CHOICE type extension. The presence of unknown extensions indicates that the sender is using a newer ASN.1 specification version. This feature is disabled by default due to some performance and size overhead. To enable it, C-compile the generated code using the -DOSS_DETECT_UNKNOWN_EXTENSION option.
  • The ASN.1/C RTOED runtime now supports the ossPrintPDUToBuffer() and ossDeterminePDUBufferLength() API functions.
  • The Interpretive ASN.1 API (IAAPI) includes the following enhancements:
    • Functions that convert decoded internal format values into CSV format support the OSS_SKIP_EMPTY_CSV setting, which instructs the CSV encoder to skip CSVs that include only column separators and spaces, that is, CSVs with empty values for all nested simple types.
    • When OCTET STRING values marked with OSS.PrintFunctionName directives cannot be converted to the specified OSS format, IAAPI functions that convert decoded internal format values into CSV format now include the original value in hexadecimal format, prefixed with the ??? string, in the output CSV. Functions used to decode CSVs ignore the ??? prefix, skip conversion, and process such values as hstrings. For backward compatibility, the OSS_EMPTY_OCTSTR_IF_CONVERSION_FAILS flag is supported.
    • The limit of 50 on the user-specified maximum number of CSVs created for multiple components of each SET OF and SEQUENCE OF type value has been removed in functions that convert decoded internal format values into CSV format. The ossSetCsvSetting() function can be used to set a user-specified maximum for the OSS_CSV_MAX_SET_OF_SEQ_OF_COMPONENTS setting. The total number of additional CSVs for all SET OF and SEQUENCE OF types is limited to the maximum between the user-specified number and 50, multiplied by 50.
    • The ossGetComponentByAbsRef() and ossPutComponentByAbsRef() functions now accept absolute references generated by the ossGetCsvOfPDU() and ossGetCsvOfType() functions in a new extended CSV header format. They now support the "*" token for unnamed SET OF and SEQUENCE OF type value components, which is equivalent to "1", and PDU names or numbers inside parentheses for open type values and type values with contents constraints.
    • The ossGetComponentByAbsRef() now supports absolute references prefixed with a typereference name that is not a PDU.
    • IAAPI functions used for CSV conversion support the new CSV header format that includes the OSS_CHR_ABREF_EXTENDED identifier. The identifier is equivalent to OSS_CHR_ABREF, except for the following additions that can also be set separately using the OSS_CSV_FLAGS identifier:
      • The PDU name prefix is used for all nodes in the CSV header.
      • The "*" token is used for unnamed SET OF and SEQUENCE OF type components.
      • A component's index that starts with "1" is used for unnamed of SET, SEQUENCE, and CHOICE type components.
    • Functions that convert decoded internal format values into CSV format support the OSS_CSV_ALL_MAX setting, which is used to specify the maximum number of all CSVs to create for a top-level PDU type value that can include multiple components for multiple SET OF and SEQUENCE OF type values for which additional CSVs are created.

    NOTE: IAAPI functions are not supported in the Time-Optimized Encoder/Decoder library (TOED), which is the runtime library used by default.

  • The cam_denm sample has been updated to use the most recent version of the ASN.1 schema:
    • CAM ETSI EN 302 637-2 V1.4.1 (2019-04)
    • DENM ETSI EN 302 637-3 V1.3.1 (2019-04)
    • ITS-Container ETSI TS 102 894-2 V1.3.1 (2018-08)
    The existing 3GPP Release 13 samples have been removed and other samples have been updated to newer versions of the ASN.1 schemas:
    • 5g_e1ap_r15 TS 38.463 V15.8.0 (2020-10)
    • 5g_e1ap_r16 TS 38.463 V16.5.0 (2021-04)
    • 5g_f1ap_r15 TS 38.473 V15.13.0 (2020-03)
    • 5g_f1ap_r16 TS 38.473 V16.4.1 (2021-03)
    • 5g_ngap_r15 TS 38.413 V15.11.0 (2021-04)
    • 5g_ngap_r16 TS 38.413 V16.5.0 (2021-04)
    • 5g_rrc_r15 TS 38.331 V15.13.0 (2021-03)
    • 5g_rrc_r16 TS 38.331 V16.4.1 (2021-03)
    • 5g_xnap_r15 TS 38.423 V15.11.0 (2021-04)
    • 5g_xnap_r16 TS 38.423 V16.5.0 (2021-04)
    • lte_lcsap_r14 TS 29.171 V14.3.0 (2019-09)
    • lte_lcsap_r15 TS 29.171 V15.5.1 (2021-03)
    • lte_lcsap_r16 TS 29.171 V16.2.0 (2020-12)
    • lte_lppa_r14 TS 36.455 V14.5.0 (2018-09)
    • lte_lppa_r15 TS 36.455 V15.2.1 (2019-01)
    • lte_lppa_r16 TS 36.455 V16.1.0 (2021-04)
    • lte_rrc_cv2x_r14 TS 36.331 V14.16.0 (2021-01)
    • lte_rrc_cv2x_r15 TS 36.331 V15.16.0 (2021-03)
    • lte_rrc_cv2x_r16 TS 36.331 V16.4.0 (2021-03)
    • lte_rrc_nb_iot_r14 TS 36.331 V14.16.0 (2021-01)
    • lte_rrc_nb_iot_r15 TS 36.331 V15.16.0 (2021-03)
    • lte_rrc_nb_iot_r16 TS 36.331 V16.4.0 (2021-03)
    • lte_rrc_r14 TS 36.331 V14.16.0 (2021-01)
    • lte_rrc_r15 TS 36.331 V15.16.0 (2021-03)
    • lte_rrc_r16 TS 36.331 V16.4.0 (2021-03)
    • lte_s1ap_nb_iot_r14 TS 36.413 V14.9.0 (2019-07)
    • lte_s1ap_nb_iot_r15 TS 36.413 V15.10.0 (2020-10)
    • lte_s1ap_nb_iot_r16 TS 36.413 V16.5.0 (2021-04)
    • lte_s1ap_r14 TS 36.413 V14.9.0 (2019-07)
    • lte_s1ap_r15 TS 36.413 V15.10.0 (2020-10)
    • lte_s1ap_r16 TS 36.413 V16.5.0 (2021-04)
    • lte_sbcap_r14 TS 29.168 V14.2.0 (2017-12)
    • lte_sbcap_r15 TS 29.168 V15.1.0 (2018-09)
    • lte_sbcap_r16 TS 29.168 V16.0.0 (2020-07)
    • lte_slmap_r15 TS 36.459 V15.0.0 (2018-01)
    • lte_slmap_r16 TS 36.459 V16.0.0 (2020-07)
    • lte_x2ap_nb_iot_r14 TS 36.423 V14.8.0 (2019-10)
    • lte_x2ap_nb_iot_r15 TS 36.423 V15.11.0 (2020-10)
    • lte_x2ap_nb_iot_r16 TS 36.423 V16.5.0 (2021-04)
    • lte_x2ap_r14 TS 36.423 V14.8.0 (2019-10)
    • lte_x2ap_r15 TS 36.423 V15.11.0 (2020-10)
    • lte_x2ap_r16 TS 36.423 V16.5.0 (2021-04)
    • lte_xwap_r14 TS 36.463 V14.2.0 (2017-06)
    • lte_xwap_r15 TS 36.463 V15.0.0 (2018-06)
    • lte_xwap_r16 TS 36.463 V16.0.0 (2020-07)
    • umts_rrc_r16 TS 25.331 V16.1.0 (2020-10)

ASN.1 Tools for C - version

ASN.1 Tools for C - version

ASN.1 Tools for C - version 11.0

  • The ASN.1/C Tools now includes ASN.1 Studio v10.0.1.
  • The new -rtoed compiler option instructs the compiler to generate code for the new RTOED runtime. In the generated code, all function pointers are now constant, so the C compiler toolchain can place them in read-only memory. This protects the pointers from being maliciously overwritten.
  • There is now improved protection from stack smashing in the error handling code of the SOED, TOED, and LED runtimes.
  • When the new EXER_ENCODING_OF_DEFAULT_VALUES_AS_COMMENTS encoding flag is set, the E-XER encoder will now encode absent DEFAULT fields as XML comments that contain the corresponding default values. The new OSS_NO_EXER_ENCODING_OF_DEFAULT_VALUES_AS_COMMENTS macro can be used to control performance or memory footprint when TOED is enabled.
  • The compiler will now generate additional TOED code that enables the ossBinary2XML(), ossXML2Binary(), ossBinary2JSON(), and ossJSON2Binary() OSS conversion API functions to always report the D0373S error and return the CONVERSION_NOT_POSSIBLE error code when a proper conversion is not possible due to any of the following reasons:
    • Component relation constraints cannot be resolved for an extensible open type.
    • The OSS.NoConstrain compiler directive is applied to an open type or a contents constrained type.
    • When you use the TOED library without specifying the -autoencdec or -constr option at ASN.1 compile time.
    Previously, these functions could leave some parts of the encoding in its original form, thus an invalid output message was produced.
    When the application does not need these conversion functions and you link with the TOED library, compile the generated code file using the -DOSS_NO_BINARY_TEXT_API_CHECKS option to reduce the code size.
  • The order of the typedefs generated for shared open types derived from component relation constraints that are present within a contents constraint applied to a BIT STRING or OCTET will no longer cause C-compilation errors. The problem could occur when the default union representation was used for decoded values of open types. A new compat flag, v10.7OrderOfSharedTypedefsForOpenTypes, can be used to restore the order of typedefs generated by previous ASN.1 compiler versions.
  • The ASN.1 compiler will now generate sample code that refers to the correct constants for named bits when the input syntax includes several BIT STRING types that contain a NamedBitList syntax.
  • The OSS ASN.1 runtime will now check whether the value of the day component of a TIME type corresponds to the number of days of the specified month. Previously, the runtime checked whether the value exceeded 31. Also, negative values for the year component are now rejected.
  • When an OSS.PrintFunctionName directive that contains an OSS conversion function specified as a parameter is applied to OCTET STRING types and conversion is possible, the value notation will now include the actual BCD, TBCD, ASCII, IP address, or time stamp values inside an ASN.1 comment.

ASN.1 Tools for C - version 10.7.0

  • The ASN.1/C Tools now includes ASN.1 Studio v9.0.0.
  • The ASN.1 compiler now supports X.680 Amendment 1. The IMPORTS clause allows symbols to be imported from the latest module version, as indicated by the object identifier, and it can now include WITH SUCCESSORS and WITH DESCENDANTS as SelectionOption.
  • The OSS.NOENCODE and OSS.NODECODE compiler directives have been added. They reduce the generated TOED code by excluding the encoding or decoding routines for the directive's operand. Under certain conditions, the generated code can be reduced even further using the new -compactNoDecode compiler option.
  • The compiler now supports the OSS.JEREncodeFunction directive. This directive allows you to customize a JSON encoding of an ASN.1 type using a user-provided function that will generate the custom encoding. Note that the OSS.JEREncodeFunction directive is available only when the -soed or -toed compiler option is specified.
  • The JSON encoders now support an alternative form of encoding values of BIT STRING or OCTET STRING types with contents constraints if an ENCODED BY is absent. When you select this form, the values are encoded as text (the JSON value represents the contained value) rather than hex string.
  • Improved handling of types within inner subtype constraints with nested CONSTRAINED BY or contents constraints:
    1. A special type of absolute reference notation that allows you to access ASN.1 types located within WITH COMPONENTS and WITH COMPONENT (inner subtype) clauses and consists of two dollar signs ($$) followed by an index number indicating a particular WITH COMPONENTS or WITH COMPONENT is now supported. You can now assign user-defined names within CONSTRAINED BY clauses that are present within an inner subtype or a compiler-generated structure.
    2. When contents constraints are applied within an inner subtype constraint, the generated representations of the base type and the constrained type are now different. The ASN.1 compiler no longer uses the same name for both representations when the TYPENAME directive is applied to the base type. The new compat flag, oldTypesFromInnerSubtypeWithContentConstraints, can be used to restore the previous behavior.
    3. The ASN.1 compiler now generates user-defined functions for fields to which a CONSTRAINED BY included within a WITH COMPONENTS syntax is applied. The new compat flag, noConstrainedByFunctionsFromInnerSubtype, can be used to generate a user-defined function for the parent type.
    4. The ASN.1 compiler no longer generates structures with additional pointers for circularly defined types with contents constraints applied within inner subtypes in helper mode. The new compat flag, v10.6PointeredTypesFromInnerWithContentConstraints, can be used to restore the previous behavior.
    5. The ASN.1/C compiler now preserves the same global define names and values that are generated for similar fields within artificial types created after applying a contents constraint within an inner subtype constraint. To generate mangled names, use the v10.6DefineNamesForTypesFromInnerWithContentConstraints compat flag.
    6. The ASN.1/C compiler now generates correct header files when the -splitHeader option is specified with the -c++ or -dualHeaders option and the input ASN.1 syntax includes an inner subtype and a contents constraint or a CONSTRAINED BY constraint. The oldLocationOfTypesFromInnerWithContentConstraints compat flag can be used to restore the previous behavior.
  • The following samples have been created:
    • A sample for the DIN EN 15722 Intelligent transport systems - ESafety - ECall minimum set of data standard. The sample demonstrates how the ECallMessage message can be created and serialized to binary (UPER) and XML formats.
    • A sample for the eUICC Profile Package standard. The sample demonstrates how the eUICC Profile Package can be constructed and saved to the disk file in binary (DER) and text (JSON) formats.
    • A sample for the GSMA Remote SIM Provisioning standard. The sample demonstrates the RSP communication using the GetBoundProfilePackageRequest request to the SM-DP+ as an example.
  • New samples have been created for the 5G NGAP, XnAP, E1AP, F1AP, and LTE SLmAP protocols for 3GPP Release 15. The samples for the LTE LCSAP, LPPA, S1AP, M2AP, M3AP, RRC, SBcAP, XwAP, X2AP protocols have been updated to 3GPP Release 15.

ASN.1 Tools for C - version 10.6.0

  • The ASN.1/C Tools now includes ASN.1 Studio v8.3.0.
  • Support for the Canonical Packed Encoding Rules (ALIGNED and UNALIGNED) as specified by ITU-T Recommendation X.691 (08/2015) | ISO/IEC 8825-2:2015 has been added. To enable support for CPER, use the new compiler options: -cper and -cuper. For better security, the CPER decoder operates in strict mode: every deviation from the X.691 standard is reported.
  • The ASN.1 compiler supports the UPPERCAMELCASED and LOWERCAMELCASED keywords in the NAME and TEXT JER encoding instructions. You can now describe a wider range of JSON data in an ASN.1 schema.
  • The JSON encoders will now always encode a non-special REAL value as a JSON number. Previously, it could be encoded as a JSON object. For example, value 3.14 of an unconstrained REAL type was encoded as {base10value: 3.14}. The JSON decoders now accept both encoding forms: JSON number and JSON objects.
  • The DER/CER/CXER/COER encoders now automatically convert any valid value of GeneralizedTime and UTCTime types to the canonical form specified by X.690 Clause 11.7 and 11.8. Previously it was assumed that the value to be encoded already satisfied the restrictions imposed on its encoding by these clauses. For example, the UTCTime value "171231235900Z" was accepted but "17122359Z" was rejected because the seconds component was absent.
  • A new sample that demonstrates processing of CDR files as described by 3GPP TS 32.297 has been added. 3GPP CDR files contain a non-ASN.1 file header and non-ASN.1 record headers while record bodies are encoded by one of the ASN.1 encoding rules (BER, PER unaligned, PER aligned, or XER).
  • New samples have been created for 3GPP Release 14 of the LTE protocols and the existing Release 12 and 13 samples have been updated to the most recent versions of the ASN.1 schemas.
    • lte_lcsap_r13 TS 29.171 V13.3.0 (2017-06)
    • lte_lcsap_r14 TS 29.171 V14.1.0 (2017-06)
    • lte_lppa_r13 TS 36.455 V13.1.0 (2016-03)
    • lte_lppa_r14 TS 36.455 V14.3.0 (2017-09)
    • lte_m2ap_r12 TS 36.443 V12.2.0 (2015-03)
    • lte_m2ap_r13 TS 36.443 V13.3.0 (2016-03)
    • lte_m2ap_r14 TS 36.443 V14.0.1 (2017-09)
    • lte_m3ap_r12 TS 36.444 V12.2.0 (2015-03)
    • lte_m3ap_r13 TS 36.444 V13.2.0 (2016-03)
    • lte_m3ap_r14 TS 36.444 V14.1.0 (2017-06)
    • lte_rrc_cv2x_r14 TS 36.331 V14.4.0 (2017-09)
    • lte_rrc_nb_iot_r13 TS 36.331 V13.7.1 (2017-09)
    • lte_rrc_nb_iot_r14 TS 36.331 V14.4.0 (2017-09)
    • lte_rrc_r12 TS 36.331 V12.15.1 (2017-09)
    • lte_rrc_r13 TS 36.331 V13.7.1 (2017-09)
    • lte_rrc_r14 TS 36.331 V14.4.0 (2017-09)
    • lte_s1ap_nb_iot_r13 TS 36.413 V13.6.0 (2017-06)
    • lte_s1ap_nb_iot_r14 TS 36.413 V14.4.0 (2017-10)
    • lte_s1ap_r12 TS 36.413 V12.7.0 (2016-03)
    • lte_s1ap_r13 TS 36.413 V13.6.0 (2017-06)
    • lte_s1ap_r14 TS 36.413 V14.4.0 (2017-10)
    • lte_sbcap_r12 TS 29.168 V12.10.0 (2017-09)
    • lte_sbcap_r13 TS 29.168 V13.3.0 (2017-09)
    • lte_sbcap_r14 TS 29.168 V14.1.0 (2017-09)
    • lte_x2ap_nb_iot_r13 TS 36.423 V13.7.0 (2017-06)
    • lte_x2ap_nb_iot_r14 TS 36.423 V14.4.0 (2017-09)
    • lte_x2ap_r12 TS 36.423 V12.9.0 (2016-07)
    • lte_x2ap_r13 TS 36.423 V13.7.0 (2017-06)
    • lte_x2ap_r14 TS 36.423 V14.4.0 (2017-09)
    • lte_xwap_r13 TS 36.463 V13.1.0 (2016-07)
    • lte_xwap_r14 TS 36.463 V14.2.0 (2017-06)

ASN.1 Tools for C - version 10.5.0

  • The ASN.1/C Tools now includes ASN.1 Studio v8.2.0.
  • Conformance to Draft ITU-T Recommendation X.jsoner:
    • The ASN.1/C compiler and the SOED, TOED, and LED runtime libraries support the JSON Encoding Rules. The existing -json command-line option instructs the compiler to enable support for X.jsoner at runtime.
    • The JSON codec supports the following encoding instructions:
      • JER:ARRAY
      • JER:BASE64
      • JER:NAME
      • JER:OBJECT
      • JER:TEXT
  • Smaller TOED footprint. By defining OSS_REDUCED_ERROR_MSGS when compiling the generated .c, error messages will contain just the 5 character message prefix, instead of the full message. Alternatively, if OSSDEBUG=0 is defined, the error message strings will be removed completely, leaving only the return code to determine which error occurred. On Linux x86, you can reduce the footprint of your application by approximately 20 kilobytes. This number may vary depending on the processor, operating system, and C compiler.
  • The following new samples for LTE protocols have been added:

ASN.1 Tools for C - version 10.4.0

  • The ASN.1/C Tools now includes ASN.1 Studio v8.1.0.
  • The ASN.1/C Compiler and Runtime now support 64-bit precision (19-20 decimal digits) in TIME type fractions. The C representation of a TIME type is a string (char[]), so the only visible change in the encoder/decoder behavior is that it now accepts fractional TIME values of 19-20 decimal digits. Previously, an error about too-long fractions was thrown.
  • The name of the OSS_ALLOW_ABSENT_OR_BAD_SECONDS_OR_ABSENT_Z runtime compatibility flag has been changed to OSS_ALLOW_ABSENT_OR_BAD_SECONDS; the original name was deemed somewhat misleading. For backward compatibility, the old name is still available.
  • The ASN.1/C SOED/LEAN/TOED PER encoder-decoder implementation now conforms to the recent X.691 corrigendum (2015): an encoding contained in a BIT STRING should be at least one octet for PER ALIGNED and 1 bit for PER UNALIGNED.
  • The ASN.1/C runtime implementations are now aligned to conform to ITU-T X.680 Clause 46.3c. This clause states that the minutes component of a GeneralizedTime type value can be omitted when the difference between local time and UTC is an integral number of hours. Previously, a false error could be issued when the minutes component was absent.
  • New samples:
    • A sample for the 2016-03 version of the J2735 protocol has been created. The sample does not include the J2735:2016 ASN.1 specification due to licensing reasons. Users should obtain it directly from the ITS SAE site.
    • A sample for the 3GPP XwAP (TS 36.463) protocol has been created.

ASN.1 Tools for C - version 10.3.0

  • The ASN.1/C Tools now includes ASN.1 Studio v8.0.0.
  • Support for the JSON Encoding Rules per the "OSS Technical Specification for JSON Encoding Rules" is available in the ASN.1/C compiler and in all three runtime libraries of the OSS ASN.1/C Tools: Space-Optimized Encoder/Decoder (SOED), Time-Optimized Encoder/Decoder (TOED), and Lean Encoder/Decoder (LED). The following API functions have been added:
  • Two new API functions, ossBinary2JSON() and ossJSON2Binary(), have been added to convert data encoded in ASN.1 binary form (e.g., BER, PER, DER, OER, etc.) to JSON text encoding form (JSON/ER) and vice versa.
  • The ossPrintJSON() API function is now supported. This function allows you to print the contents of a JSON/ER encoding in a well-formatted manner.
  • IAAPI functions that print BER-encoded messages in TLV format now automatically detect and skip CDR headers.
    The following CDR formats are supported:
    • CDR files consisting of a CDR file header and CDR records with a CDR record header before each BER-based message.
    • CDR files consisting of CDR record headers that hold the record identifier in the first two octets and the record length in the next two octets.
    For more information, consult the IAAPI user manual.
  • Several IAAPI functions for converting ASN.1 encodings to and from comma-separated-values (CSV) data have been added.
  • The samples for 3GPP Releases 10, 11, and 12 have been updated to the latest versions of the standards. New samples for 3GPP LTE Release 13 have been added.

ASN.1 Tools for C - version 10.2.1

  • The ASN.1/C Tools now includes ASN.1 Studio v7.5.1. (Windows only)
  • The Windows ASN.1/C packages have been changed to include binaries targeted for Microsoft Visual Studio 2015 along with the binaries supporting MVS2005-MVS2013.

ASN.1 Tools for C - version 10.2

  • The ASN.1/C Tools now includes ASN.1 Studio v7.4.
  • The ASN.1/C compiler and the ASN.1/C TOED runtime library now have partial decode capabilities. The partial decode feature enables you to:
    • Decode preselected fields from incoming messages at a high speed
    • Directly access the decoded field in the callback function without traversing from the top of the PDU
    • Get the offset and length of the field encoding in a binary BER/DER/OER/COER message. It allows you to replace the value of the field directly in the binary message, if the encoding of the new value is of the same length as of the previous one.
    Existing customers who are interested in evaluating this feature should contact info@oss.com.
  • Several API utility functions were added to the ASN.1/C runtime libraries for support BCD and TBCD encodings. The functions print octet-aligned data as BCD or TBCD strings and convert octet strings to or from BCD or TBCD strings.

ASN.1 Tools for C - version 10.1

  • The ASN.1/C Tools now includes ASN.1 Studio v7.1
  • The ASN.1/C compiler and the ASN.1/C SOED/LED/TOED runtime libraries now support Octet Encoding Rules (OER) and Canonical Octet Encoding Rules (COER) as defined in "Rec. ITU-T X.696 | ISO/IEC 8825-7", rather than only the subset of ASN.1 types as defined in the "NTCIP 1102:2004 Octet Encoding Rules (OER) Base Protocol" document.
    The Octet Encoding Rules (OER), like the Packed Encoding Rules (PER), produce compact encodings by taking advantage of information present in the ASN.1 schema to limit the amount of information included in each encoded message. However, in contrast to PER, OER favors encoding/decoding speed over compactness of the encodings.
  • The compiler has been enhanced to support the new -useQualifedNames compiler option to resolve potential name conflicts. This option instructs the ASN.1 compiler to add a prefix to:
    • - the enumerators generated for an ENUMERATED ASN.1 type
    • - the constants generated for named numbers of an INTEGER type
    • - the constants generated for named bits of a BIT STRING type
  • Samples have been added that illustrate use of the SBc-AP, M2AP, and M3AP LTE protocols based on 3GPP Release 11.
  • A sample has been added that illustrates use of the DSRC Message Set Standard, SAE J2735_200911.

Note: OSS ASN.1 Tools for C version 10.0.0 implement an older version of OER, specified by NTCIP 1102:2004. If you are using OER we strongly recommend that you upgrade to 10.1.0 or later.

ASN.1 Tools for C - version 10.0

  • The ASN.1/C Tools now includes ASN.1 Studio v7.0
  • Support for the Octet Encoding Rules (OER), as specified by the NTCIP 1102:2004 Octet Encoding Rules (OER) Base Protocol document, has been implemented in the ASN.1/C compiler, the SOED, and TOED and IAAPI runtime libraries, ASN.1 Studio, as well as CAGL. OER messages can generally be encoded/decoded significantly faster than BER and PER messages, while being only slightly less compact than PER messages. Support for OER in ASN.1/C LED runtime library will be provided in the next release.
  • The ability to decode open types with table (component relation) constraints, when the AUTOMATIC_ENCDEC runtime flag is not set, has been added.
  • Two new utility API functions are provided:
    • - ossPrintPDUToBuffer()- serializes the content of the compiler-generated structures (before encoding or after decoding) into standardized ASN.1 "value notation" format and then writes it into the output buffer; this function is similar to ossPrintPDU(), which writes to the standard output;
    • - ossDeterminePDUBufferLength() - used to determine the length of the output buffer (in bytes) required by ossPrintPDUToBuffer().
  • The set of samples provided now includes samples illustrating the use of protocols based on the SAE J2735 Intelligent Transportation standard, as well as the 3GPP Release 10 RRC, S1AP, and X2AP LTE protocols based.
  • PER Encoding Analyzer add-ons for SOED and LED now include DLLs in addition to static libraries.
  • Various IAAPI improvements, including support for OID-IRI and RELATIVE-OID-IRI types, support for more complex permitted alphabet constraints, and more have been added.

ASN.1 Tools for C - version 9.0.2

  • The ASN.1/C Tools now includes ASN.1 Studio, a powerful new IDE packed with functionality that allows you to compile ASN.1 specs, display, create, modify or encode messages with just a few mouse clicks, and so much more!
  • The ASN.1/C Tools are capable of generating C code for ASN.1 open types that is more user-friendly.
  • You can generate code demonstrating how to perform encoding/decoding operation for any type in your ASN.1 specification.
  • The TOED (Time Optimized Encoder/Decoder) is now the default runtime library, providing you with speed optimized code "right out of the box". We haven't retired the SOED (Space Optimized Encoder/Decoder). We've just put our faster foot forward in response to a growing focus on speed.
  • On Windows, the ASN.1/C tools now install under the Program Files\OSS Nokalva\ossasn1\ folder (whereas before the 9.0.0 release, they were installed under Program Files\OSS\ossasn1\.)
  • Samples for the Windows platforms are now installed under the folder pointed to by the environment variable %ALLUSERSPROFILE%. By default, on Windows 7 and VISTA, the samples are installed under the C:\ProgramData\OSS Nokalva\ossasn1\[win32|winx64]\<version-number>\samples folder, and on Windows XP, the samples are installed under the C:\Documents and Settings\All Users\Application Data\OSS Nokalva\ossasn1\[win32|winx64]\<version-number>\samples folder.

ASN.1 Tools for C - version 8.6.1

  • Error processing for the ASN.1/C Tools has been enhanced as follows:
    • - The A1140W warning message prints more details about unknown encoding instructions, when possible.
    • - New descriptions of CAGL return codes have been added to the ossDescribeReturnCode() function.
    • - The new IAAPI function, ossGetIaapiErrMsg(), allows you to obtain an error message as a text string after a previous call to an IAAPI function has failed. Also, the new error handling function, ossIaapiErrMsgHandle(), is set as the default IAAPI error handling function.
    • - The new IAAPI function, ossDescribeIaapiReturnCode(), returns a textual description of an IAAPI numeric return code.
  • The TOED constraint checking functions have been enhanced to support value range constraints for REAL types.
  • A new value sharing algorithm has been added to the ASN.1 compiler to make the compilation of ASN.1 specification with large value notations very fast. Consequently, the size of the generated data is reduced because more values are now shared.

ASN.1 Tools for C - version 8.5

  • The ASN.1/C Tools now provide the following support for INTEGER types using the HUGE compiler directive:
    • - Support for constrained HUGE integers with constraints other than (0..MAX).
    • - Support for the application of the [DEFAULT-FOR-EMPTY] E-XER encoding instruction onto HUGE integer fields.
    • - Support for DEFAULT values and named values of HUGE INTEGER types as long as values can be represented in 64 bits.
  • The ASN.1/C compiler can now produce TOED E-XER decoder code that will skip unknown XML content found on input. The new code is generated inside the #ifdef OSS_SKIP_UNKNOWN_CONTENT_SUPPORTED #endif section and is disabled by default. To enable the code that supports the OSS_SKIP_UNKNOWN_CONTENT runtime flag, specify the OSS_SKIP_UNKNOWN_CONTENT_SUPPORTED macro when C-compiling the generated code file.
  • The E-XER decoders will now discard any unknown XML tag or attribute that is passed on input, provided the new OSS_SKIP_UNKNOWN_CONTENT runtime flag is set with the ossSetFlags() or ossSetDecodingFlags() function. By default, when the flag is not set, any unknown element or attribute will cause the decoder to issue an error.
  • A new API function, ossSkipCompressionPrefix(), has been added to the ASN.1/C runtime libraries. A full encoding produced by the OSS ASN.1 Tools using compression consists of the compression prefix followed by the compressed encoding. Given an OssBuf structure describing a full encoding, the function returns the lengths of both the original (uncompressed) encodings and the compressed encodings and modifies the OssBuf structure.

ASN.1 Tools for C - version 8.4

  • PrintPER now supports printing of values of a type contained in a type with a contents constraint applied when this contained type may be automatically decoded. If a non-PER encoding rule is specified in ENCODED BY in the contents constrained type, PrintPER writes out trace data for the contained type like a decoder does with the DEBUGPDU runtime flag. The ossPrintPER() function prints such trace data inside of /* */ comments and ossPrintXPER() prints it inside of comments.
  • Previously, PrintPER never displayed encoding information for a contained type, it only explained a BIT STRING or OCTET STRING encoding.
  • The new PrintPER flags "OSS_NO_CONTAINED_TYPE" and "OSS_NO_CONTAINED_TYPE_TRACE" have been added. The first flag instructs the PER Encoding Analyzer not to print information about a contained type. The second flag instructs the Analyzer not to print comments with trace data for a contained type encoded by non-PER rules.
  • PrintPER now supports printing of complex ISO 8601 time values.
  • The new PrintPER flag "OSS_NO_TIME_DETAILS" is added. The flag instructs the PER Encoding Analyzer to handle ISO 8601 time types as primitive types, that is, to not report their internal structure as defined by Amendment 2 to ITU-T Rec. X.691:2002.
  • A new compiler option, -relaxPerToedIntegerRangeConstraint, is now available to modify the default behavior of the TOED PER encoder. The Standard behavior for the PER encoder is to enforce range constraints even when constraint checking is disabled. Disabling constraints loses meaning since PER reserves only enough bits to represent all states in the specified range.
  • The -relaxPerToedIntegerRangeConstraint compiler option asks the compiler to generate TOED code so as to permit the user to deliberately force the encoding of a disallowed, but possible, value.
  • The Lean encoder/decoder now supports the tracing of complex ISO 8601 time values.
  • The new trace flag "LTRACE_NO_TIME_DETAILS" is added. The flag instructs the runtime to trace ISO 8601 time types as primitive types, that is, to not trace their internal structure defined by Amendment 2 to ITU-T Rec. X.691:2002.
  • The SOED PER encoder/decoder has been enhanced to support tracing of the new time types.

ASN.1 Tools for C - version 8.3

  • ASN.1 Compiler Enhancements
    • - The ASN.1 compiler has been changed to automatically select the -ignoreIncompleteItems option if the -relaxedMode option is specified.
    • - The ASN.1 compiler now supports combining the -exer and -code options and generates a code file for encoding and decoding Extended XER data using the TOED runtime. The generated code provides for performance-optimized parsing and serialization of XML (E-XER) data in accordance with the ASN.1 specification, and mapping of this XML data from/to the compiler-generated C structures. The generated code works 2 to 3 times faster than LED E-XER and 3 to 4 times faster than SOED E-XER. You must link with version 8.3 or later of the TOED runtime in order to use E-XER with TOED.
    • - The compiler does not generate 'relay safe' code for Extended XER in the presence of the -relaySafe compiler option. Please contact OSS Nokalva support at support@oss.com if you need this feature.
  • ASN.1 Runtime Enhancements
    • - The file and socket memory managers have been modified to delete the temporary files created when ossterm() is called, even if the PDUs stored in these files were not freed with ossFreePDU(). You may restore the previous behavior by setting the new OSS_KEEP_MEMORY_MANAGER_TEMPORARY_FILES compat flag.
    • The Time-Optimized OSS runtime (TOED) now supports the Extended XER encoding rules. The new runtime routines efficiently parse and serialize the XML (E-XER) data in accordance with the ASN.1 specification, and map this XML data from/to the compiler-generated C structures. You must use version 8.3 or later of the ASN.1 compiler and specify -exer and -code on the compiler command line in order to generate the code file to use E-XER with TOED.

ASN.1 Tools for C - version 8.2

  • OSS ASN.1 Tools for C version 8.2 supports the full range of time types as specified in ISO 8601 (TIME, DATE, TIME-OF-DAY, DATE-TIME, DURATION). These representations of date and time were standardized to avoid misinterpretations when communicating across national boundaries. Support for time types is available in the Space-Optimized Encoder/Decoder (SOED), Time-Optimized Encoder/Decoder (TOED), and Lean Encoder / Decoder (LED).
  • RelaySafe mode is now supported for XER/CXER/E-XER in all of the ASN.1/C Runtimes - the Space-Optimized Encoder/Decoder (SOED), Time-Optimized Encoder/Decoder (TOED), and Lean Encoder/Decoder (LED). When -relaySafe is in effect, a new OSS-specific directive, OSS.ExtensibleUseType, can be applied locally or globally to selected extensible CHOICE types being encoded in E-XER. The new directive instructs the E-XER decoder to handle unknown alternatives of an extensible CHOICE type as unknown extensions, so that the complete XML or binary encoding of the unknown type is preserved.
  • A new OSS-specific directive, OSS.ExerNumericBoolean, can be applied locally or globally to BOOLEAN types causing the E-XER encoder to produce numeric BOOLEAN values (0 and 1) instead of textual values (true/false or their replacements as set using the TEXT encoding instruction).

ASN.1 Tools for C - version 8.1.3

  • The new OSS ASN.1 GUI is the first true Integrated Development Environment (IDE) for ASN.1. Now even beginners can build, test, deploy ASN.1 applications with ease. The new ASN.1 GUI consists of two offerings:
    • - OSS ASN.1 Compiler GUI
    • - OSS ASN-1EDGE
  • The OSS ASN.1 Compiler GUI is an easy-to-use graphical interface to our ASN.1 compiler. The GUI allows users to graphically choose the input files and options for the ASN.1 compiler, and save the settings for later retrieval.
  • Key features of the OSS ASN.1 Compiler GUI include:
    • - Syntax checking of your ASN.1 specification
    • - ASN.1 compile and generation of header files and encoding/decoding information
    • - A full featured Syntax Editor designed specifically for ASN.1
  • OSS ASN-1EDGE, a separately purchased add-on, is a development tool designed to ease ASN.1 application development, deployment, and maintenance. It provides an intuitive graphical user interface for ASN.1 syntax checking and for encoding, decoding, creating, editing, and viewing ASN.1 messages. ASN-1EDGE provides the following key features:
    • - A full featured Syntax Editor designed specifically for ASN.1 Navigation of ASN.1 syntax via an easy-to-use graphical tree
    • - A Code Wizard which greatly simplifies ASN.1 development by creating scenario code based on the OSS compiler-generated structures
    • - Encoding of any valid value reference into any ASN.1 standard encoding rule
    • - Decoding of any valid encoding given its corresponding ASN.1 type definition
    • - Generation of test encodings for all value notation in the input ASN.1 specification
    • - Display of any PDU message saved in a file encoded using any standard encoding rule, in a graphical expandable/collapsible tree-like view
    • - A Value Editor for all ASN.1 standard encoding rules - this is an invaluable tool when generating test case data, debugging, or performing protocol analysis
    • - A Hex Editor for editing binary data
    • - Exportation of a value tree to HTML, CSV, or RTF files
  • A new compiler option, -reservedWords, allows you to instruct the compiler to mangle the words you specify for this option; this will avoid name conflicts with reserved words that must be present in the generated output.
  • A new compiler option, -ignoreIncompleteItems, instructs the compiler to ignore incomplete ASN.1 definitions that appear within ASN.1 modules and directly or indirectly reference undefined types or values. This allows you to successfully utilize specs that have unresolved references that don't affect your application.
  • A new OSS-specific directive, OSS.SelfCompleteWildcard, can be applied globally or locally to types that contain an "ANY-ELEMENT XER" encoding instruction. This directive will mark the associated type as a self-complete entity whose content will be taken as a complete XML document that can be passed to another application or function.
  • The TOED XER and LED XER/E-XER encoders have been optimized for the encoding of REAL values. Encoding of character REAL values (when the exponential form is not used) is up to 20% faster than the previous version.
  • A new runtime function, ossIdentifyPDUByEXERName(), returns the PDU number when supplied with the associated root XML (E-XER) tag name.

ASN.1 Tools for C - version 8.1

  • A new runtime function, ossDescribeReturnCode(), provides useful debugging information. It displays full textual descriptions corresponding to the numeric codes returned from any OSS API function.
  • The LED runtime now supports built-in compression/decompression via zlib; this functionality was previously available only in the SOED runtime.
  • New API functions, ossCompress() and ossUnCompress(), have been added to the SOED and LED runtimes. This API provides the ability to utilize user-specified compression/decompression and encryption/decryption routines. This is in addition to the built-in zlib compression feature.
  • The LED BER/DER/XER/E-XER decoders have been enhanced to automatically determine PDU number by the topmost tag of an encoded PDU if a zero PDU number is passed to the ossDecode() function. Previously, this feature was available only in the SOED runtime.

ASN.1 Tools for C - version 8.0

  • New Rapid Application Development (RAD) Features that help expedite application development by eliminating the need to understand the ASN.1 compiler-generated structures. The new RAD features include:
    • - New, more intuitive naming rules for ASN.1 types/fields, resulting in the generation of more user-friendly context-based names.
    • - Helper Macros generated by the ASN.1/C compiler create new instances of ASN.1 compiler generated structures and populate data into these structures. These Helper Macros greatly reduce development time and result in cleaner and leaner application code - all without a performance penalty.
    • - Linked-list types are now generated, by default, by the ASN.1 compiler for the SET OF and SEQUENCE OF types. The compiler also generates List APIs to automate the manipulation of these linked lists in the application program - for example, functions are provided to add/remove nodes to/from a list, update/insert nodes into a list, etc. The availability of these List APIs results in cleaner application code and reduced development time.
    • - A new compiler option, -restrictedContraintChecking, allows runtime constraint checking to be applied selectively (for individually selected types.
    • - New APIs allow users to set various debugging levels to control the amount of debug data that is generated at runtime while encoding or decoding. The ossPrintHex function has been enhanced to display the hex data and its ASCII equivalent.
    • - A new memory management mode improves the performance of the encoder and decoder by doing the following:
      • - Decreases the number of calls to system 'malloc' and 'free' functions when encoding and decoding
      • - Reuses allocated dynamic memory blocks when the encoder and decoder are being run in a loop
      • - Significantly speeds up freeing of complex data structures
    • - New API functions are available to easily convert between ASN.1 Time Type values and time_t ANSI C data type values.
    • - The LED Runtime has been enhanced to produce more descriptive (SOED-like) error messages.
    • - TOED BER and PER runtimes have been optimized for speed. For example, on the Windows platform, the decoder speed improvement is 50-60% for both BER and PER decoders.

ASN.1 Tools for C - version 7.0

  • Extended XML Encoding Rules (E-XER) support has been added to the SOED and the Lean Encoder/Decoder (LED) libraries. Now you can have the full capabilities of XML with ASN.1. Extended-XER encoding makes ASN.1 an XML schema notation as powerful as XSD, with the simplicity of ASN.1. The SOED are space-optimized libraries. The LED libraries are a perfect solution for resource starved embedded systems.
  • A new API function has been added which is useful when you need to skip "padding" bytes in an encoding before or after decoding it using ossDecode().
  • A new API function has been added which gives you an easy to use view of the valid ASN.1 notation. It's especially useful if you are debugging, or writing a protocol analyzer.
  • A new compiler option has been added so you can control whether relaxed checking is performed. Relaxed checking will eliminate the generation of warning messages, and some insignificant error messages, by the compiler.
  • A new directive has been added so that your ASN.1 notation can now customize the generated XER encoding layout for selected ASN.1 types. This capability is useful when your ASN.1 syntax defines rich semantics for simple ASN.1 types such as OCTET STRING, and you want to generate more readable XML encodings to reflect these semantics.
  • A new compiler option and a new runtime flag have been added which give you further compression beyond BER, PER, or other ASN.1 encoding rules. Additionally, you can customize the compression algorithm to suit your data which gives you the ability to minimize the compressed data size.
  • The sample directory structure for OSS ASN.1/C Tools has been changed and more samples added. The samples are divided into four categories: addons, advanced basic, standards
  • To view our E-XER Whitepaper click on E-XER. For an example of building an ASN.1 application with E-XER support click Example of Using E-XER.
  • Experience the benefit of E-XER yourself. If you are an existing C Tools customer, simply upgrade your Tools - have your username and password ready. Otherwise, download an evaluation copy of the Tools for C now. For information on purchasing, contact our Sales department at info@oss.com, Toll Free +1-888-OSS-ASN1 (USA & Canada), or +1-732-302-9669.

ASN.1 Tools for C - version 6.1

  • XER support has now been added to our LEAN Encoder/Decoder Libraries (LED), which are perfect for resource starved embedded systems.
  • Canonical XML Encoding Rules (CXER) are supported in our Time Optimized Encoder/Decoder Libraries (TOED).
  • A new compiler option which will generate XSD files, so that one can use the XML Encoding Rules (XER) to represent binary ASN.1 data in XML software such as schema-aware XML editors, Schema compilers, browsers, and so on.
  • The introduction of two new API functions will make conversion between XML and binary encodings an easy, one step process.
  • A new API function which allows you to print the contents of an XER/CXER encoding in a well-formatted manner.
  • The Time-optimized encoder/decoders have been improved to encode/decode much faster!
  • For PER, a value with extension fields of SEQUENCE and SET types can be encoded 650% faster and decoded 550% faster than it was previously in the TOED. And values of most String types have improved on average with an encoding speed increased by 210%-250% and an average decoding speed of 140%-370%.
  • For the XER/CXER encoder, complex and nested data encode at a faster rate.
  • For the XER encoder, all encodings are 1.5 times faster on average.

ASN.1 Tools for C - version 6.0

The OSS ASN.1 Tools for C version 6.0 supports the XML additions to ASN.1 described in the ASN.1:2002 standards documents. The tool includes the following functionality:

  • The ASN.1 compiler supports the XML value notation that provides a means of representing ASN.1 values using eXtensible Markup Language (XML) with the ASN.1 type definition as the schema. The XML value notation may be present within the same input ASN.1 file as other ASN.1 components.
  • The space-optimized encoder/decoder has been enhanced to allow you to encode/decode any PDU in the input using the XML encoding rules (XER). You can now add visibility to your ASN.1-described messages via XML.
  • New compiler command-line options are now available, -xer and -cxer. These options are similar to the -ber/-der/-per/uper options in that they allow the associated set of encoding rules (namely, the XML encoding rules (XER) and the canonical XML encoding rules (CXER)) to be available to the encoder/decoder during runtime.
  • A new ASN.1 compiler command-line option called "-xsl" has been added to allow you to automatically generate multiple default stylesheets, one for each PDU. Stylesheets allow you to have greater control over the visual aesthetic quality of an XML encoding.
  • A new compiler directive OSS.Stylesheet has been introduced to allow you greater control over the default stylesheets which are produced by the ASN.1 compiler. Using this directive, you can instruct the ASN.1 compiler to generate a separate stylesheet with your own desired filename for any particular PDU.
  • The ASN.1 compiler can now automatically generate XML DTD's (Data Type Definitions). This allows you to view and edit the XER output of ossEncode() in an ASN.1-independent tool which only recognizes XML.
  • A new function ossPrintXPER() has been added to the PER Encoder Analyzer shipment. This new function allows you to view the trace and analysis data for PER encodings in XML format. This greatly improves the aesthetic and user-friendly qualities of this product's output.

ASN.1 Tools for C - version 5.4

  • The ASN.1 compiler can now generate multiple header files, one for each ASN.1 module present in the input. To enable this new mode of header files generation, you may use the "-splitHeaders" or "-splitForSharing" command-line option. This is especially helpful for large ASN.1 specifications as it allows the user to work with smaller easier-to-handle header files.
  • The new ASN.1 compiler directives OSS.HeaderName and OSS.Preserve have been added to allow greater control over the new multiple header file generation.
  • The ASN.1 compiler now supports the contents constraints subtype, which is part of the new ASN.1:2002 standard.
  • The time-optimized encoder/decoder has been further optimized by omitting certain unneeded operations and implementing better processing algorithms.
  • The time-optimized encoder/decoder now fully supports the ossCmpValue() and ossCpyValue() functions. Now, you can take advantage of these useful PDU comparison and copying functions while linking with this fast encoder/decoder.
  • The ASN.1 compiler has been enhanced to support multi-line comments enclosed between the "/*" and "*/" tokens as defined in the new ASN.1 standard. The content of comments is also now transferred to the generated header files.
  • The ASN.1 compiler now supports the new PATTERN constraint notation, which is part of the new ASN.1:2002 standard.
  • The ASN.1 compiler now accepts text files that are in the multi-byte UTF-8 format. This allows you to specify multi-national characters in the input file where they are allowed by the ASN.1 standard.
  • The IAAPI functions can now be used with the Lean encoder/decoder.

ASN.1 Tools for C - version 5.3

  • The time-optimized encoder/decoder now supports the automatic encoding/decoding of open types. You can now combine the ease of automatic encoding/decoding of open types with the speed of the time-optimized encoder/decoder.
  • The time-optimized encoder/decoder library now supports the functions for handling information objects (e.g., ossGetInfoObject()).
  • More speed for enhanced performance: Certain ASN.1 syntax users will experience a 33+ percent upward shift in performance.
  • You can now speed up the decoding of certain large PDUs by skipping extra trailing elements in a SET OF or SEQUENCE OF type with the addition of a new compiler directive named OSS.Truncate.
  • A faster algorithm for checking component relation constraints is now available.
  • New optimization schemes for representing parameterized types and sharing type definitions have been implemented. The end result is shorter output files for certain ASN.1 specifications.
  • The combination of the -autoEncDec and -noConstraints options produces an optimized and smaller control-table/code-file.
  • More error checks have been added to the decoder for invalid BER encoding of the BIT STRING and OBJECT IDENTIFIER types have been added. The new error checks can be disabled via the RELAXBER flag.
  • More error checks have been added to the decoder for invalid PER encoding of INTEGER types with superfluous octets. The new error check can be disabled via the RELAXPER flag.
  • More descriptive error messages have been added to the ASN.1 compiler to better help users pinpoint errors in their syntax.
  • Two new API functions (ossUinit() and ossUterm()) now allow you to dynamically load the generated control-table or code file compiled as a dynamically linked library on UNIX-like systems. Previously, such dynamic linking was only available on the Windows operating system.