SOME/IP Transformer (SomeIpXf)

This function transforms a Sender/Receiver communication using the serialization of SOME/IP. It takes the data element as input and outputs a uint8 array containing the serialized data. The length of the serialized data shall be calculated by the transformer during runtime and returned in the OUT-parameter bufferLength. It may be smaller than the maximum buffer size used by the RTE for buffer allocation.

This function transforms a Client/Server communication using the serialization of SOME/IP. It takes the operation arguments and optionally the return value as input and outputs a uint8 array containing the serialized data. The length of the serialized data shall be calculated by the transformer during runtime and returned in the OUT-parameter bufferLength. It may be smaller than the maximum buffer size used by the RTE for buffer allocation.

This function deserializes a Sender/Receiver communication using the deserialization of SOME/IP. It takes the uint8 array containing the serialized data as input and outputs the original data element which will be passed to the RTE.

This function deserializes a Client/Server communication using the deserialization of SOME/IP. It takes the uint8 array containing the serialized data as input and outputs the return value of the server runnable and the operation arguments which have to be passed from the server to the client.

This service returns the version information of the called transformer module.

This service initializes the transformer for the further processing.

This service deinitializes the transformer.

This function transforms an external trigger event using the serialization of SOME/IP. It takes trigger as input and outputs a uint8 array. The length of the transformed data shall be calculated by the transformer during runtime and returned in the OUT parameter bufferLength. It may be smaller than the maximum buffer size used by the RTE for buffer allocation.

This function deserializes an external trigger event using the deserialization of SOME/IP.

Function to extract the relevant SOME/IP protocol header fields of the message and the type of the message result. - At the time being, this is limited to the types used for C/S communication (i.e., REQUEST and RESPONSE and OK and ERROR).

This is the type of the data structure containing the initialization data for the transformer.

Type of error Related error code Error value Error code if any other API service, except Get VersionInfo is called before the transformer module was initialized with Init or after a call to De Init SOMEIPXF_E_UNINIT 0x01 Error code if an invalid configuration set was selected SOMEIPXF_E_INIT_FAILED 0x02 API service called with wrong parameter SOMEIPXF_E_PARAM 0x03 API service called with invalid pointer SOMEIPXF_E_PARAM_POINTER 0x04

A service shall be identified using the Service-ID.

Service-IDs shall be of type 16 bit length unsigned integer (uint16).

Different services within the same vehicle shall have differ- ent Service-IDs.

A service instance shall be identified using the Service- Instance-ID.

Service-Instance-IDs shall be of type 16 bit length un- signed integer (uint16).

Different service instances within the same vehicle shall have different Service-Instance-IDs.

Methods and events shall be identified inside a service us- ing a 16bit Method-ID, which is called Event-ID for events and notifications.

Methods shall use Method-IDs with the highest bit set to 0, while the Method-IDs highest bit shall be set to 1 for events and notifications of fields.

All headers shall be encoded in network byte order Big Endian (MostSignificantByteFirst) [RFC 791].

The SOME/IP transformer shall implement all fields of the header except Message ID and Length.

If more data than expected are handed over to the SOME/IP transformer during deserialization of data, the unexpected data shall be dis- carded. The known fraction shall be considered.

If less data than expected are handed over to the SOME/IP transformer during deserialization of data, the following shall happen: • if for the corresponding ISignal an initial value is specified (in serialized form) use the value to fill the missing elements at the end of the serialized stream. • if no initial value is available abort deserialization with E_SER_MALFORMED_MESSAGE .

The Request ID shall be constructed of the Client ID and Session ID as shown in Table 7.5.

The clientId inside the Rte_Cs_TransactionHandleType handed over from RTE shall be used for the value of the Client ID.

The sequenceCounter inside the Rte_Cs_TransactionHandleType handed over from RTE shall be used for the value of the Session ID.

The Protocol Version shall be set to 0x01.

The Interface Version field shall be 8 bit long.

The Message Type field shall be filled with one of the values of Table 7.6.

Messages of Type REQUEST, REQUEST_NO_RETURN, and Notification have to set the Return Code to 0x00 (E_OK).

The serialization shall be based on the Sender- ReceiverInterface or ClientServerInterface of the data.

The SwBaseType s defined in [8] and according to [TPS_- STDT_00067] placed in the package /AUTOSAR_Platform/BaseTypes (e.g., /AU- TOSAR_Platform/BaseTypes/uint32 ) whihc shall be supported for serialization are listed in Table 7.8.

Alignment shall always be calculated from start of SOME/IP message.

A struct shall be serialized in order of depth-first traversal.

Strings shall be encoded using Unicode and terminated with a "\textbackslash0"-character for both fixed-length and dynamic-length strings. Unused space shall be filled using "\0".

Different Unicode encoding shall be supported including UTF-8, UTF-16BE, and UTF-16LE. Since these encoding have a dynamic length of bytes per character, the maximum length in bytes is up to three times the length of characters in UTF-8 plus 1 Byte for the termination with a "\0" or two times the length of the characters in UTF-16 plus 2 Bytes for a "\0". UTF-8 character can be up to 6 bytes and an UTF-16 character can be up to 4 bytes.

UTF-16LE and UTF-16BE strings shall be zero terminated with a "\textbackslash0"-character . This means they shall end with (at least) two 0x00 Bytes.

UTF-16LE and UTF-16BE strings shall have an even length.

For UTF-16LE and UTF-16BE strings having an odd length the last byte shall be silently removed by the receiving SOME/IP transformer.

All strings shall always start with a Byte Order Mark (BOM). The BOM shall be included in fixed-length-strings as well as dynamic-length strings.

