NAME

adrsolvQueuMulti - Verifying address resolution queues

TARGET

Host and Router

SYNOPSIS

  adrsolvQueuMulti.seq [-tooloption ...] -p adrsolvQueuMulti.def

INITIALIZATION

  Clear a neighbor cache entry for TN and X

TEST PROCEDURE

adrsolvQueuMulti verifies that a NUT queues at least one packet for an address whose LLA is not resolved.

  TN                 NUT
  ----------------------


  State: No neighbor cache entry (for TN, X)


  ==== echo-request A ===>
	src=TN's link-local
	dst=NUT's link-local


  State: INCOMPLETE (for TN), No neighbor cache entry (for X)


  ==== echo-request B ===>
	src=X's link-local
	dst=NUT's link-local


  State: INCOMPLETE (for all)


  <=== Judgment #1: multicast NS ====
	src=NUT's link-local or global
	dst=solicited-node[TN's link-local]
	w/ SLLA
	timeout: $RETRANS_TIMER * $MAX_MULTICAST_SOLICIT
  ==== solicited NA ===>
	src=TN's link-local
	dst=NUT's link-local
	R=0, S=1, O=1
	w/ TLLA


  State: REACHABLE (for TN), INCOMPLETE (for X)


  <=== Judgment #2: multicast NS ====
	src=NUT's link-local or global
	dst=solicited-node[X's link-local]
	w/ SLLA
	timeout: $RETRANS_TIMER * $MAX_MULTICAST_SOLICIT


  ==== solicited NA ===>
	src=X's link-local
	dst=NUT's link-local
	R=0, S=1, O=1
	w/ TLLA


  State: REACHABLE (for TN, X)


  <=== Judgment #3: echo-reply A ====
	src=NUT's link-local
	dst=TN's link-local


  <=== Judgment #4: echo-reply B ====
	src=NUT's link-local
	dst=X's link-local

JUDGMENT


  1. NUT must send at the least one multicast NS to TN.
     src=NUT's link-local or global, dst=solicited-node[TN's link-local], w/ SLLA

  2. NUT must send at the least one multicast NS to the X.
     src=NUT's link-local or global, dst=solicited-node[X's link-local], w/ SLLA

  3. NUT must send an echo-reply to TN.
     src=NUT's link-local, dst=TN's link-local

  4. NUT must send an echo-reply to the X.
     src=NUT's link-local, dst=X's link-local

  5. The order that the above packets (multicast NS and
     echo-reply) are captured in is not matter.

TERMINATION

N/A

NOTE

  The test does not invoke any remote command.

REFERENCE

RFC2461

7.2.2 Sending Neighbor Solicitations

   When a node has a unicast packet to send to a neighbor, but does not
   know the neighbor's link-layer address, it performs address
   resolution.  For multicast-capable interfaces this entails creating a
   Neighbor Cache entry in the INCOMPLETE state and transmitting a
   Neighbor Solicitation message targeted at the neighbor.  The
   solicitation is sent to the solicited-node multicast address
   corresponding to the target address.

   If the source address of the packet prompting the solicitation is the
   same as one of the addresses assigned to the outgoing interface, that
   address SHOULD be placed in the IP Source Address of the outgoing
   solicitation.  Otherwise, any one of the addresses assigned to the
   interface should be used.  Using the prompting packet's source
   address when possible insures that the recipient of the Neighbor
   Solicitation installs in its Neighbor Cache the IP address that is
   highly likely to be used in subsequent return traffic belonging to
   the prompting packet's "connection".

   If the solicitation is being sent to a solicited-node multicast
   address, the sender MUST include its link-layer address (if it has
   one) as a Source Link-Layer Address option.  Otherwise, the sender
   SHOULD include its link-layer address (if it has one) as a Source
   Link-Layer Address option.  Including the source link-layer address
   in a multicast solicitation is required to give the target an address
   to which it can send the Neighbor Advertisement.  On unicast
   solicitations, an implementation MAY omit the Source Link-Layer
   Address option. The assumption here is that if the sender has a
   peer's link-layer address in its cache, there is a high probability
   that the peer will also have an entry in its cache for the sender.
   Consequently, it need not be sent.

   While waiting for address resolution to complete, the sender MUST,
   for each neighbor, retain a small queue of packets waiting for
   address resolution to complete.  The queue MUST hold at least one
   packet, and MAY contain more.  However, the number of queued packets
   per neighbor SHOULD be limited to some small value.  When a queue
   overflows, the new arrival SHOULD replace the oldest entry.  Once
   address resolution completes, the node transmits any queued packets.