Hello Kevin,
I find helpful Section 10.5 of the RFC (Receiving Hello Packets).
First, a received Hello packet must pass some basic sanity checks.
"At this point, an attempt is made to match the source of the
Hello Packet to one of the receiving interface's neighbors."...
"The interface's current list of neighbors is contained in the interface's data structure.
If a matching neighbor structure cannot be found,
(i.e., this is the first time the neighbor has been detected), one is created.
The initial state of a newly created neighbor is set to Down."...
"Now the rest of the Hello Packet is examined, generating events
to be given to the neighbor and interface state machines.
These state machines are specified either to be executed or scheduled (see Section 4.4).
For example, by specifying below that the neighbor state machine be executed in line,
several neighbor state transitions may be effected by a single received Hello:
o Each Hello Packet causes the neighbor state machine to be executed
with the event HelloReceived.
o Then the list of neighbors contained in the Hello Packet is examined.
If the router itself appears in this list, the neighbor state machine should be executed
with the event 2-WayReceived.
Otherwise, the neighbor state machine should be executed with the event
1-WayReceived, and the processing of the packet stops."
The points above I find most important are:
"several neighbor state transitions may be effected by a single received Hello"
"Each Hello Packet causes the neighbor state machine to be executed
with the event HelloReceived."
Note that the last means that next state is Init (page 90 of the RFC).
And after the RFC theory (which I do find very useful),
a few implementation-oriented points (stolen from Moy):
When a neighbor is first allocated, it's initial state is set to Down.
The usual reason for allocating a neighbor structure is that
a Hello packet is received from the neighbor,
in which case the neighbor state immediately transitions to Init.
When Hellos cease to be heard from a neighbor or
the neighbor is otherwise found to be inoperative,
the neighbor transitions back to the Down state and
storage associated with the neighbor is returned to the heap.
The other reason for allocating a neighbor is when a neighbor is statically configured.
In the case of statically configured neighbors, lack of received Hellos
causes the neighbor to fall back to Down without freeing the configured neighbors.
As I see it, initializing newly discovered dynamic neighbors to the Down state
(because of a received Hello) is rather temporary (state is destined to transition to Init),
while those dynamic neighbors who "really" fall into the Down state are destroyed.
I suppose it makes sense starting with Down, so as to keep a unified approach
on which the initial state of the neighbor state machine is,
regardless of the neighbors' type (dynamic/static).
Have fun,
Maria