The receiving SOME/IP transformer implementation shall check the BOM and handle a missing BOM or a malformed BOM as an error.

The BOM shall be added by the SOME/IP sending trans- former implementation.

The length of fixed length arrays is defined by the datatype definition.

A one-dimensional array with fixed length shall be serial- ized by concatenating the array elements in order.

The serialization of multidimensional arrays shall happen in row-major order(in-memory layout of multidimensional arrays in the C programming language)

A variable size array embedded in a structure which also contains a size indicator shall be serialized as the concatenation of the following ele- ments: • the length indicator which holds the length (in bytes) of the following variable size array • the array which contains the valid elements of the variable size array where • the data type of the length field shall be determined as specified in [SWS_SomeIpXf_00234] • the array shall be serialized like a static size array but does only contain the valid elements. The number of elements to serializer shall be taken from the size indicator.

The default serialization layout of unions in SOME/IP is shown in Table 7.10.

Spezifikationsanforderung SWS_SomeIpXf_00098.

The element is serialized depending on the type in the type field. This also defines the length of the data. All bytes behind the data that are covered by the length, are padding. The deserializer shall skip the padding bytes by calculat- ing the required number according to the formula given in [SWS_SomeIpXf_00088].

For the SOME/IP request message, the SOME/IP trans- former on the client-ECU has to do the following for payload and header: • Construct the payload • Optionally set the Request ID to a unique number (shall be unique for client only) • Set the Protocol Version according [SWS_SomeIpXf_00029] • Set the Interface Version. If interfaceVersion of SOMEIPTransforma- tionISignalProps is set, this shall be used. Otherwise interfaceVersion of SOMEIPTransformationDescription shall be used. • Set the Message Type to Request (i.e. 0x00 ) • Set the Return Code to 0x00

The SOME/IP transformer on the server-ECU builds its header for the server response based on the header of the client's request and does in addition: • Construct the payload • Set the Message Type to RESPONSE (i.e. 0x80 ) • If the ClientServerOperation has at least one possibleError defined, place the return value of the executed ClientServerOperation into the Re- turn Code field and add 0x1F to adapt the number ranges in case the original return value was different from 0x00 .

The SOME/IP transformer on the sender side of trans- formed Sender/Receiver communication shall construct header and payload in the fol- lowing way: • Construct the payload • Set the Request ID – to 0x00 if sessionHandlingSR of SOMEIPTransformationISignal- Props is not set to sessionHandlingActive – the current value of the Session Handling ID counter otherwise • Set the Protocol Version according [SWS_SomeIpXf_00029] • Set the Interface Version. If interfaceVersion of SOMEIPTransforma- tionISignalProps is set, this shall be used. Otherwise interfaceVersion of SOMEIPTransformationDescription shall be used. • Set the Message Type according to messageType of SOMEIPTransforma- tionISignalProps : – NOTIFICATION ( 0x02 ) shall be used in the header if attribute mes- sageType is set to notification – REQUEST_NO_RETURN ( 0x01 ) shall be used in the header if attribute mes- sageType is set to requestNoReturn • Set the Return Code to 0x00

The SOME/IP transformer shall use the Return Code error handling.

The Error Handling via Return Code shall be based on the Std_ReturnType .

The Return Codes shall only be used for Client/Server communication

The Return Codes of Table 7.11 are currently defined and shall be implemented as described:

To construct the payload of a request message all argu- ment s of the ClientServerOperation which have direction IN or INOUT shall be serialized according to the order of the ArgumentDataPrototype s within the ClientServerOperation .

To construct the payload of a response message all argu- ment s of the ClientServerOperation which have direction INOUT or OUT shall be serialized in the following order: The ArgumentDataPrototype s with a direction of INOUT or OUT shall be serialized according to the order of the ArgumentDataPrototype s within the ClientServer- Operation .

Reserved and special Service-IDs are defined in Table 7.12.

Reserved and special Instance-IDs are defined in Table 7.13.

Reserved and special Method-IDs/Event-IDs are defined in Table 7.14.

Method-IDs and Event-IDs of Service 0xFFFF are defined in Table 7.15.

Besides "otherserv" other names are supported by the con- figuration option. Table 7.16 gives an overview of the reserved names

The header file SomeIpXf[_<Ie>].h shall be the main include file for the SOME/IP transformer and include TransformerTypes.h and its Module Interlink Header file SchM_<bsnp>_[<vi>_<ai>].h . where <Ie> is the optional implementation specific file name extension according [SWS_- BSW_00103], <bsnp> is the BSW Scheduler Name Prefix according [SWS_Rte_07593] and [SWS_- Rte_07594], <vi> is the vendorId of the BSW module and <ai> is the vendorApiInfix of the BSW module.

The function SomeIpXf_<transformerId> specified in [SWS_SomeIpXf_00138] shall exist for the first reference in the list of ordered refer- ences transformer from a DataTransformation to a TransformationTech- nology if the DataTransformation is referenced by an ISignal in the role data- Transformation where the ISignal references a SystemSignal which is refer- enced by SenderReceiverToSignalMapping .

The function SomeIpXf_<transformerId> specified in [SWS_SomeIpXf_00138] shall serialize primitive or complex data elements of Sender/Receiver communication into a linear byte array representation using the SOME/IP serialization.

The function SomeIpXf_<transformerId> specified in [SWS_SomeIpXf_00141] shall exist for the first reference in the list of ordered refer- ences transformer from a DataTransformation to a TransformationTech- nology if the DataTransformation is referenced by an ISignal in the role dataTransformation where the ISignal references a SystemSignal which is referenced by ClientServerToSignalMapping in the callSignal or re- turnSignal .

