Newer
Older
/*
* @author STF 276
* @version $Id$
* @desc This module specifies common ICMP messages
* interchanges (= operations) for an Ipv6 test component
* Functions do not set a test component verdict but instead
* use the function return value instead to notify the function
* caller about the success of the operation.
*
*/
module LibIpv6_Rfc2463Icmpv6_Functions {
//LibCommon
import from LibCommon_BasicTypesAndValues all;
import from LibCommon_DataStrings all;
import from LibCommon_VerdictControl { type FncRetCode };
//LibIpv6
import from LibIpv6_Interface_TypesAndValues all ;
import from LibIpv6_Interface_Functions all;
import from LibIpv6_Interface_Templates all;
import from LibIpv6_CommonRfcs_TypesAndValues all;
import from LibIpv6_CommonRfcs_Functions all;
import from LibIpv6_Rfc2463Icmpv6_Templates all;
import from LibIpv6_Rfc2463Icmpv6_TypesAndValues all;
/*
* @desc This sends an ICMPv6 echo request from an IPv6 node to
* any NUT. Prior it modifies IPv6 packet payload length
* and ICMPv6 checksum to their correct values using external
* functions.
* @remark The template passed in must NOT contain any matching expressions!
* @param p_echoRequest Ipv6 packet value or template with echo request to be sent
* @return execution status
*/
function f_sendEchoRequest (in template EchoRequest p_echoRequest)
runs on LibIpv6Node
return FncRetCode {
tepelmann
committed
var EchoRequest v_ipPkt;
if(f_setExtensionHeaders( v_ipPkt ) != e_success) {
log(" **** f_sendEchoRequest: Error when calculating length of extension headers ****");
return e_error;
}
//send
ipPort.send(v_ipPkt);
return e_success;
}//end f_sendEchoRequest
/*
* @desc This sends an ICMPv6 echo request from an IPv6 node to any NUT.
* Prior it modifies IPv6 packet payload length and ICMPv6 checksum
* to their correct values using external functions
* @remark The template passed in must NOT contain any matching expressions!
* @param p_echoReply Ipv6 packet value or template with echo reply to be sent
* @return execution status
*/
function f_sendEchoReply (in template EchoReply p_echoReply)
runs on LibIpv6Node
return FncRetCode {
tepelmann
committed
var EchoReply v_ipPkt;
if(f_setExtensionHeaders( v_ipPkt ) != e_success) {
log(" **** f_sendEchoReply: Error when calculating length of extension headers ****");
return e_error;
}
//send
ipPort.send(v_ipPkt);
return e_success;
}//end f_sendEchoReply
* @desc This sends an ICMPv6 echo request from an IPv6 node to any NUT,
* and waits for any ICMP packet for a fixed amount of time.
* @remark Time limit is defined by module parameter PX_TAC (see comp type)
* @param p_hops Number of hops to be used in IPv6 header
* @param p_llaAddrTn Local link address of testing node which calls this function
* @param p_llaAddrNut Local link address of node under test
* @param p_ipPkt ICMPv6 packet which has been received
* @return execution status
in template Ipv6Address p_llaAddrTn,
in template Ipv6Address p_llaAddrNut,
out Ipv6Packet p_ipPkt)
runs on LibIpv6Node
return FncRetCode {
var FncRetCode v_ret;
v_ret := f_sendEchoRequest (
m_echoRequest_noExtHdr_noData_hop (
p_llaAddrTn,
p_llaAddrNut,
p_hops,
c_defId,
c_defSeqNo ) );
if ( v_ret != e_success ) {return v_ret;}
tc_ac.start;
alt {
[] ipPort.receive(mw_ipPkt) -> value p_ipPkt {
tc_ac.stop;
return e_success;
}
[] tc_ac.timeout{
return e_timeout;
}
} // end alt
} // end f_getIcmpAfterEchoReq
* @desc This sends an ICMPv6 echo request from an IPv6 node to any NUT,
* and waits for a Time Exceeded message for a fixed amount of time.
* @remark Time limit is defined by module parameter PX_TAC (see comp type)
* @param p_hops Number of hops to be used in IPv6 header
* @param p_llaAddrTn Local link address of testing node which calls this function
* @param p_llaAddrNut Local link address of node under test
* @param p_llaAddrRut Local link address of router under test
* @return execution status
in template Ipv6Address p_llaAddrTn,
in template Ipv6Address p_llaAddrNut,
in template Ipv6Address p_llaAddrRut)
runs on LibIpv6Node
return FncRetCode {
var FncRetCode v_ret;
v_ret := f_sendEchoRequest (
m_echoRequest_noExtHdr_noData_hop (
p_llaAddrTn,
p_llaAddrNut,
p_hops,
c_defId,
c_defSeqNo ) );
if ( v_ret != e_success ) {return v_ret;}
tc_ac.start;
alt {
[] ipPort.receive(mw_timeExceeded_noExtHdr ( p_llaAddrRut,
p_llaAddrTn,
c_icmpCode0 )) {
tc_ac.stop;
return e_success;
}
[] tc_ac.timeout{
return e_timeout;
}
} // end alt
* @desc This sends an ICMPv6 echo request from an IPv6 node to any NUT,
* and waits for a Packet Too Big message for a fixed amount of time.
* @remark Time limit is defined by module parameter PX_TAC (see comp type)
* @param p_echoRequest Template of the Echo Request to be sent
* @param p_packetTooBig Template of the Packet Too Big message that is expected
* @return execution status
*/
function f_getPacketTooBigAfterEchoReq (
template EchoRequest p_echoRequest,
template PacketTooBig p_packetTooBig )
runs on LibIpv6Node
return FncRetCode {
var FncRetCode v_ret;
v_ret := f_sendEchoRequest ( p_echoRequest );
if ( v_ret != e_success ) {return v_ret;}
tc_ac.start;
alt {
[] ipPort.receive ( p_packetTooBig ) {
tc_ac.stop;
return e_success;
}
[] tc_ac.timeout{
return e_timeout;
}
} // end alt
} // end f_getPacketTooBigAfterEchoReq
* @desc This sends an ICMPv6 echo request from an IPv6 node to any NUT,
* and waits for a Destination Unreachable message for a fixed amount of time.
* @remark Time limit is defined by module parameter PX_TAC (see comp type)
* @param p_echoRequest Template of the Echo Request to be sent
* @param p_destUnreachable Template of the Packet Too Big message that is expected
* @return execution status
*/
function f_getDestinationUnreachableAfterEchoReq (
template EchoRequest p_echoRequest,
template DestinationUnreachable p_destUnreachable )
runs on LibIpv6Node
return FncRetCode {
var FncRetCode v_ret;
v_ret := f_sendEchoRequest ( p_echoRequest );
if ( v_ret != e_success ) {return v_ret;}
tc_ac.start;
alt {
[] ipPort.receive ( p_destUnreachable ) {
tc_ac.stop;
return e_success;
}
[] tc_ac.timeout{
return e_timeout;
}
} // end alt
} // end f_getDestinationUnreachableAfterEchoReq
* @desc This sends an ICMPv6 echo request from an IPv6 node to any
* NUT, and waits for a echo reply for a fixed amount of time.
* This function can be used to verify that the NUT is
* up and running.
* @remark Time limit is defined by module parameter PX_TAC (see comp type)
* @param p_llaAddrTn Local link address of testing node which calls this function
* @param p_llaAddrNut Local link address of node under test
* @param p_identifier Idenitifier to be used in ICMPv6 echo request
* @param p_seqNo Sequence number to be used in ICMPv6 echo request
* @param p_icmpPkt IPv6 packet which has been received
* @return execution status
function f_echoProcUp( in template Ipv6Address p_llaAddrTn,
in template Ipv6Address p_llaAddrNut,
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
in UInt16 p_identifier,
in UInt16 p_seqNo,
out EchoReply p_icmpPkt)
runs on LibIpv6Node
return FncRetCode {
var EchoReply v_echoRep;
var FncRetCode v_ret;
v_ret := f_sendEchoRequest( m_echoRequest_noExtHdr_noData( p_llaAddrTn,
p_llaAddrNut,
p_identifier,
p_seqNo ));
if ( v_ret != e_success ) {return v_ret;}
tc_ac.start;
alt {
[] ipPort.receive(mw_echoReply ( p_llaAddrNut,
p_llaAddrTn )) -> value v_echoRep {
p_icmpPkt := v_echoRep ;
tc_ac.stop;
return e_success;
}
[] tc_ac.timeout{
return e_timeout;
}
} // end alt
} // end f_echoProcUp
/*
* @desc This sends an ICMPv6 echo request from an IPv6 node to any NUT,
* and waits for a echo reply for a fixed amount of time.
* @remark Time limit is defined by module parameter PX_TAC (see comp type)
* @param p_llaAddrTn Local link address of testing node which calls this function
* @param p_llaAddrNut Local link address of node under test
* @param p_identifier Idenitifier to be used in ICMPv6 echo request
* @param p_seqNo Sequence number to be used in ICMPv6 echo request
* @return execution status
function f_replyToEchoRequest(in template Ipv6Address p_llaAddrTn,
in template Ipv6Address p_llaAddrNut,
in UInt16 p_seqNo,
out EchoRequest p_echoRequest)
runs on LibIpv6Node
return FncRetCode {
var FncRetCode v_ret := e_error;
tc_ac.start;
alt {
[] ipPort.receive(mw_echoRequest ( p_llaAddrNut,
p_llaAddrTn )) -> value p_echoRequest {
tc_ac.stop;
v_ret := e_success;
}
[] tc_ac.timeout{
return e_timeout;
}
} // end alt
v_ret := f_sendEchoReply( m_echoReply_noExtHdr_data( p_llaAddrTn,
p_echoRequest.ipv6Payload.echoRequestMsg.data ));
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
function f_replyToEchoRequest_DS(in template Ipv6Address p_llaAddrTn,
in template Ipv6Address p_llaAddrNut,
in UInt16 p_identifier,
in UInt16 p_seqNo )
runs on LibIpv6Node
return FncRetCode {
var FncRetCode v_ret := e_error;
var EchoRequest echoRequest;
tc_ac.start;
alt {
[] ipPort.receive(mw_echoRequest ( p_llaAddrNut,
p_llaAddrTn )) -> value echoRequest {
tc_ac.stop;
v_ret := e_success;
}
[] tc_ac.timeout{
return e_timeout;
}
} // end alt
// v_ret := f_sendEchoReply( m_echoReply_noExtHdr_data( p_llaAddrTn,
// p_llaAddrNut,
// p_identifier,
// p_seqNo,
// echoRequest.data ));
tc_ac.start;
alt {
[] ipPort.receive(mw_echoReply_noExtHdr_data (
p_llaAddrTn,
p_llaAddrNut,
p_identifier,
p_seqNo,
echoRequest.ipv6Payload.echoRequestMsg.data)) {
tc_ac.stop;
v_ret := e_success;
}
[] tc_ac.timeout{
return e_timeout;
}
} // end alt
return v_ret ;
} // end f_replyToEchoRequest_DS
* @desc This sends an ICMPv6 echo request from an IPv6 node to any
* NUT, and does not a reply wihtin a given time limit.
* This function can be used to verify that the NUT is NOT
* up and running.
* @remark Time limit is defined by module parameter PX_TNOAC (see comp type)
* @param p_llaAddrTn Local link address of testing node which calls this function
* @param p_llaAddrNut Local link address of node under test
* @return execution status
function f_echoProcDown( template Ipv6Address p_llaAddrTn, template Ipv6Address p_llaAddrNut)
// var EchoReply v_echoReply;
// if ( f_echoProcUp( p_llaAddrTn, p_llaAddrNut, c_defId, c_defSeqNo, v_echoReply) == e_timeout ) {
// // that means no echo reply was received - this is what we want here
// return e_success;
// } else {
// return e_error;
// }
var EchoReply v_echoRep;
var FncRetCode v_ret;
v_ret := f_sendEchoRequest( m_echoRequest_noExtHdr_noData( p_llaAddrTn,
p_llaAddrNut,
c_defId,
c_defSeqNo ));
if ( v_ret != e_success ) {return v_ret;}
tc_noAc.start;
alt {
[] ipPort.receive(mw_echoReply ( p_llaAddrNut,
p_llaAddrTn )) -> value v_echoRep {
return e_error;
}
[] tc_noAc.timeout{
return e_success;
}
} // end alt
* @desc This sends an ICMPv6 echo request from an IPv6 node to
* any NUT. Prior it modifies IPv6 packet payload length
* and ICMPv6 checksum to their correct values using external
* functions.
* @remark The template passed in must NOT contain any matching expressions!
* @param p_echoRequest Ipv6 packet value or template with echo request to be sent
* @param p_payloadLength Length of the IPv6 payload to be sent
* @return execution status
*/
function f_sendEchoRequest_noCalcPayloadLength (in template EchoRequest p_echoRequest,
UInt16 p_payloadLength )
runs on LibIpv6Node
return FncRetCode {
tepelmann
committed
var EchoRequest v_ipPkt;
v_ipPkt.ipv6Hdr.payloadLength := p_payloadLength;
if(f_setExtensionHeaders( v_ipPkt ) != e_success) {
log(" **** f_sendEchoRequest_noCalcPayloadLength: Error when calculating length of extension headers ****");
return e_error;
}
* @desc This sends an ICMPv6 echo request from an IPv6 node to
* any NUT. Prior it modifies IPv6 packet payload length
* and ICMPv6 checksum to their correct values using external
* functions. Waits for a Parameter Problem message.
* @param p_echoRequest Ipv6 packet value or template with echo request to be sent (must not contains wildcards)
* @param p_parameterProblem Parameter Problem message we are waiting for.
* @return execution status
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
*/
function f_getParameterProblemAfterEchoReq_ignoreEchoReply (
in template EchoRequest p_echoRequest,
in template ParameterProblem p_parameterProblem )
runs on LibIpv6Node
return FncRetCode {
var FncRetCode v_ret;
var boolean v_ppReceived := false;
v_ret := f_sendEchoRequest ( p_echoRequest );
if ( v_ret != e_success ) {
return v_ret;
}
tc_ac.start;
alt {
[] ipPort.receive ( p_parameterProblem ) {
v_ppReceived := true;
repeat;
}
[] ipPort.receive ( ParameterProblem:? ) {
log("**** f_getParameterProblemAfterEchoReq_ignoreEchoReply: ERROR: Template mismatch **** ");
v_ret := e_error;
}
[] ipPort.receive(mw_echoReply ( p_echoRequest.ipv6Hdr.destinationAddress,
p_echoRequest.ipv6Hdr.sourceAddress ) ) {
tc_ac.stop;
log("**** f_getParameterProblemAfterEchoReq_ignoreEchoReply: ERROR: An Echo Reply was received, HUT did not discard our Echo Request **** ");
v_ret := e_error;
}
[v_ppReceived==false] tc_ac.timeout{
v_ret := e_timeout;
}
[v_ppReceived==true] tc_ac.timeout{
v_ret := e_success;
}
} // end alt
return v_ret;
}//end f_getParameterProblemAfterEchoReq_ignoreEchoReply
* @desc This sends an ICMPv6 echo request from an IPv6 node to any
* NUT, and waits for a echo reply for a fixed amount of time.
* This function can be used to verify that the NUT is
* up and running. Neighbor detection is handled here, rather than in
* a default. Might be useful if NUT must perform neighbor detection.
* @remark Time limit is defined by module parameter PX_TAC (see comp type)
* @param p_llaAddrTn Local link address of testing node which calls this function
* @param p_llaAddrNut Local link address of node under test
* @return execution status
in template Ipv6Address p_llaAddrTn,
in template Ipv6Address p_llaAddrNut)
runs on LibIpv6Node return FncRetCode {
var FncRetCode v_ret;
v_ret := f_sendEchoRequest (
m_echoRequest_noExtHdr_data_hop (
p_llaAddrTn,
p_llaAddrNut,
c_hopLimit255,
c_defId,
c_defSeqNo,
c_1280ZeroBytes ) );
[] ipPort.receive (
mw_echoReply_noExtHdr_data_hop (
p_llaAddrNut,
p_llaAddrTn,
c_hopLimit255,
c_1280ZeroBytes ) ) {
tc_ac.stop;
return e_success;
}
[] tc_ac.timeout{
return e_timeout;
}
} // end alt
} // End If
return v_ret;
} // End function f_echoProcUp_withHopL255Len1280
/*
* @desc This sends other ICMPv6 packet from an IPv6 node to
* any IUT. Prior it modifies IPv6 packet payload length
* and ICMPv6 checksum to their correct values using external
* functions.
* @remark The template passed in must NOT contain any matching expressions!
* @param p_otherIcmpv6 Ipv6 packet value or template with the ICMPv6 packet to be sent
* @return execution status
function f_sendOtherIcmpv6 (in template OtherIcmpv6 p_otherIcmpv6)
tepelmann
committed
var OtherIcmpv6 v_ipPkt;
if(f_setExtensionHeaders( v_ipPkt ) != e_success) {
log(" **** f_sendOtherIcmpv6: Error when calculating length of extension headers ****");
return e_error;
}
return e_success;
} // end f_sendOtherIcmpv6
/*
* @desc This sends an ICMPv6 Destination Unreachable message to
* any IUT. Prior it modifies IPv6 packet payload length
* and ICMPv6 checksum to their correct values using external
* functions.
* @remark The template passed in must NOT contain any matching expressions!
* @param p_destUnreachable Ipv6 packet value or template with the Destination
* Unreachable message to be sent
* @return execution status
*/
function f_sendDestUnreachable (in template DestinationUnreachable p_destUnreachable )
runs on LibIpv6Node
return FncRetCode {
tepelmann
committed
var DestinationUnreachable v_ipPkt;
if(f_setExtensionHeaders( v_ipPkt ) != e_success) {
log(" **** f_sendDestUnreachable: Error when calculating length of extension headers ****");
return e_error;
}
return e_success;
} // end f_sendDestUnreachable
/*
* @desc This sends an ICMPv6 Packet Too Big message to
* any IUT. Prior it modifies IPv6 packet payload length
* and ICMPv6 checksum to their correct values using external
* functions.
* @remark The template passed in must NOT contain any matching expressions!
* @param p_packetTooBig Ipv6 packet value or template with the Packet
* Too Big message to be sent
* @return execution status
*/
function f_sendPacketTooBig (in template PacketTooBig p_packetTooBig )
runs on LibIpv6Node
return FncRetCode {
tepelmann
committed
var PacketTooBig v_ipPkt;
if(f_setExtensionHeaders( v_ipPkt ) != e_success) {
log(" **** f_sendPacketTooBig: Error when calculating length of extension headers ****");
return e_error;
}
return e_success;
} // end f_sendPacketTooBig
/*
* @desc This sends an ICMPv6 Packet Too Big message to
* any IUT. Prior it modifies IPv6 packet payload length
* and ICMPv6 checksum to their correct values using external
* functions.
* @remark The template passed in must NOT contain any matching expressions!
* @param p_timeExceeded Ipv6 packet value or template with the Time
* Exceeded message to be sent
* @return execution status
*/
function f_sendTimeExceeded (in template TimeExceeded p_timeExceeded )
runs on LibIpv6Node
return FncRetCode {
tepelmann
committed
var TimeExceeded v_ipPkt;
if(f_setExtensionHeaders( v_ipPkt ) != e_success) {
log(" **** f_sendTimeExceeded: Error when calculating length of extension headers ****");
return e_error;
}
return e_success;
} // end f_sendTimeExceeded
/*
* @desc This sends an ICMPv6 Packet Too Big message to
* any IUT. Prior it modifies IPv6 packet payload length
* and ICMPv6 checksum to their correct values using external
* functions.
* @remark The template passed in must NOT contain any matching expressions!
* @param p_parameterProblem Ipv6 packet value or template with the Parameter
* Problem message to be sent
* @return execution status
*/
function f_sendParameterProblem (in template ParameterProblem p_parameterProblem )
runs on LibIpv6Node
return FncRetCode {
tepelmann
committed
var ParameterProblem v_ipPkt;
if(f_setExtensionHeaders( v_ipPkt ) != e_success) {
log(" **** f_sendParameterProblem: Error when calculating length of extension headers ****");
return e_error;
}
return e_success;
} // end f_sendParameterProblem
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
/*
* @desc This sends an ICMPv6 echo request from an IPv6 node to any
* NUT, and waits for a echo reply for a fixed amount of time.
* This function can be used to verify that the NUT is
* up and running.
* @remark Time limit is defined by module parameter PX_TAC (see comp type)
* @param p_glaA Global address of tunnel entry point ( testing node 1)
* @param p_glaB Global address of tunnel exit point (IUT)
* @param p_glaC Src Global address of tunneled packet ( MN Home Address)
* @param p_glaD Dst Global address of tunneled packet ( testing node 2)
* @param p_identifier Idenitifier to be used in ICMPv6 echo request
* @param p_seqNo Sequence number to be used in ICMPv6 echo request
* @param p_icmpPkt IPv6 packet which has been received
* @return execution status
*/
function f_echoProc_tunneled( in template Ipv6Address p_glaA,
in template Ipv6Address p_glaB,
in template Ipv6Address p_glaC,
in template Ipv6Address p_glaD,
in UInt16 p_identifier,
in UInt16 p_seqNo,
out EchoReply p_icmpPkt)
runs on LibIpv6Node
return FncRetCode {
var EchoReply v_echoRep;
var FncRetCode v_ret;
v_ret := f_sendEchoRequest(
m_echoRequest_extHdr_data (
c_tunneledIpHdr,
m_extHdrList_1Elem (
m_extHdr_tunneledHeader (
c_icmpHdr,
p_glaC,
p_glaD)),
p_glaA,
p_glaB,
c_defId,
c_defSeqNo,
c_8ZeroBytes ));
if ( v_ret != e_success ) {return v_ret;}
tc_ac.start;
alt {
[] ipPort.receive(mw_echoReply_extHdr_data (
p_glaB,
p_glaA,
c_tunneledIpHdr,
m_extHdrList_1Elem (
mw_extHdr_tunneledHeader (
c_icmpHdr,
p_glaD,
p_glaC )),
c_defId,
c_defSeqNo,
c_8ZeroBytes)) -> value v_echoRep {
p_icmpPkt := v_echoRep ;
tc_ac.stop;
return e_success;
}
[] tc_ac.timeout{
return e_timeout;
}
} // end alt
} // end f_echoProc_tunneled