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_ExternalFunctions all;
import from LibIpv6_Interface all ;
import from LibIpv6_ModuleParameters all ;
import from LibIpv6_Interface { type Ipv6Packet };
import from LibIpv6_Rfc2460Root_TypesAndValues { type all };
import from LibIpv6_Rfc2460Root_Templates all;
import from LibIpv6_Rfc2463Icmpv6_Templates all;
import from LibIpv6_Rfc2463Icmpv6_TypesAndValues all;
import from LibIpv6_Rfc2461NeighborDiscovery_TypesAndValues all;
import from LibIpv6_Rfc2461NeighborDiscovery_Templates all;
import from LibIpv6_MultiRfcs_TypesAndValues all;
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
group sendCalculation {
/*
** @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
** @returns execution status
*/
function f_sendEchoRequest (in template EchoRequest p_echoRequest)
runs on LibIpv6Node
return FncRetCode {
var Ipv6Packet v_ipPkt;
v_ipPkt.echoRequest := valueof(p_echoRequest);
//calc payloadLen
v_ipPkt.echoRequest.ipv6Hdr.payloadLength := fx_payloadLength (v_ipPkt);
//set checksum to zero
v_ipPkt.echoRequest.checksum := c_2ZeroBytes;
//calc checksum
v_ipPkt.echoRequest.checksum := fx_icmpv6Checksum(v_ipPkt);
//send
ipPort.send(v_ipPkt.echoRequest);
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
** @returns execution status
*/
function f_sendEchoReply (in template EchoReply p_echoReply)
runs on LibIpv6Node
return FncRetCode {
var Ipv6Packet v_ipPkt;
v_ipPkt.echoReply := valueof(p_echoReply);
//calc payloadLen
v_ipPkt.echoReply.ipv6Hdr.payloadLength := fx_payloadLength (v_ipPkt);
//set checksum to zero
v_ipPkt.echoReply.checksum := c_2ZeroBytes;
//calc checksum
v_ipPkt.echoReply.checksum := fx_icmpv6Checksum(v_ipPkt);
//send
ipPort.send(v_ipPkt.echoReply);
return e_success;
} // end group sendCalculation
/*
** @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
*/
function f_getIpPktAfterEchoReq( in UInt8 p_hops,
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_hop_noExtHdr_noData( p_hops,
p_llaAddrTn,
p_llaAddrNut,
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_hop_noExtHdr_noData( p_hops,
p_llaAddrTn,
p_llaAddrNut,
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;
}
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
/*
** @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
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
/*
** @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,
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
272
273
274
275
276
277
278
279
280
281
282
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,
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
in UInt16 p_identifier,
in UInt16 p_seqNo )
runs on LibIpv6Node
return FncRetCode {
var FncRetCode v_ret := e_error;
tc_ac.start;
alt {
[] ipPort.receive(mw_echoRequest ( p_llaAddrNut,
p_llaAddrTn )) {
tc_ac.stop;
v_ret := e_success;
}
[] tc_ac.timeout{
return e_timeout;
}
} // end alt
v_ret := f_sendEchoReply( m_echoReply_noExtHdr_noData( p_llaAddrTn,
p_llaAddrNut,
p_identifier,
p_seqNo ));
return v_ret ;
} // end f_replyToEchoRequest
/*
** @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_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
*/
function f_echoProcDown( template Ipv6Address p_llaAddrTn, template Ipv6Address p_llaAddrNut)
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
runs on LibIpv6Node
return FncRetCode {
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;
}
}//end f_echoProcDown
/*
** @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 packet to be sent
** @returns execution status
*/
function f_sendEchoRequest_noCalcPayloadLength (in template EchoRequest p_echoRequest,
UInt16 p_payloadLength )
runs on LibIpv6Node
return FncRetCode {
var Ipv6Packet v_ipPkt;
v_ipPkt.echoRequest := valueof(p_echoRequest);
//set payload length
v_ipPkt.echoRequest.ipv6Hdr.payloadLength := p_payloadLength;
//set checksum to zero
v_ipPkt.echoRequest.checksum := c_2ZeroBytes;
//calc checksum
v_ipPkt.echoRequest.checksum := fx_icmpv6Checksum(v_ipPkt);
//send
ipPort.send(v_ipPkt.echoRequest);
return e_success;
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
/*
** @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.
** @returns execution status
*/
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 Creates a prefix using p_address and p_prefixLength. The p_prefixLength
** MSB bits remain unchanged, the others are set to zero.
** @param p_address Address used for prefix creation
** @param p_prefixLength Length of the prefix
*/
function f_createPrefix ( template Ipv6Address p_address, template UInt8 p_prefixLength )
runs on LibIpv6Node
return Ipv6Address {
var Bit128 v_prefix;
var integer v_pos;
for ( v_pos := 128 - valueof ( p_prefixLength ); v_pos < 128; v_pos := v_pos + 1 ) {
v_prefix[v_pos] := '0'B;
}
return bit2oct ( v_prefix );
} // end f_createPrefix
/*
** @desc Creates a prefix using p_address. The length of the prefix is fixed
** in 64. The first 64 bits remain unchanged, the others are set to zero.
** @param p_address Address used for prefix creation
*/
runs on LibIpv6Node
return Ipv6Address {
var Bit128 v_prefix;
var integer v_pos;
for ( v_pos := 64; v_pos < 128; v_pos := v_pos + 1 ) {
v_prefix[v_pos] := '0'B;
}
return bit2oct ( v_prefix );
} // end f_createPrefix
/*
** @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
*/
function f_echoProcUp_withHopL255Len1280(
in template Ipv6Address p_llaAddrTn,
in template Ipv6Address p_llaAddrNut)
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
runs on LibIpv6Node return FncRetCode {
var FncRetCode v_ret;
v_ret := f_sendEchoRequest( m_echoRequest_noExtHdr_dataHopL255( p_llaAddrTn,
p_llaAddrNut,
c_defId, c_defSeqNo,
c_1280ZeroBytes));
if ( v_ret == e_success ) {
tc_ac.start;
alt {
[] ipPort.receive(mw_echoReply_hopL255_data ( p_llaAddrNut,
p_llaAddrTn ,
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
** @returns execution status
*/
function f_sendOtherIcmpv6 (in template OtherIcmpv6Hdr p_otherIcmpv6)
runs on LibIpv6Node
return FncRetCode {
var Ipv6Packet v_ipPkt;
v_ipPkt.otherHeader := valueof(p_otherIcmpv6);
//calc payloadLen
v_ipPkt.otherHeader.ipv6Hdr.payloadLength := fx_payloadLength (v_ipPkt);
//set checksum to zero
v_ipPkt.otherHeader.checksum := c_2ZeroBytes;
//calc checksum
v_ipPkt.otherHeader.checksum := fx_icmpv6Checksum(v_ipPkt);
//send
ipPort.send(v_ipPkt.otherHeader);
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
** @returns execution status
*/
function f_sendDestUnreachable (in template DestinationUnreachable p_destUnreachable )
runs on LibIpv6Node
return FncRetCode {
var Ipv6Packet v_ipPkt;
v_ipPkt.destinationUnreachable := valueof(p_destUnreachable);
//calc payloadLen
v_ipPkt.destinationUnreachable.ipv6Hdr.payloadLength := fx_payloadLength (v_ipPkt);
//set checksum to zero
v_ipPkt.destinationUnreachable.checksum := c_2ZeroBytes;
//calc checksum
v_ipPkt.destinationUnreachable.checksum := fx_icmpv6Checksum(v_ipPkt);
//send
ipPort.send(v_ipPkt.destinationUnreachable);
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
** @returns execution status
*/
function f_sendPacketTooBig (in template PacketTooBig p_packetTooBig )
runs on LibIpv6Node
return FncRetCode {
var Ipv6Packet v_ipPkt;
v_ipPkt.packetTooBig := valueof(p_packetTooBig);
//calc payloadLen
v_ipPkt.packetTooBig.ipv6Hdr.payloadLength := fx_payloadLength (v_ipPkt);
//set checksum to zero
v_ipPkt.packetTooBig.checksum := c_2ZeroBytes;
//calc checksum
v_ipPkt.packetTooBig.checksum := fx_icmpv6Checksum(v_ipPkt);
//send
ipPort.send(v_ipPkt.packetTooBig);
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
** @returns execution status
*/
function f_sendTimeExceeded (in template TimeExceeded p_timeExceeded )
runs on LibIpv6Node
return FncRetCode {
var Ipv6Packet v_ipPkt;
v_ipPkt.timeExceeded := valueof(p_timeExceeded);
//calc payloadLen
v_ipPkt.timeExceeded.ipv6Hdr.payloadLength := fx_payloadLength (v_ipPkt);
//set checksum to zero
v_ipPkt.timeExceeded.checksum := c_2ZeroBytes;
//calc checksum
v_ipPkt.timeExceeded.checksum := fx_icmpv6Checksum(v_ipPkt);
//send
ipPort.send(v_ipPkt.timeExceeded);
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
** @returns execution status
*/
function f_sendParameterProblem (in template ParameterProblem p_parameterProblem )
runs on LibIpv6Node
return FncRetCode {
var Ipv6Packet v_ipPkt;
v_ipPkt.parameterProblem := valueof(p_parameterProblem);
//calc payloadLen
v_ipPkt.parameterProblem.ipv6Hdr.payloadLength := fx_payloadLength (v_ipPkt);
//set checksum to zero
v_ipPkt.parameterProblem.checksum := c_2ZeroBytes;
//calc checksum
v_ipPkt.parameterProblem.checksum := fx_icmpv6Checksum(v_ipPkt);
//send
ipPort.send(v_ipPkt.parameterProblem);
return e_success;
} // end f_sendParameterProblem