The function SomeIpXf_<transformerId> [_<symbolSuffix>] specified in [SWS_SomeIpXf_00141] shall serialize all primi- tive or complex operation arguments and the return value (if executed on server side) of Client/Server communication into a linear byte array representation using the SOME/IP serialization.

The function SomeIpXf_Inv_<transformerId> speci- fied in [SWS_SomeIpXf_00144] shall exist for the first reference in the list of ordered references transformer from a DataTransformation to a Transformation- Technology if the DataTransformation is referenced by an ISignal in the role dataTransformation where the ISignal references a SystemSignal which is referenced by SenderReceiverToSignalMapping .

The function SomeIpXf_Inv_<transformerId> spec- ified in [SWS_SomeIpXf_00144] shall deserialize a linear byte array to primitive or complex data elements of Sender/Receiver communication using the SOME/IP dese- rialization.

The function SomeIpXf_Inv_<transformerId> specified in [SWS_SomeIpXf_00145] shall exist for the first reference in the list of ordered references transformer from a DataTransformation to a Transformation- Technology if the DataTransformation is referenced by an ISignal in the role dataTransformation where the ISignal references a SystemSignal which is referenced by ClientServerToSignalMapping in the callSignal or returnSignal .

The function SomeIpXf_Inv_<transformerId> spec- ified in [SWS_SomeIpXf_00145] shall deserialize a linear byte array which contains primitive or complex operation arguments and the return value (if executed on client side) of Client/Server communication using the SOME/IP deserialization.

The SOME/IP Transformer shall only provide functions for transformers where the TransformationTechnology is referenced as the first ref- erence in the list of ordered references transformer from a DataTransformation to a TransformationTechnology .

The SOME/IP transformer defined in this document shall be used as a transformer if • the attribute protocol of the TransformationTechnology is set to SOMEIP • and the attribute version of the TransformationTechnology is set to 1 • and the attribute transformerClass of the TransformationTechnology is set to serializer

For interoperability reasons the header layout shall be iden- tical for all implementations of SOME/IP and is described as follows: 1. Message ID (Service ID / Method ID) [32 bit] 2. Length [32 bit] 3. Additional information: (a) Protocol Version [8 bit] (b) Interface Version [8 bit] (c) Message Type [8 bit] (d) Return Code [8 bit] 4. Payload [variable size] The fields are presented in transmission order; i.e. the fields on the top are transmit- ted first. In the following sections the different header fields and their usage is being described.

The Request ID field shall be 32 bit long.

The Protocol Version field shall be 8 bit long.

The Protocol Version field shall contain the SOME/IP pro- tocol version.

The Interface Version field shall contain the Version of the Service Interface.

The Message Type field shall be 8 bit long.

The Return Code field shall be 8 bit long.

The Return Code field shall be used to signal whether a request has been successfully processed.

The Payload field shall have variable size.

The Payload field shall contain the transported data.

The allowed Return Codes for specific message types are specified in Table 7.7.

To allow migration the deserialization shall ignore parame- ters attached to the end of previously known parameter list.

In case of Client/Server communication the Return Code shall transport the ApplicationError s of the executed ClientServerOperation if no SOME/IP error occurred.

The byte order of the parameters inside the payload shall be defined by byteOrder of SOMEIPTransformationDescription .

The payload of a message for Sender/Receiver communi- cation shall consists of the serialized data element that is transported.

The apiServicePrefix of the SOME/IP transformer's EcuC shall be set to SomeIpXf .

If csErrorReaction of TransformationISignal- Props is set to autonomous and the returnValue parameter handed over from RTE is greater or equal to 0x80 , the SOME/IP transformer for a response of a client/server communication shall generate an error message according to [SWS_SomeIpXf_00201], else it shall generate a normal response according to [SWS_SomeIpXf_00107].

The SOME/IP transformer on the server-ECU builds its header for an autonomous error response based on the header of the client's request and does in addition: • Construct no payload (the payload shall be empty) • Set the Message Type to RESPONSE (i.e. 0x80 ) • Adapt the return value by subtracting 0x80 from the parameter returnValue (calculation: adaptedReturnV alue = returnV alue � 0 x 80 ) • Place the adaptedReturnValue into the Return Code field.

A SOME/IP transformer on the server-ECU that builds an autonomous error response shall return with a return value equal to E_OK (See [SWS_SomeIpXf_00141]).

The function SomeIpXf_<transformerId> [_<symbolSuffix>] specified in [SWS_SomeIpXf_00141] shall ignore all argu- ments data_1 , ... , data_n if the return code is greater or equal to 0x80 because they are not filled with meaningful values.

The SOME/IP transformer on the trigger source side of transformed external trigger events shall construct header in the following way: • Set the Request ID – to 0x00 if sessionHandlingSR of SOMEIPTransformationISignal- Props is not set to sessionHandlingActive – the current value of the Session Handling ID counter otherwise • Set the Protocol Version according [SWS_SomeIpXf_00029] • Set the Interface Version. If interfaceVersion of SOMEIPTransforma- tionISignalProps is set, this shall be used. Otherwise interfaceVersion of SOMEIPTransformationDescription shall be used. • Set the Message Type to REQUEST_NO_RETURN (i.e. 0x01 ) • Set the Return Code to 0x00

The payload of a message for external trigger event com- munication shall be empty.

The function SomeIpXf_<transformerId> specified in [SWS_SomeIpXf_00206] shall exist for the first referenced TransformationTech- nology in the ordered transformerChain of a DataTransformation if the DataTransformation is referenced by an ISignal in the role dataTransfor- mation where the ISignal references a SystemSignal which is referenced by a TriggerToSignalMapping .

