In the last post on this topic, we found the tail of the update chain. The actual event appears to be processed here—
case BGPEventUpdateMsg: st.fsm.StartHoldTimer() bgpMsg := data.(*packet.BGPMessage) st.fsm.ProcessUpdateMessage(bgpMsg)
—which is found around line 734 of fsm.go. The second line of code in this snippet is interesting; it’s a little difficult to understand what it’s actually doing. There are three crucial elements to figuring out what is going on here—
:=, in go, is a way of assigning information to a data structure. But what, precisely, is being assigned to
bgpMsg from the
* (asterisk) is a way to reference a pointer within a structure. We’ve not talked about pointers before, so it’s worth spending just a moment with them. The illustration below will help a bit.
Each letter in the string “this is a string” is stored in a single memory location (this isn’t necessarily true, but let’s assume it is for this example). Further, each memory location has a
location identifier, or rather some form of number that says, “this is memory location x.” This memory locator is, of course a number—hence the memory locator itself can be assigned to a variable, which can then be treated as a separate object from the string itself.
This memory locator is called a pointer.
It should only make sense that the locator is called a pointer, because it points to the string. The question that should pop up in your head right now is—”but wait, if each letter is stored in a different memory location, then which memory location does the pointer actually point to?” If you’re trying to describe the entire string, the pointer would normally point to the first character in the string. You can, of course, also describe just some part of the string by pointing to a memory location that’s someplace in the middle of the string. For instance, you could point to just the part of the string “is a string” by finding the memory location of the second “i” in the string, and storing its memory location.
How can you find the location of a string, or some other data structure? You place an
& (ampersand) in front of it. So, if you do this—
my-pointer = &a-string
Now I have the pointer, but how do I get back to the value from the pointer? Like this—
a-string-copy = *my-pointer
* takes the data that is pointed at by the pointer and pulls it out for assignment to another variable. In this case, then, this line of code—
bgpMsg := data.(*packet.BGPMessage)
- taking the data located at
- assigning it to the data structure
In other words, this is copying the actual packet contents out of the buffer into which they were copied by the BGP FSM when the packet was received, and into another structure where they can be processed as an update. We need to look elsewhere for the code that removes messages from this data structure—we will most likely find it when we start looking through
ProcessUpdateMessage, which is where we will start next time.