| /////////////////////////////////////////////////////////////////////////////// |
| // // |
| // Copyright Test Competence Center (TCC) ETH 2016 // |
| // // |
| // The copyright to the computer program(s) herein is the property of TCC. // |
| // The program(s) may be used and/or copied only with the written permission // |
| // of TCC or in accordance with the terms and conditions stipulated in the // |
| // agreement/contract under which the program(s) has been supplied. // |
| // // |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // File: SS_PDU_Defs.asn |
| // Rev: R1B |
| // Prodnr: CNL 113 832 |
| // Contact: http://ttcn.ericsson.se |
| // Reference: 3GPP TS 24.008 v13.4.0 |
| |
| #include "SS_PDU_Defs.hh" |
| #include "SS_Types.hh" |
| |
| namespace SS__Types |
| { |
| using namespace SS__PDU__Defs; |
| TTCN_Module SS__EncDec("SS_EncDec", __DATE__, __TIME__); |
| |
| //Type definitions to transfer data between coding functions |
| struct SS_Invoke_for_dec |
| { |
| INTEGER invokeId; |
| OPTIONAL<INTEGER> linkedId; |
| Remote__Operations__Information__Objects::Code opcode; |
| OPTIONAL<OCTETSTRING> stream; |
| }; |
| |
| struct SS_ReturnResult_for_dec |
| { |
| INTEGER invokeId; |
| OPTIONAL<Remote__Operations__Information__Objects::Code> opcode; |
| OPTIONAL<OCTETSTRING> stream; |
| }; |
| |
| struct SS_ReturnError_for_dec |
| { |
| INTEGER invokeId; |
| Remote__Operations__Information__Objects::Code errorCode; |
| OPTIONAL<OCTETSTRING> stream; |
| }; |
| |
| struct SS_Reject_for_dec |
| { |
| OPTIONAL<INTEGER> invokeId; |
| Remote__Operations__Generic__ROS__PDUs::ProblemType problem; |
| }; |
| |
| |
| ////////////////////////////////// |
| // Encoding function for SS__Invoke |
| ////////////////////////////////// |
| OCTETSTRING enc_SS_Invoke(const SS__Invoke& pdu) |
| { |
| TTCN_Buffer buf; |
| |
| OCTETSTRING ret_val; |
| pdu.encode(SS__Invoke_descr_, buf, TTCN_EncDec::CT_BER, BER_ENCODE_DER); |
| buf.get_string(ret_val); |
| ret_val[0] = int2oct(161,1); |
| |
| return ret_val; |
| } |
| ////////////////////////////////// |
| // Encoding function for SS__ReturnResult |
| ////////////////////////////////// |
| OCTETSTRING enc_SS_ReturnResult(const SS__ReturnResult& pdu) |
| { |
| TTCN_Buffer buf; |
| |
| OCTETSTRING ret_val; |
| pdu.encode(SS__ReturnResult_descr_, buf, TTCN_EncDec::CT_BER, BER_ENCODE_DER); |
| buf.get_string(ret_val); |
| ret_val[0] = int2oct(162,1); |
| |
| return ret_val; |
| } |
| ////////////////////////////////// |
| // Encoding function for SS__ReturnError |
| ////////////////////////////////// |
| OCTETSTRING enc_SS_ReturnError(const SS__ReturnError& pdu) |
| { |
| TTCN_Buffer buf; |
| |
| OCTETSTRING ret_val; |
| pdu.encode(SS__ReturnError_descr_, buf, TTCN_EncDec::CT_BER, BER_ENCODE_DER); |
| buf.get_string(ret_val); |
| ret_val[0] = int2oct(163,1); |
| |
| return ret_val; |
| } |
| ////////////////////////////////// |
| // Encoding function for SS__Reject |
| ////////////////////////////////// |
| OCTETSTRING enc_SS_Reject(const SS__Reject& pdu) |
| { |
| TTCN_Buffer buf; |
| |
| OCTETSTRING ret_val; |
| pdu.encode(SS__Reject_descr_, buf, TTCN_EncDec::CT_BER, BER_ENCODE_DER); |
| buf.get_string(ret_val); |
| ret_val[0] = int2oct(164,1); |
| |
| return ret_val; |
| } |
| |
| ////////////////////////////////// |
| // Decoding function for SS__Invoke |
| ////////////////////////////////// |
| int dec_SS_Invoke(const SS_Invoke_for_dec& params, SS__Invoke& pdu) |
| { |
| SS__Invoke__help help_pdu; |
| |
| if(params.stream.ispresent()) |
| { |
| help_pdu.invokeId().present__() = params.invokeId; |
| if(params.linkedId.ispresent()) |
| help_pdu.linkedId()().present__().present__() = params.linkedId; |
| else |
| help_pdu.linkedId() = OMIT_VALUE; |
| |
| help_pdu.opcode() = params.opcode; |
| |
| OCTETSTRING oct_stream = params.stream; |
| help_pdu.argument() = oct_stream; |
| TTCN_Buffer buf; |
| help_pdu.encode(SS__Invoke__help_descr_, buf, TTCN_EncDec::CT_BER, BER_ENCODE_DER); |
| |
| TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL, TTCN_EncDec::EB_IGNORE);
|
| TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL, TTCN_EncDec::EB_WARNING);
|
| TTCN_EncDec::clear_error();
|
| |
| pdu.decode(SS__Invoke_descr_, buf, TTCN_EncDec::CT_BER, BER_ACCEPT_ALL); |
| |
| TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL, TTCN_EncDec::EB_DEFAULT); |
| |
| if(TTCN_EncDec::get_last_error_type() != 0) return 1; |
| } |
| else |
| { |
| pdu.invokeId().present__() = params.invokeId; |
| |
| if(params.linkedId.ispresent()) |
| pdu.linkedId()().present__().present__() = params.linkedId; |
| else |
| pdu.linkedId() = OMIT_VALUE; |
| |
| pdu.opcode() = params.opcode; |
| |
| pdu.argument() = OMIT_VALUE; |
| } |
| |
| return 0; |
| } |
| |
| ////////////////////////////////// |
| // Decoding function for SS__ReturnResult |
| ////////////////////////////////// |
| int dec_SS_ReturnResult(const SS_ReturnResult_for_dec& params, SS__ReturnResult& pdu) |
| { |
| SS__ReturnResult__help help_pdu; |
| |
| |
| if(params.opcode.ispresent() && params.stream.ispresent()) |
| { |
| help_pdu.invokeId().present__() = params.invokeId; |
| help_pdu.result()().opcode() = params.opcode; |
| OCTETSTRING oct_stream = params.stream; |
| help_pdu.result()().result() = oct_stream; |
| TTCN_Buffer buf; |
| help_pdu.encode(SS__ReturnResult__help_descr_, buf, TTCN_EncDec::CT_BER, BER_ENCODE_DER); |
| |
| TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL, TTCN_EncDec::EB_IGNORE);
|
| TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL, TTCN_EncDec::EB_WARNING);
|
| TTCN_EncDec::clear_error(); |
| |
| pdu.decode(SS__ReturnResult_descr_, buf, TTCN_EncDec::CT_BER, BER_ACCEPT_ALL); |
| |
| TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL, TTCN_EncDec::EB_DEFAULT); |
| |
| if(TTCN_EncDec::get_last_error_type() != 0) return 1; |
| } |
| else |
| { |
| pdu.invokeId().present__() = params.invokeId; |
| pdu.result() = OMIT_VALUE; |
| } |
| |
| return 0; |
| } |
| |
| ////////////////////////////////// |
| // Decoding function for SS__ReturnError |
| ////////////////////////////////// |
| int dec_SS_ReturnError(const SS_ReturnError_for_dec& params, SS__ReturnError& pdu) |
| { |
| |
| SS__ReturnError__help help_pdu; |
| |
| if(params.stream.ispresent()) |
| { |
| help_pdu.invokeId().present__() = params.invokeId; |
| help_pdu.errcode() = params.errorCode; |
| OCTETSTRING oct_stream = params.stream; |
| help_pdu.parameter()() = oct_stream; |
| |
| TTCN_Buffer buf; |
| |
| help_pdu.encode(SS__ReturnError__help_descr_, buf, TTCN_EncDec::CT_BER, BER_ENCODE_DER); |
| |
| TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL, TTCN_EncDec::EB_IGNORE);
|
| TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL, TTCN_EncDec::EB_WARNING);
|
| TTCN_EncDec::clear_error(); |
| |
| pdu.decode(SS__ReturnError_descr_, buf, TTCN_EncDec::CT_BER, BER_ACCEPT_ALL); |
| |
| TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL, TTCN_EncDec::EB_DEFAULT); |
| |
| if(TTCN_EncDec::get_last_error_type() != 0) return 1; |
| } |
| else |
| { |
| pdu.invokeId().present__() = params.invokeId; |
| pdu.errcode() = params.errorCode; |
| pdu.parameter() = OMIT_VALUE; |
| } |
| |
| return 0; |
| } |
| |
| ////////////////////////////////// |
| // Decoding function for SS__Reject |
| ////////////////////////////////// |
| int dec_SS_Reject(const SS_Reject_for_dec& params, SS__Reject& pdu) |
| { |
| if(params.invokeId.ispresent()) |
| pdu.invokeId().present__() = params.invokeId; |
| else |
| pdu.invokeId().absent() = ASN_NULL_VALUE; |
| |
| pdu.problem() = params.problem; |
| |
| return 0; |
| } |
| |
| //////////////////////////////////////////////////////////////////// |
| // Decoding function for internal SS_TCAP_ComponentPortion |
| //////////////////////////////////////////////////////////////////// |
| int dec__SS__TCAP__ComponentPortion(const OCTETSTRING& stream, SS__TCAP__ComponentPortion& pdu) |
| { |
| if (TTCN_Logger::log_this_event(TTCN_Logger::DEBUG_ENCDEC)) |
| { |
| TTCN_Logger::begin_event(TTCN_Logger::DEBUG_ENCDEC); |
| TTCN_Logger::log_event_str("dec_SS_TCAP_ComponentPortion(): Stream before decoding: "); |
| stream.log(); |
| TTCN_Logger::end_event(); |
| } |
| |
| TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL, TTCN_EncDec::EB_IGNORE);
|
| TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL, TTCN_EncDec::EB_WARNING);
|
| TTCN_EncDec::clear_error();
|
| |
| TTCN_Buffer ttcn_buffer(stream); |
| SS__TCAP__Component ret_sub_val; |
| int i = 0; |
| |
| if(!ttcn_buffer.contains_complete_TLV()) { |
| if (TTCN_Logger::log_this_event(TTCN_Logger::TTCN_WARNING)) |
| { |
| TTCN_Logger::begin_event(TTCN_Logger::TTCN_WARNING); |
| TTCN_Logger::log_event_str("dec_SS_TCAP_ComponentPortion(): there is no complete TLV in the incoming stream!"); |
| TTCN_Logger::end_event(); |
| } |
| return 1; |
| } |
| |
| while(ttcn_buffer.contains_complete_TLV()) |
| { |
| ret_sub_val.decode(SS__TCAP__Component_descr_, ttcn_buffer, TTCN_EncDec::CT_BER, BER_ACCEPT_ALL); |
| pdu[i] = ret_sub_val; |
| i++; |
| ttcn_buffer.cut(); |
| } |
| |
| TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL, TTCN_EncDec::EB_DEFAULT); |
| |
| if (TTCN_Logger::log_this_event(TTCN_Logger::DEBUG_ENCDEC)) |
| { |
| TTCN_Logger::begin_event(TTCN_Logger::DEBUG_ENCDEC); |
| TTCN_Logger::log_event_str("dec_SS_TCAP_ComponentPortion(): Decoded @SS_Types.SS_TCAP_ComponentPortion: "); |
| pdu.log(); |
| TTCN_Logger::end_event(); |
| } |
| |
| return TTCN_EncDec::get_last_error_type() == TTCN_EncDec::ET_NONE ? 0 : 1; |
| } |
| |
| |
| ////////////////////////////////////////////////////////////////////////////////////////////////////// |
| // Main encoding function for SS_FacilityInformation. This is called from TTCN-3 |
| ////////////////////////////////////////////////////////////////////////////////////////////////////// |
| OCTETSTRING enc__SS__FacilityInformation(const SS__FacilityInformation& pdu) |
| { |
| if (TTCN_Logger::log_this_event(TTCN_Logger::DEBUG_ENCDEC)) |
| { |
| TTCN_Logger::begin_event(TTCN_Logger::DEBUG_ENCDEC); |
| TTCN_Logger::log_event_str("enc_SS_FacilityInformation(): SS_FacilityInformation before encoding: "); |
| pdu.log(); |
| TTCN_Logger::end_event(); |
| } |
| SS__TCAP__ComponentPortion temp_val; |
| OCTETSTRING ret_val(0,NULL); |
| |
| for (int i = 0; i < pdu.size_of(); i++) |
| { |
| if (pdu[i].get_selection() == SS__Component::ALT_invoke) |
| { |
| ret_val = ret_val + enc_SS_Invoke(pdu[i].invoke()); |
| } |
| else if (pdu[i].get_selection() == SS__Component::ALT_returnResult) |
| { |
| ret_val = ret_val + enc_SS_ReturnResult(pdu[i].returnResult()); |
| } |
| else if (pdu[i].get_selection() == SS__Component::ALT_returnError) |
| { |
| ret_val = ret_val + enc_SS_ReturnError(pdu[i].returnError()); |
| } |
| else if (pdu[i].get_selection() == SS__Component::ALT_reject) |
| { |
| ret_val = ret_val + enc_SS_Reject(pdu[i].reject()); |
| } |
| } |
| if (TTCN_Logger::log_this_event(TTCN_Logger::DEBUG_ENCDEC)) |
| { |
| TTCN_Logger::begin_event(TTCN_Logger::DEBUG_ENCDEC); |
| TTCN_Logger::log_event_str("enc_SS_FacilityInformation(): stream after encoding: "); |
| ret_val.log(); |
| TTCN_Logger::end_event(); |
| } |
| return ret_val; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////////////////////// |
| // Main decoding function for SS_FacilityInformation. This is called from TTCN-3 |
| ////////////////////////////////////////////////////////////////////////////////////////////////////// |
| INTEGER dec__SS__FacilityInformation__backtrack(const OCTETSTRING& stream, SS__FacilityInformation& pdu) |
| { |
| if (TTCN_Logger::log_this_event(TTCN_Logger::DEBUG_ENCDEC)) |
| { |
| TTCN_Logger::begin_event(TTCN_Logger::DEBUG_ENCDEC); |
| TTCN_Logger::log_event_str("dec_SS_FacilityInformation__backtrack(): Stream before decoding: "); |
| stream.log(); |
| TTCN_Logger::end_event(); |
| } |
| |
| SS__TCAP__ComponentPortion temp_val; |
| int decode = dec__SS__TCAP__ComponentPortion(stream, temp_val); |
| |
| if(decode == 0) { |
| |
| for (int i = 0; i < temp_val.size_of() && decode == 0; i++) |
| { |
| if (temp_val[i].get_selection() == SS__TCAP__Component::ALT_invoke) |
| { |
| SS_Invoke_for_dec par_val; |
| par_val.invokeId = temp_val[i].invoke().invokeID(); |
| par_val.linkedId = temp_val[i].invoke().linkedID(); |
| par_val.opcode = temp_val[i].invoke().operationCode(); |
| par_val.stream = temp_val[i].invoke().parameter(); |
| decode = dec_SS_Invoke(par_val, pdu[i].invoke()); |
| } |
| else if (temp_val[i].get_selection() == SS__TCAP__Component::ALT_returnResult) |
| { |
| SS_ReturnResult_for_dec par_val; |
| par_val.invokeId = temp_val[i].returnResult().invokeID(); |
| |
| if(temp_val[i].returnResult().result().ispresent()) |
| { |
| SS__TCAP__ReturnResult__Result temp_res = temp_val[i].returnResult().result(); |
| par_val.opcode = temp_res.operationCode(); |
| par_val.stream = temp_res.parameter(); |
| } |
| else |
| { |
| par_val.opcode = OMIT_VALUE; |
| par_val.stream = OMIT_VALUE; |
| } |
| decode = dec_SS_ReturnResult(par_val, pdu[i].returnResult()); |
| } |
| else if (temp_val[i].get_selection() == SS__TCAP__Component::ALT_returnError) |
| { |
| SS_ReturnError_for_dec par_val; |
| par_val.invokeId = temp_val[i].returnError().invokeID(); |
| par_val.errorCode = temp_val[i].returnError().errorCode(); |
| par_val.stream = temp_val[i].returnError().parameter(); |
| |
| decode = dec_SS_ReturnError(par_val, pdu[i].returnError()); |
| } |
| else if (temp_val[i].get_selection() == SS__TCAP__Component::ALT_reject) |
| { |
| SS_Reject_for_dec par_val; |
| if( temp_val[i].reject().invokeID().get_selection() == SS__TCAP__Reject_invokeID::ALT_derivable) |
| par_val.invokeId = temp_val[i].reject().invokeID().derivable(); |
| else |
| par_val.invokeId = OMIT_VALUE; |
| par_val.problem = temp_val[i].reject().problem(); |
| |
| decode = dec_SS_Reject(par_val, pdu[i].reject()); |
| } |
| } |
| } |
| |
| if (TTCN_Logger::log_this_event(TTCN_Logger::DEBUG_ENCDEC)) |
| { |
| TTCN_Logger::begin_event(TTCN_Logger::DEBUG_ENCDEC); |
| TTCN_Logger::log_event_str("dec_SS_FacilityInformation__backtrack(): Decoded @SS_Types.SS_FacilityInformation: "); |
| pdu.log(); |
| TTCN_Logger::end_event(); |
| } |
| |
| return decode; |
| } |
| |
| SS__FacilityInformation dec__SS__FacilityInformation(const OCTETSTRING& stream) |
| { |
| SS__FacilityInformation ret; |
| dec__SS__FacilityInformation__backtrack(stream, ret); |
| return ret; |
| } |
| |
| }//namespace |
| |