The function SomeIpXf_<transformerId> specified in [SWS_SomeIpXf_00206] shall serialize an external trigger event into a linear byte array representation using the SOME/IP serialization.

The function SomeIpXf_Inv_<transformerId> speci- fied in [SWS_SomeIpXf_00209] shall exist for the first referenced Transformation- Technology in the ordered transformerChain of a DataTransformation if the DataTransformation is referenced by an ISignal in the role dataTransfor- mation where the ISignal references a SystemSignal which is referenced by a TriggerToSignalMapping .

The function SomeIpXf_Inv_<transformerId> spec- ified in [SWS_SomeIpXf_00209] shall deserialize a linear byte array to an external trigger event using the SOME/IP deserialization.

One Session Handling ID counter (16 Bit) has to be maintained per transformer function for Sender/Receiver communication (see [SWS_SomeIpXf_00138]) if sessionHandlingSR is set to sessionHandlingAc- tive .

All Session Handling ID counters shall be initialized with 0x0001 .

After serialization of the data, the function SomeIpXf_<transformerId> specified in [SWS_SomeIpXf_00138] shall in- crement the Session Handling ID counter assigned to <transformerId> if sessionHandlingSR is set to sessionHandlingActive .

When the Session Handling ID counter assigned to <transformerId> is 0xFFFF and gets incremented, it shall roll-over to 0x0001 (in- stead of 0x0000) if sessionHandlingSR is set to sessionHandlingActive .

If attribute sizeOfStructLengthFields of SOMEIP- TransformationISignalProps is set to a value greater 0, a length field shall be inserted in front of every serialized struct.

The data type of the length field of the struct and all nested structs within the struct shall be the same and shall be determined by the value of SOMEIPTransformationISignalProps . sizeOfStructLengthFields of the serialized ISignal : • uint8 if sizeOfStructLengthFields equals 1 • uint16 if sizeOfStructLengthFields equals 2 • uint32 if sizeOfStructLengthFields equals 4

The serializing SOME/IP transformer shall write the size (in bytes) of the serialized struct (without the size of the length field) into the length field of the struct.

If the length is greater than the expected length of a struct (as specified in the data type definition) a deserializing SOME/IP transformer shall only interpret the expected data and skip the unexpected.

If attribute sizeOfArrayLengthFields of SOMEIP- TransformationISignalProps is set to a value greater 0, a length field shall be inserted in front of every serialized array.

The data type of the length field for an array shall be determined by the value of SOMEIPTransformationISignalProps . sizeOfAr- rayLengthFields of the serialized ISignal : • uint8 if sizeOfArrayLengthFields equals 1 • uint16 if sizeOfArrayLengthFields equals 2 • uint32 if sizeOfArrayLengthFields equals 4

The serializing SOME/IP transformer shall write the size (in bytes) of the serialized array (without the size of the length field) into the length field of the array.

If the length is greater than the expected length of an array (as specified in the data type definition) a deserializing SOME/IP transformer shall only interpret the expected data and skip the unexpected.

If attribute sizeOfUnionLengthFields of SOMEIP- TransformationISignalProps is set to a value greater 0, a length field shall be inserted in front of every serialized union.

The data type of the length field of the union and all nested unions within the union shall be determined by the value of SOMEIPTransforma- tionISignalProps . sizeOfUnionLengthFields of the serialized ISignal : • uint8 if sizeOfUnionLengthFields equals 1 • uint16 if sizeOfUnionLengthFields equals 2 • uint32 if sizeOfUnionLengthFields equals 4

The serializing SOME/IP transformer shall write the size (in bytes) of the serialized union (including padding bytes but without the size of the length field and type field) into the length field of the union. This requirement does not apply for the serialization of extensible structs and methods.

If the length is greater than the expected length of a union (as specified in the data type definition) a deserializing SOME/IP transformer shall only interpret the expected data and skip the unexpected.

In function SomeIpXf_<transformerId> defined in [SWS_SomeIpXf_00138] • paramtype is derived from type according to the parameter passing rules rules defined by the [15, SRS BSW General] (see [SRS_BSW_00484], [SRS_BSW_- 00485], and [SRS_BSW_00486]) and [14, SWS BSW General] (see [SWS_- BSW_00186] and [SWS_BSW_00187]). • type shall be the data type of the data element after all data conversion activities of the RTE • transformerId shall be the name pattern for the transformer specified in [SWS_Xfrm_00062] ([3, ASWS Transformer General])

In function SomeIpXf_<transformerId> defined in [SWS_SomeIpXf_00141] • paramtype is derived from type according to the parameter passing rules rules defined by the [15, SRS BSW General] (see [SRS_BSW_00484], [SRS_BSW_- 00485], and [SRS_BSW_00486]) and [14, SWS BSW General] (see [SWS_- BSW_00186] and [SWS_BSW_00187]). • type shall be the data type of the data element after all data conversion activities of the RTE • transformerId shall be the name pattern for the transformer specified in [SWS_Xfrm_00062] ([3, ASWS Transformer General]).

In function SomeIpXf_<transformerId> defined in [SWS_SomeIpXf_00206] • transformerId shall be the name pattern for the transformer specified in [SWS_Xfrm_00062] ([3, ASWS Transformer General]).

In function SomeIpXf_Inv_<transformerId> defined in [SWS_SomeIpXf_00144] • type shall be the data type of the data element before all data conversion activi- ties of the RTE • transformerId shall be the name pattern for the transformer specified in [SWS_Xfrm_00062] ([3, ASWS Transformer General]).

In function SomeIpXf_Inv_<transformerId> defined in [SWS_SomeIpXf_00145] • paramtype is derived from type according to the parameter passing rules rules defined by the [15, SRS BSW General] (see [SRS_BSW_00484], [SRS_BSW_- 00485], and [SRS_BSW_00486]) and [14, SWS BSW General] (see [SWS_- BSW_00186] and [SWS_BSW_00187]). • type shall be the data type of the data element before all data conversion activi- ties of the RTE • transformerId shall be the name pattern for the transformer specified in [SWS_Xfrm_00062] ([3, ASWS Transformer General]).

In function SomeIpXf_Inv_<transformerId> defined in [SWS_SomeIpXf_00209] • transformerId shall be the name pattern for the transformer specified in [SWS_Xfrm_00062] ([3, ASWS Transformer General]).

A variable size array is represented in AUTOSAR by an ImplementationDataType with the category STRUCTURE and two sub-elements (namely payload and size indicator ). The data type of the length fields for the SOME/IP message for an variable size array shall be determined from the sizeOfAr- rayLengthFields . If the attribute sizeOfArrayLengthFields is not configured then the default value of 32 bit shall be used as defined by [PRS_SOMEIP_00945]. In case of nested variable size arrays, AUTOSAR allows to use profiles to specify size indicators which apply to more than one variable size array nested within the same ImplementationDataType . Depending on the specific profile ( dynamicArray- SizeProfile ), the data type of the of the length fields inside the SOME/IP message shall be determined differently: • VSA_LINEAR The data type of the SOME/IP length field shall be determined from the single sizeOfArrayLengthFields . If the attribute sizeOfArrayLengthFields is not configured then the default value of 32 bit shall be used as defined by [PRS_- SOMEIP_00945]. • VSA_SQUARE All data type of the SOME/IP length fields shall be determined from the single sizeOfArrayLengthFields . If the attribute sizeOfArrayLengthFields is not configured then the default value of 32 bit shall be used as defined by [PRS_- SOMEIP_00945]. • VSA_RECTANGULAR The data type of all SOME/IP length fields for all dimensions (nesting level) shall be determined from the single sizeOfArrayLengthFields . If the attribute sizeOfArrayLengthFields is not configured then the default value of 32 bit shall be used as defined by [PRS_SOMEIP_00945]. • VSA_FULLY_FLEXIBLE The data type of all SOME/IP length fields for all variable size arrays shall be de- termined from the single sizeOfArrayLengthFields . If the attribute sizeO- fArrayLengthFields is not configured then the default value of 32 bit shall be used as defined by [PRS_SOMEIP_00945].

If the value of dynamicArraySizeProfile equals VSA_LINEAR , the value of the length field of the serialized variable size array shall be calculated based on the value of the size indicator of the AUTOSAR data type.

If the value of dynamicArraySizeProfile of a multi- dimensional variable size array equals VSA_SQUARE , the value of all length fields of the nested serialized variable size arrays that belong to this multi-dimensional variable size arrays shall be calculated based on the value of the single size indicator of the AUTOSAR data type.

If the value of dynamicArraySizeProfile of a multi- dimensional variable size array equals VSA_RECTANGULAR , the values of all length fields of the nested serialized variable size arrays of the same nesting level (i.e. the same dimension) that belong to this multi-dimensional variable size array shall be cal- culated based on the values of the size indicators of the AUTOSAR data type for this respective nesting level.

If the value of dynamicArraySizeProfile of a multi- dimensional variable size array equals VSA_FULLY_FLEXIBLE , the values of all length fields of the nested serialized variable size arrays that belong to this multi-dimensional variable size arrays shall be calculated based on the value of the size indicator of the corresponding variable size array that is contained in the AUTOSAR data type.

The String specific serialization will only be triggered if an Unicode String is detected and implementsLegacyStringSerialization is false .

Recognition of UTF-8 Fixed Length Strings An UTF-8 Fixed Length String shall be detected if an ApplicationPrimitiveDataType and an ImplementationDataType with the following pattern are used: • ApplicationPrimitiveDataType – with category equal to STRING – ApplicationPrimitiveDataType . swDataDefProps . swTextProps . baseType refers to a BaseType with baseTypeDefinition . baseType- Encoding equal to UTF-8 • ImplementationDataType – with category ARRAY – that contains exactly one ImplementationDataTypeElement that boils down to a uint8 ImplementationDataType :  ImplementationDataTypeElement . arraySize is set to a value  ImplementationDataTypeElement . arraySizeSemantics is set to fixedSize

Recognition of UTF-16 Fixed Length Strings An UTF-16 Fixed Length String shall be detected if an ApplicationPrimitiveDataType and an ImplementationDataType with the following pattern are used: • ApplicationPrimitiveDataType – with category equal to STRING – ApplicationPrimitiveDataType . swDataDefProps . swTextProps . baseType refers to a BaseType with baseTypeDefinition . baseType- Encoding equal to UTF-16 • ImplementationDataType – with category ARRAY – that contains exactly one ImplementationDataTypeElement that boils down to a uint16 ImplementationDataType :  ImplementationDataTypeElement . arraySize is set to a value  ImplementationDataTypeElement . arraySizeSemantics is set to fixedSize

Recognition of UTF-8 Variable Length Strings An UTF-8 Fixed Length String shall be detected if an ApplicationPrimitiveDataType and an ImplementationDataType with the following pattern are used: • ApplicationPrimitiveDataType – with category equal to STRING – ApplicationPrimitiveDataType . swDataDefProps . swTextProps . baseType refers to a BaseType with baseTypeDefinition . baseType- Encoding equal to UTF-8 • ImplementationDataType The ImplementationDataType shall be defined according to [TPS_SWCT_- 01650] as a STRUCTURE that contains exactly two Implementation- DataTypeElement s and shall follow the rules defined by [constr_1318]: – one ImplementationDataTypeElement represents the Size Indica- tor and has the category equal to TYPE_REFERENCE which points to a uint8, uint16 or uint32 ImplementationDataType – one ImplementationDataTypeElement has the category equal to ARRAY and contains exactly one ImplementationDataTypeElement that boils down to a uint8 ImplementationDataType

Recognition of UTF-16 Variable Length Strings An UTF-16 Fixed Length String shall be detected if an ApplicationPrimitive- DataType and an ImplementationDataType with the following pattern are used: • ApplicationPrimitiveDataType – with category equal to STRING – ApplicationPrimitiveDataType . swDataDefProps . swTextProps . baseType refers to a BaseType with baseTypeDefinition . baseType- Encoding equal to UTF-16 • ImplementationDataType The ImplementationDataType shall be defined according to [TPS_SWCT_- 01650] as a STRUCTURE that contains exactly two Implementation- DataTypeElement s and shall follow the rules defined by [constr_1318]: – one ImplementationDataTypeElement represents the Size Indica- tor and has the category equal to TYPE_REFERENCE which points to a uint8, uint16 or uint32 ImplementationDataType – one ImplementationDataTypeElement has the category equal to ARRAY and contains exactly one ImplementationDataTypeElement that boils down to a uint16 ImplementationDataType

Serialization of fixed length strings Serialization of fixed length strings shall consist of the following steps: 1. Check whether the string terminates with 0x00 (UTF-8) or 0x0000 (UTF-16). If not, a E_SER_GENERIC_ERROR error shall be issued. 2. Appending BOM at the beginning of the output buffer, if BOM is not already avail- able in the first three (UTF-8) or two (UTF-16) bytes of the to be serialized array containing the string. If the BOM is already present, simply copy the BOM into the output buffer. 3. Copying the string data (the number of bytes according to the string's fixed length) from the array into the output buffer, optionally performing a conversion between UTF-16LE and UTF-16BE between ECU and network byte order if BaseTypeDi- rectDefinition . byteOrder and SOMEIPTransformationDescription . byteOrder have different values

Serialization of dynamic length strings Serialization of dynamic length strings shall consist of the followign steps: 1. Check whether the string terminates with 0x00 (UTF-8) or 0x0000 (UTF-16). If not, a E_SER_GENERIC_ERROR error shall be issued. 2. Add the Length Field - The value of the length field shall be computed by multi- plying the number of elements given by the size indicator with the size in bytes of each element (i.e., 1 for UTF-8 and 2 for UTF-16) increased by the size in bytes required by the BOM. The data type of the length field shall be determined from the sizeOfStringLengthFields . If the attribute sizeOfStringLength- Fields is not configured then the default value of 32 bit shall be used as de- fined by [PRS_SOMEIP_00094]. The value of the length field shall comply with [SWS_SomeIpXf_CONSTR_0001]. 3. Appending BOM at the beginning, if BOM is not already available in the first 3 (UTF-8) or 2 (UTF-16) bytes of the to be serialized array containing the string. If the BOM is already present, simply copy the BOM into the output buffer 4. Copying the string data (copy the the number of bytes according to the string's size indicator and the size of bytes of each element) from the array into the out- put buffer, optionally performing a conversion between UTF-16LE and UTF-16BE between ECU and network byte order BaseTypeDirectDefinition . byte- Order and SOMEIPTransformationDescription . byteOrder have differ- ent values

Deserialization of fixed length strings Deserialization of fixed length strings shall consist of the following steps: 1. Check whether the string starts with a BOM. If not, a MALFORMED_MESSAGE error shall be issued 2. Check whether BOM has the same value as SOMEIPTransformationDe- scription . byteOrder . If not, a MALFORMED_MESSAGE error shall be issued 3. Remove the BOM 4. Silently discard the last byte of the string in case of an UTF-16 string with odd length 5. Check whether the string terminates with 0x00 (UTF-8) or 0x0000 (UTF-16). If not, a MALFORMED_MESSAGE error shall be issued 6. Copy the string data (the number of bytes according to the string's fixed length) from the input buffer into the array, optionally performing a conversion between UTF-16LE and UTF-16BE between network and ECU byte order if BaseTypeDi- rectDefinition . byteOrder and SOMEIPTransformationDescription . byteOrder have different values.

. byteOrder have different values.

In case of UTF-16LE and UTF-16BE strings having an odd length, after removal of the last byte, the two bytes before shall be 0x00 bytes (termi- nation) for a string to be valid.

A union shall be detected if an Implementation- DataType with the following pattern (named wrapped union data type) is used: Im- plementationDataType with category STRUCTURE that contains exactly two Im- plementationDataTypeElement s: • memberSelector: ImplementationDataTypeElement which represents the type field that boils down to a uint8, uint16 or uint32 Implementation- DataType • payload: ImplementationDataTypeElement of category UNION which rep- resents the actual union

The data type of the type field of the union shall be determined from the ImplementationDataType of the first Implementation- DataTypeElement (memberSelector) in the wrapped union data type defined in [SWS_SomeIpXf_00249].

The value of the type field shall be set to the value defined by the first ImplementationDataTypeElement (memberSelector) in the wrapped union data type defined in [SWS_SomeIpXf_00249].

If attribute sizeOfStructLengthField of SOMEIP- TransformationProps is set to a value greater 0, a length field shall be inserted in front of the serialized struct for which the SOMEIPTransformationProps is de- fined. (See [TPS_SYST_02121])

If SOMEIPTransformationProps . sizeOf- StructLengthField is present for a struct the data type for the length field of the struct shall be determined by the value of SOMEIPTransformationProps . sizeOfStructLengthField : • uint8 if sizeOfStructLengthField equals 1 • uint16 if sizeOfStructLengthField equals 2 • uint32 if sizeOfStructLengthField equals 4 • Otherwise [SWS_SomeIpXf_00217] applies.

If attribute sizeOfUnionLengthField of SOMEIP- TransformationProps is set to a value greater 0, a length field shall be inserted in front of the serialized union for which the SOMEIPTransformationProps is de- fined. (See [TPS_SYST_02121]).

If attribute sizeOfArrayLengthField of SOMEIP- TransformationProps is set to a value greater 0, a length field shall be inserted in front of the serialized array for which the SOMEIPTransformationProps is de- fined. (See [TPS_SYST_02121])

If SOMEIPTransformationProps . sizeOfAr- rayLengthField is present for a static size array the data type for the length field of the array shall be determined by the value of SOMEIPTransformation- Props . sizeOfArrayLengthField : • uint8 if sizeOfArrayLengthField equals 1 • uint16 if sizeOfArrayLengthField equals 2 • uint32 if sizeOfArrayLengthField equals 4 • Otherwise [SWS_SomeIpXf_00221] applies.

If SOMEIPTransformationProps . sizeOfUnion- LengthField is present for a union the data type of the length field for the union shall be determined by the value of SOMEIPTransformationProps . sizeOfU- nionLengthField : • uint8 if sizeOfUnionLengthFields equals 1 • uint16 if sizeOfUnionLengthFields equals 2 • uint32 if sizeOfUnionLengthFields equals 4 • Otherwise [SWS_SomeIpXf_00225] applies.

After the serialized data of a variable data length Dat- aPrototype a padding for alignment purposes shall be added for the configured alignment (see [SWS_SomeIpXf_00260] and [SWS_SomeIpXf_00262]) if the variable data length DataPrototype is not the last element in the serialized data stream. This requirement does not apply for the serialization of extensible structs and methods.

If SOMEIPTransformationProps . alignment is set for a variable data length data element, the value of SOMEIPTransformationProps . alignment defines the alignment. This requirement does not apply for the serializa- tion of extensible structs and methods .

If SOMEIPTransformationProps . alignment is not set for a variable data length data element, the value of SOMEIPTransformationDe- scription . alignment defines the alignment. This requirement does not apply for the serialization of extensible structs and methods.

After serialized fixed data length data elements, the SOME/IP transformer shall never add automatically a padding for alignment.

If SomeIpXf_Inv_<transformerId> specified in [SWS_SomeIpXf_00144] is called with buffer equal to NULL_PTR and buffer- Length equal to 0, the output buffer buffer shall not be changed and SomeIpXf_Inv_<transformerId> shall return with E_NO_DATA .

If SomeIpXf_Inv_<transformerId> specified in [SWS_SomeIpXf_00145] is called with buffer equal to NULL_PTR and buffer- Length equal to 0, the output buffer buffer shall not be changed and SomeIpXf_Inv_<transformerId> shall return with E_NO_DATA .

If SomeIpXf_Inv_<transformerId> specified in [SWS_SomeIpXf_00209] is called with buffer equal to NULL_PTR and buffer- Length equal to 0, the output buffer buffer shall not be changed and SomeIpXf_Inv_<transformerId> shall return with E_NO_DATA .

The length of a tag shall be two bytes.

The tag shall consist of • reserved (Bit 7 of the first byte) • wire type (Bit 6-4 of the first byte) • Data ID (Bit 3-0 of the first byte and bit 7-0 of the second byte) Bit 7 is the highest significant bit of a byte, bit 0 is the lowest significant bit of a byte.

The lower significant part of the Data ID of the member shall be encoded in bits 7-0 of the second byte of the tag. The higher significant part of the Data ID of the member shall be encoded in bits 3-0 of the first byte.

The wire type shall determine the type of the following data of the member. The value shall be assigned as shown in Table 7.9.

If SOMEIPTransformationISignalProps . isDynami- cLengthFieldSize is set to false or is not defined, the transformer shall use wire type 4 for serializing complex types and shall use the fixed size length fields. The size of the length fields is defined in SOMEIPTransformationISignalProps . sizeOfAr- rayLengthFields , sizeOfStructLengthFields and sizeOfUnionLength- Fields .

SOMEIPTransformationISignalProps . isDynami- cLengthFieldSize is set to true, the transformer shall use wire types 5,6,7 for serializing complex types and shall chose the size of the length field according to this wire type.

A deserializer shall always be able to handle the wire types 4, 5, 6 and 7 independent of the setting of SOMEIPTransformationISignalProps . isDynamicLengthFieldSize

If a Data ID is defined for an ArgumentDataPrototype or ImplementationDataTypeElement by means of SOMEIPTransformation- ISignalProps . tlvDataId .id, a tag shall be inserted in the serialized byte stream.

If the datatype of the serialized member / argument is a basic datatype (wire types 0-3) and a Data ID is configured, the tag shall be inserted directly in front of the member/argument. No length field shall be inserted into the serialized stream.

If the datatype of the serialized member/argument is not a basic datatype (wire type 4-7) and a Data ID is configured, the tag shall be inserted in front of the length field.

If the datatype of the serialized member/argument is not a basic datatype and a Data ID is configured, a length field shall always be inserted in front of the member/argument.

The length field shall always contain the length up to the next tag of the struct, but does not include the tag size and length field size itself.

If the member itself is of type struct, there shall be exactly one length field.

If the member itself is of type dynamic length string, there shall be exactly one length field.

If the member itself is of type fixed length string, there shall be exactly one length field corresponding to dynamic length strings.

⌊ DRAFT g If the member itself is of type dynamic length ar- ray, there shall be exactly one length field.

If the member itself is of type fixed length array, there shall be exactly one length field.

If the member itself is of type union, there shall be exactly one length field.

For the serialization of extensible structs and methods the length field shall cover the size of the type field, data and padding bytes if the member itself is of type union.

A member of a non-extensible (standard) struct which is of type extensible struct, shall be serialized according to the requirements for extensible structs.

A member of an extensible struct which is of type non- extensible (standard) struct, shall be serialized according to the requirements for stan- dard structs.

For the serialization of extensible structs and methods no alignment shall be applied.

If the attribute isStructWithOptionalElement of the ImplementationDataType representing the extensible struct is set to true, the transformer shall ignore the first ImplementationDataTypeElement and shall not se- rialize or deserialize it.

The transformer shall only serialize an optional member of a struct if the corresponding bit in the availability bitfield is set as follows: (availabilityBitfield[(pos/8)] & (1<<(pos mod 8))) != 0

If an optional member is available in the serialized byte stream, the transformer shall set the corresponding bit in the availability bitfield as follows: availabilityBitfield[(pos/8)] = availabilityBitfield[(pos/8)] | (1<<(pos mod 8))

If an optional member is not available in the serialized byte stream, the transformer shall clear the corresponding bit in the availability bitfield as follows: availabilityBitfield[(pos/8)] = availabilityBitfield[(pos/8)] & ~(1<<(pos mod 8))

If the transformer reads an unknown Data ID (i.e. not con- tained in its data definition), it shall skip the unknown member/argument by using the information of the wire type and length field.

If the transformer cannot find a required (i.e. non-optional) member defined in its data definition in the serialized byte stream, the deserialization shall be aborted with E_SER_MALFORMED_MESSAGE . For examples, please refer to [10].

If an optional member is not available in the received se- rialized byte stream, the transformer shall keep the memory section occupied by this optional element without modification.

The function SomeIpXf_ExtractProtocolHeader- Fields specified in [SWS_SomeIpXf_91001] shall extract the type of a message and the type of the message result from the SOME/IP protocol header and provide this in- formation in a canonical representation via its output arguments.

The function SomeIpXf_ExtractProtocolHeader- Fields specified in [SWS_SomeIpXf_91001] shall check whether the provided bufferLength is larger or equal than the size of the protocol header processed by the SOME/IP transformer (i.e., 8 bytes). – If this is not the case, E_NOT_OK shall be returned. Neither messageType nor messageResult shall be modified in this case.

The function SomeIpXf_ExtractProtocolHeader- Fields specified in [SWS_SomeIpXf_91001] shall check whether the value of the Protocol Version field (see [PRS_SOMEIP_00052]) is equal to the value defined by [PRS_SOMEIP_00051]. – If this is not the case, E_NOT_OK shall be returned. Nei- ther messageType nor messageResult shall be modified in this case.

The function SomeIpXf_ExtractProtocolHeader- Fields specified in [SWS_SomeIpXf_91001] shall check whether the value of the Message Type field (see [PRS_SOMEIP_00055]) is equal REQUEST , RESPONSE , or ERROR . – If this is not the case, E_NOT_OK shall be returned. Neither messageType nor messageResult shall be modified in this case.

Bitfields shall be transported as basic datatypes uint8/uint16/uint32.

The function SomeIpXf_ExtractProtocolHeader- Fields specified in [SWS_SomeIpXf_91001] shall return E_OK in all other cases.

The function SomeIpXf_ExtractProtocolHead- erFields specified in [SWS_SomeIpXf_91001] shall set messageType to STD_MESSAGETYPE_REQUEST in case the value of the Message Type field (see [PRS_SOMEIP_00055]) is equal REQUEST .

The function SomeIpXf_ExtractProtocolHead- erFields specified in [SWS_SomeIpXf_91001] shall set messageType to STD_MESSAGETYPE_RESULT in case the value of the Message Type field (see [PRS_SOMEIP_00055]) is equal RESULT or ERROR .

The function SomeIpXf_ExtractProtocolHeader- Fields specified in [SWS_SomeIpXf_91001] shall set messageResult to STD_MESSAGERESULT_ERROR in case the value of the Message Type field (see [PRS_SOMEIP_00055]) is equal to ERROR or if the value of the Return Code field (see [PRS_SOMEIP_00058]) is different from 0.

The function SomeIpXf_ExtractProtocolHeader- Fields specified in [SWS_SomeIpXf_91001] shall set messageResult to STD_MESSAGERESULT_OK otherwise (i.e., in case the value of the Message Type field (see [PRS_SOMEIP_00055]) is different from ERROR and if the value of the Return Code field (see [PRS_SOMEIP_00058]) is 0.

Serialization based on NetworkRepresentation If a networkRepresentationProps is defined according to [TPS_SYST_02136] on the ISignal , then the SOME/IP serialization shall be based on the networkRepresen- tationProps .

Serialization based on ImplementationDataTypes If no networkRepresentationProps is defined on the ISignal , then (according to [TPS_SYST_02137]) the SOME/IP serialization shall be based on the Implementa- tionDataType s.

In accordance with [SWS_SomeIpXf_00245], 2 ˆ (8*sizeof(data type of length field)) shall be larger than the number of elements given by the size indicator multiplied by the size in bytes of each element (i.e., 1 for UTF-8 and 2 for UTF-16) and increased by the size in bytes required by the BOM.

Serialization based on the network representa- tion according to [TPS_SYST_02136] is currently not supported in combination with structured datatypes and arguments with identifier and optional members, strings, dy- namic length arrays / variable size arrays, and unions / variants and shall therefore not be used in those combinations.