Route reflectors
iBGP's split-horizon rule needs a full mesh, which gets expensive as routers grow. A route reflector is a router allowed an exception: it reflects routes between iBGP peers. It sorts its peers into clients and non-clients: routes from non-clients go to clients only; routes from clients, and from eBGP peers, go to clients and non-clients. Only the reflector is configured.
By Arif, founder of Daveth · Updated
The full 11 min walkthrough is in Daveth Pro (Network). See what the plan opens
What this page answers
What is a BGP route reflector?
A router configured to advertise routes learned from an iBGP peer to other iBGP peers, an exception to the split-horizon rule, so the AS no longer needs a full mesh. A reflector and its clients form a cluster. Read it in “One router allowed an exception”
What are the route reflector rules?
A route from a non-client is advertised to clients, not to non-clients. A route from a client is advertised to clients and non-clients. A route from an eBGP peer is advertised to clients and non-clients. Read it in the lesson
Do route reflector clients need configuring?
No. Only the route reflector is configured; nothing in a client's configuration changes, and nothing in it would tell you it is a client. Read it in “Configured on one side”
The bill for a full mesh
Here's the question this lesson answers, the way you'd ask it: how do fifty iBGP routers share routes without fifty times forty-nine sessions?
Start with the bill, because the question's arithmetic is slightly off and the real number is still bad. You know why there's a bill at all. A route learned from an iBGP peer is never advertised to another iBGP peer, because iBGP doesn't prepend its AS and so can't see its own loops; it's called the BGP split-horizon rule, and it comes back near the end. That inability to pass a route on can lead to scalability issues inside an AS. The answer so far has been the full mesh: every BGP router in the AS with a session to every other.
The formula: n(n − 1)/2 sessions, where n is the number of routers. Five routers need 10 sessions; ten routers need 45.
1,225. Fifty times forty-nine is 2,450, and that's a real number too, just not of sessions: it's the number of neighbor … remote-as lines you'd type, at the least, because every session is configured at both of its ends. Either way, that's a lot of change tickets. iBGP scalability becomes an issue for large networks, and RFC 4456 says the same thing more bluntly: the full mesh requirement "clearly does not scale" with a large number of iBGP speakers.
The total isn't even the worst part. Add a fifty-first router to a full mesh and it needs a session with all fifty routers already there, so the change touches fifty-one configurations, not one. Hold that; the next section prices the same change with a reflector.
Our network has four BGP routers in AS 64500, HQ-E1, HQ-E2, HQ-C1 and HQ-C2, and the iBGP lesson put them in a full mesh: six sessions. Nothing is breaking at four. But the design for our network already names HQ-C1 as the iBGP route reflector, and this lesson is why, and how to take the mesh down without anyone losing a route.

Today: every BGP router in AS 64500 peers with every other. The dashed blue lines are iBGP sessions between loopbacks, over the cables in grey.
There are two standard ways out: route reflectors and confederations both scale iBGP without a full mesh. Confederations split the AS into sub-ASs; the exam's blueprint leaves them out, so they wait for another day. This lesson is the reflector.
One router allowed an exception
RFC 1966 introduced the idea that an iBGP peering can be configured so that it reflects routes to another iBGP peer. The router doing the reflecting is the route reflector (RR); a router that receives reflected routes is a route reflector client. Put plainly, a route reflector is a router that's configured to advertise routes learned from an iBGP peer to another iBGP peer. So the reflector is an exception to the split-horizon rule, for one router. An exception, not the rule switched off: the next section shows where the rule still holds.
It isn't a hack around the standard. BGP's own specification writes the exception into the ban: a router that gets an UPDATE from an internal peer "SHALL NOT re-distribute" it to other internal peers, "(unless the speaker acts as a BGP Route Reflector [RFC2796])". And the RFC that defines reflection draws the whole idea with three routers: A and B each peer only with C; if C is allowed to pass iBGP-learned routes on, the session between A and B isn't needed.
Now price it. One reflector in the middle of fifty routers: each of the other forty-nine needs one session, to the reflector. Forty-nine sessions instead of 1,225. And the fifty-first router? One new session, configured on two routers: itself and the reflector.
Two words before the rules. The reflector sorts its iBGP peers into clients and non-clients, and a reflector together with its clients is called a cluster. A network can have several reflectors and several clusters, and the exam's blueprint draws the line there: "Route reflector (excluding multiple route reflectors, confederations, dynamic peer)". So this lesson designs with one. (The worked example below happens to chain two, and you'll read it, because it's the clearest place to see what the attributes look like.)
From the reflector's chair
Sit at the reflector. Routes arrive from three kinds of neighbor: a client, a non-client, and an eBGP peer. For each, you decide which of your iBGP peers get it. Before the rules, a prediction.
Here are the three rules:
- Rule 1: a route from a non-client is advertised to clients. It is not advertised to non-clients.
- Rule 2: a route from a client is advertised to clients and non-clients.
- Rule 3: a route from an eBGP peer is advertised to clients and non-clients.
If you said "everyone", rule 1 is the one to look at again. A reflector doesn't switch iBGP's split-horizon rule off. A route it hears from a non-client still goes only to clients, so two non-clients that peer only with the reflector never hear each other's routes.
Why would the RFC build it that way? Because between two non-clients, the reflector behaves exactly as any iBGP router would. RFC 4456 says it in one line: "The Non-Client peer must be fully meshed but the Client peers need not be fully meshed". A route from one non-client is assumed to have reached the other non-clients already, over their own sessions, so the reflector keeps the old rule between them. The rule is lifted only where a client is involved. That's what makes a gradual migration possible, too: the RFC suggests starting by "configuring a single router as the designated RR", with the other routers left as normal iBGP peers, which works exactly because non-clients still mesh with each other.
Rule 3 is the one that isn't new. Any iBGP router sends an eBGP-learned route to all its iBGP peers; you saw it in the iBGP lesson's chain. RFC 4456 dropped eBGP from the reflection rules altogether; it's listed here so the table is complete.
One difference between descriptions. Some descriptions of rule 2 add that the client that sent the route gets a copy back, and discards it because it sees itself as the route's originator. Whether a current router sends that copy, we haven't confirmed. The two stamps below explain the discard either way.
And one thing the rules don't say out loud: for each prefix, a reflector passes on its best path, and only that. Which path is best is the next lesson's question.
Now sit in the chair. The step rule first: each step is one advertisement over one session. A router passes on only its best path. Any router sends an eBGP-learned route to all its iBGP peers, and every router sends its best path to its eBGP peers, wherever it learned it. A router that isn't a reflector never sends an iBGP-learned route to an iBGP peer. The reflector applies rules 1 to 3. And by default the figure draws no copy back to the router a route came from; the copy is a switch, off by default.

Step 1 of 10 The route enters at N1.

Step 2 of 10 N1 → RR (iBGP): sent. Normal iBGP: not iBGP-learned, so to every iBGP peer.

Step 3 of 10 RR → C1 (iBGP): sent. Rule 1: from a non-client, to a client.

Step 4 of 10 RR → C2 (iBGP): sent. Rule 1: from a non-client, to a client.

Step 5 of 10 RR → N1: not sent. The peer it came from.

Step 6 of 10 RR → N2: not sent. Rule 1: from a non-client, not to a non-client.

Step 7 of 10 RR → E (eBGP): sent. An eBGP peer gets the best path, wherever it was learned.

Step 8 of 10 C1 → RR: not sent. The peer it came from.

Step 9 of 10 C2 → RR: not sent. The peer it came from.

Step 10 of 10 E → RR: not sent. The peer it came from.
Configured on one side
Here's the part that surprises people the first time they build it. Only route reflectors are aware of the change in behaviour, because no additional BGP configuration goes on the clients. The clients aren't told. Nothing in their configuration changes, and nothing in it would tell you they're clients. RFC 4456 is just as flat about it: BGP gives a client no way to identify itself as a client, and the simplest way is manual configuration. So if you want to prove a router is a client, don't look at the router. Look at the reflector.
Two more facts about the configuration. Route reflection is specific to each address family. And the command is neighbor ip-address route-reflector-client, used under the neighbor's address family configuration: it configures the peer as a route reflector client.
The lab: four routers in a row in AS 65100, R1, R2, R3 and R4, with an iBGP session between each pair of neighbors. R1 is a route reflector client of R2, R4 is a route reflector client of R3, and R2 and R3 have a normal iBGP peering. The links are 10.12.1.0/24, 10.23.1.0/24 and 10.34.1.0/24, with 10.1.1.0/24 behind R1 and 10.4.4.0/24 behind R4. That's two reflectors, one per client; it's the clearest place to read the attributes, and you'll design with one.

The roles are set on R2 and R3, the reflectors; nothing on R1 or R4 says client. Each iBGP session runs over the link between its two routers.
R1 and R2 leave the default IPv4 address family on, and R3 and R4 turn it off. The client lines go only on R2 and R3. R1 advertises 10.1.1.0/24 with a network statement:
R1 (Default IPv4 Address-Family Enabled) router bgp 65100 network 10.1.1.0 mask 255.255.255.0 redistribute connected neighbor 10.12.1.2 remote-as 65100 R2 (Default IPv4 Address-Family Enabled) router bgp 65100 redistribute connected neighbor 10.12.1.1 remote-as 65100 neighbor 10.12.1.1 route-reflector-client neighbor 10.23.1.3 remote-as 65100 R3 (Default IPv4 Address-Family Disabled) router bgp 65100 no bgp default ipv4-unicast neighbor 10.23.1.2 remote-as 65100 neighbor 10.34.1.4 remote-as 65100 ! address-family ipv4 redistribute connected neighbor 10.23.1.2 activate neighbor 10.34.1.4 activate neighbor 10.34.1.4 route-reflector-client R4 (Default IPv4 Address-Family Disabled) router bgp 65100 no bgp default ipv4-unicast neighbor 10.34.1.3 remote-as 65100 ! address-family ipv4 neighbor 10.34.1.3 activate
Read it one router at a time. R1 is a plain iBGP speaker with one neighbor, R2, and nothing on it says "client". R2 names R1 as route-reflector-client at router bgp, where its IPv4 family is on by default, and peers normally with R3. R3 does the same for R4, inside address-family ipv4 with its activate lines, and peers normally with R2. R4 has one neighbor and an activate, and nothing else.
Notice one more line: R1, R2 and R3 all have redistribute connected. In our reading, that's the iBGP lesson's fix doing a job here: it puts the link subnets into BGP, so R3 and R4 can resolve the next hop R1's route carries through BGP routes to the links, with no IGP in the example at all. Take it out of R1 and R2 and R3 couldn't resolve that next hop. A next hop has to be resolvable before the route is valid and advertised to other BGP peers, which is the state you've seen before: "no best path" and "Not advertised to any peer". So R3 would hold the route with no best path, and R4, which only R3 could tell, wouldn't hold it at all.
Our network runs both families, so the reflector needs the client line twice, once under each family, because reflection is per address family. On HQ-C1, for its client HQ-C2, in the form we expect (not confirmed line by line on a current router; the IPv6 session has its own lesson):
! the client line, per family; expected form router bgp 64500 bgp router-id 10.255.0.1 no bgp default ipv4-unicast neighbor 10.255.0.2 remote-as 64500 neighbor 10.255.0.2 update-source Loopback0 neighbor 2001:db8:ffff::2 remote-as 64500 neighbor 2001:db8:ffff::2 update-source Loopback0 ! address-family ipv4 neighbor 10.255.0.2 activate neighbor 10.255.0.2 route-reflector-client address-family ipv6 neighbor 2001:db8:ffff::2 activate neighbor 2001:db8:ffff::2 route-reflector-client
Nothing is added on HQ-C2 to make it a client. It keeps its session to HQ-C1 from the mesh; the only change it will ever see is its other mesh sessions coming off, later.
What a reflected route looks like
Put the rules on the chain. R1 advertises 10.1.1.0/24 to R2 as a normal iBGP advertisement. R2 passes it to R3, a non-client, under rule 2, because it came from R2's client. R3 passes it to R4, a client, under rule 1, because it came from R3's non-client.
R1# show bgp ipv4 unicast | i Network|10.1.1
Network Next Hop Metric LocPrf Weight Path
*> 10.1.1.0/24 0.0.0.0 0 32768 i
R2# show bgp ipv4 unicast | i Network|10.1.1
Network Next Hop Metric LocPrf Weight Path
*>i 10.1.1.0/24 10.12.1.1 0 100 0 i
R3# show bgp ipv4 unicast | i Network|10.1.1
Network Next Hop Metric LocPrf Weight Path
*>i 10.1.1.0/24 10.12.1.1 0 100 0 i
R4# show bgp ipv4 unicast | i Network|10.1.1
Network Next Hop Metric LocPrf Weight Path
*>i 10.1.1.0/24 10.12.1.1 0 100 0 i10.12.1.1, R1's address, on all three. The next hop changes once, when the route goes into R2's table, and stays the same on R2, R3 and R4. R1 holds its own route with next hop 0.0.0.0; R2 holds it best, via 10.12.1.1; R3 and R4 hold it best, via 10.12.1.1 too. The i right after the > on R2, R3 and R4 says the prefix was learned through iBGP.
Nothing new happened to the next hop, and that's the point. The iBGP rule still holds. R1's table marks its own route with 0.0.0.0, meaning originated here, and R1 advertises it with its own address, 10.12.1.1; from then on iBGP leaves the next hop alone, and reflecting doesn't change it either. RFC 4456 makes it explicit for reflectors: when a reflector reflects a route it "SHOULD NOT modify" the NEXT_HOP, AS_PATH, LOCAL_PREF or MED. So a reflector changes who hears a route, not where the traffic goes. R4's packets for 10.1.1.0/24 head for 10.12.1.1 by whatever route R4 has to it, through R3 here only because the links happen to run that way. For that reason the RFC asks for the reflection design to be congruent with the network topology when a prefix has more than one path.
What about next-hop-self on the reflector? By default it doesn't change the next hop on iBGP prefixes; the all keyword makes it change them too. A reflected route is an iBGP-learned route, so plain next-hop-self on a reflector toward its client leaves reflected routes alone. With all it would, by the same rule, rewrite them, which is exactly what RFC 4456 says a reflector shouldn't do, and it would put the reflector in the path; what a current router does with a reflected route, we haven't confirmed. On our network it doesn't arise: HQ-E1 sets next-hop-self toward HQ-C1, so ISP-A's routes reach the reflector with HQ-E1's loopback as next hop and keep it on the way to every client.
| Row | Proves | Doesn't prove |
|---|---|---|
R1 *> 10.1.1.0/24 0.0.0.0 | R1 originated it and it's R1's best path | that anyone else has it |
R2 *>i ... 10.12.1.1 | R2 learned it over iBGP, chose it, and its next hop is R1's address | whether R2 passes it on: that depends on who R2 heard it from and who's asking (rules 1-3) |
R3, R4 *>i ... 10.12.1.1 | the same at R3 and R4 | that it was reflected, or by whom: R2's row looks identical, and R2 heard it straight from R1. The entry in the next section shows the reflections |
The two stamps
Removing the full mesh requirement from an iBGP topology introduces the potential for routing loops. A full mesh never needed a loop check inside the AS, because nobody passed anything on. A reflector does pass things on, and RFC 4456 says how a loop could start: "through misconfiguration". So when RFC 1966 was drafted, two reflector-specific attributes were added to prevent loops.
Originator. An optional non-transitive attribute, created by the first route reflector, set to the router ID of the router that injected or advertised the prefix into the AS. If it's already populated, it isn't overwritten. And if a router receives a route with its own router ID as the originator, the route is discarded.
Cluster list. A non-transitive attribute that the route reflector updates: each reflector adds its cluster ID to it, appended, not overwritten. By default the cluster ID is the reflector's BGP identifier, its router ID. If a reflector receives a route with its own cluster ID in the cluster list, the route is discarded. (RFC 4456 calls both attributes optional and non-transitive.)
One detail of "appended" changes how you read the list. RFC 1966 said a reflector appends its cluster ID; RFC 4456 says "prepend", and records that the change was made "to reflect the deployed code". So the newest reflector's ID is on the left. "Appended (not overwritten)" is right about the part that matters for the loop check, that nothing is replaced; for the order, trust the output.
Now the stamps on the chain. The step rule: each step is one advertisement over one session, under the three rules. When a reflector passes a route on, it sets the originator if there isn't one, to the router ID of the router that injected or advertised the prefix into the AS, and puts its own cluster ID at the front of the list. A receiver throws the route away if the originator is its own router ID, or, if it's a reflector, if its cluster ID is already in the list. The router IDs are R1 192.168.1.1, R2 192.168.2.2, R3 192.168.3.3 and R4 192.168.4.4: R1's and R3's as R4's entry prints them below, R2's inferred from the same entry, because a cluster ID is the router ID by default, and R4's ours.

Step 1 of 7 R1 holds 10.1.1.0/24, next hop 0.0.0.0.

Step 2 of 7 R1 → R2 (iBGP): sent. Normal iBGP: not iBGP-learned, so to every iBGP peer.

Step 3 of 7 R2 → R1: not sent. The peer it came from.

Step 4 of 7 R2 → R3 (iBGP): sent. Rule 2: from a client, to every peer.

Step 5 of 7 R3 → R2: not sent. The peer it came from.

Step 6 of 7 R3 → R4 (iBGP): sent. Rule 1: from a non-client, to a client.

Step 7 of 7 R4 → R3: not sent. The peer it came from.
R4's entry, whole:
R4# show bgp ipv4 unicast 10.1.1.0/24
! Output omitted for brevity
Paths: (1 available, best #1, table default)
Refresh Epoch 1
Local
10.12.1.1 from 10.34.1.3 (192.168.3.3)
Origin IGP, metric 0, localpref 100, valid, internal, best
Originator: 192.168.1.1, Cluster list: 192.168.3.3, 192.168.2.2The originator and cluster list are populated appropriately. Here's what "appropriately" means, line by line.
| Line | What it says | What it proves | What it doesn't |
|---|---|---|---|
Local | the AS_Path is empty | the route never left AS 65100 on its way here | anything about who originated it |
10.12.1.1 from 10.34.1.3 (192.168.3.3) | next hop 10.12.1.1, heard from 10.34.1.3, and in brackets 192.168.3.3, which we read as that speaker's router ID (it matches R3's cluster ID) | R4 heard it from R3 (10.34.1.3 is R3's address on their link), and the next hop is still R1's | that R3 originated it: in our reading, "from" is the last speaker, not the source |
valid, internal, best | learned over iBGP and chosen | R4 uses this path | that it was reflected: R2's row says the same |
Originator: 192.168.1.1 | the router ID of the router that put the route into the AS | R1 is the source, and at least one reflector handled it | which reflector set it |
Cluster list: 192.168.3.3, 192.168.2.2 | two cluster IDs, by default the reflectors' router IDs | two reflections, R3's the latest (RFC 4456's prepend) | the full path: a non-reflecting iBGP hop adds nothing to the list |
That fits the figure and RFC 4456's prepend: R2 reflected first, R3 put its ID in front.
When does either check actually fire? The originator check needs a route to come back to the router that put it in the AS. In the chain nothing goes back to R1, unless a router sends the sender its own copy, as some descriptions of rule 2 say; then R1 sees its own router ID as the originator and drops it, which is the figure's copy-back setup. The cluster list check needs a route to reach the same reflector twice, and that takes routes passing between several reflectors: the multi-reflector designs the blueprint leaves out. So on our network, with one reflector and nothing misconfigured, you'll read both attributes on every reflected route and probably never see either check fire, unless your router does send that copy back, in which case the originator check fires routinely and harmlessly. They're the safety catch, for the day someone adds a second reflector or makes a reflector another reflector's client by mistake.
One line you'll meet again: the cluster list's length is also a best-path step, late in the order, where the path with the shorter list wins. Where it sits, and what the originator ID does to the router-ID step just before it, is the next lesson's.
Draw the sessions
The split-horizon rule gets a name and a warning when you're troubleshooting. The BGP split-horizon rule says a BGP router that receives a route from an iBGP peering shall not advertise it to another router that's an iBGP peer. Commit it to memory, so you recognise when it's the reason for missing routes: it's one of the usual reasons a BGP route goes missing.
The classic case. R1, in AS 65501, has eBGP sessions to R2 and R3 in AS 65502, and advertises four /26s of 10.1.1.0/24; R5 has 10.1.5.0/24 behind it. R2 has an iBGP peering with R4, and R4 has one with R5. R2 advertises 10.1.1.0/26 to R4 over iBGP, and because R4 and R5 are iBGP peers, R4 doesn't pass it to R5.

The sessions, as you'd draw them from show bgp ipv4 unicast summary. Dashed: iBGP; solid: eBGP and the LAN.
For R5 to learn 10.1.1.0/26, it has to be an iBGP peer with the router that learned the route from an eBGP peer, or a peer with a route reflector. The first way: R2 and R3, the two routers that hear R1 over eBGP, each peer with R4 and R5 and with each other, which also optimises redundancy. Look at what's missing from that design: there's no R4–R5 session. It isn't a full mesh, and for R1's routes it doesn't need to be, because every one of them enters the AS at R2 or R3.

R2 and R3, the routers that hear R1 over eBGP, peer with everyone else in the AS.
Now the second way, and a prediction.
No. R4 heard it from R2, and R2 isn't R4's client, so this is rule 1: clients only. R6 gets it; R5, a non-client, doesn't. R5 gets it the moment R4 marks R5 as a client, or marks R2 as one (rule 2). So "a peer with a route reflector" is a sentence short: a client of the reflector, or a peer of a reflector that heard the route from a client or from eBGP.
The method works whatever the design: run show bgp ipv4 unicast summary on all the routers to find the peerings, draw them on paper, and remember the rule. With a reflector in the picture, draw one more thing on each line that ends at a reflector: C for a client, N for a non-client. Then walk the route. Every iBGP peer of the router where it enters gets it; a router that isn't a reflector stops; a reflector applies rules 1 to 3. The summary can't give you the C and N. Only the reflector's configuration can, or its neighbor detail, if a current router prints a client line there; we haven't confirmed that it does.
Before the change goes in
Our network, as the iBGP lesson left it: a full mesh of iBGP between loopbacks in both families, EIGRP 100 inside, next-hop-self on HQ-E1 toward its iBGP peers, and ISP-A's prefixes, 203.0.113.0/24 and 2001:db8:e000::/48, learned by HQ-E1 over eBGP. A change request lands for review:
Replace the iBGP full mesh in AS 64500 with HQ-C1 as the route reflector, both families. On HQ-C1, make HQ-C2 a route-reflector client. HQ-E1 and HQ-E2 are edge routers, so they stay normal iBGP peers. Then remove every iBGP session that doesn't involve HQ-C1. Requirement: every BGP router in AS 64500 keeps ISP-A's routes.
Review it the way the last section says, on paper, before anyone types. Draw the sessions after the change, with their marks, and walk 203.0.113.0/24 from where it enters.
Three sessions survive: HQ-C1 to HQ-C2 (C), HQ-C1 to HQ-E1 (N), HQ-C1 to HQ-E2 (N). The route enters at HQ-E1 over eBGP, so HQ-E1 sends it to its one iBGP peer, HQ-C1, with its own loopback, 10.255.0.11, which is also its router ID, as next hop. HQ-C1 heard it from a non-client, so rule 1: clients only. HQ-C2 gets it. HQ-E2 doesn't. The same happens to 2001:db8:e000::/48, because the change treats both families alike.

After the change, with the marks at HQ-C1's end: C for a client, N for a non-client.
So the change breaks its own requirement, and the people who approved it would never see it in a summary. On HQ-E2, show bgp ipv4 unicast summary will show a number in HQ-C1's State/PfxRcd column, not a state name: the session is up. What the number is depends on what else is in BGP, and it says nothing about ISP-A's prefixes. The missing route is visible only as an absence in HQ-E2's table.
This is the part worth remembering. One non-client behind a reflector is harmless: its routes go to every client, and every client's routes come back to it. It takes two non-clients that don't peer with each other to lose routes between them. That's the change request's mistake: two edges left as non-clients, and the session between them deleted. It assumed the reflector had switched the split-horizon rule off. Between non-clients it never does.
Two fixes, and the requirement picks:
- Make both edges clients. One line per edge per family on HQ-C1, nothing on the edges. All three of HQ-C1's peers are then clients, and every route goes to every router (rule 2).
- Keep the edges as non-clients and keep their session, HQ-E1 to HQ-E2, because non-clients must be fully meshed among themselves.
The request says to remove every session that doesn't involve HQ-C1, so the first. On HQ-C1, in the form we expect:
! expected form; HQ-C2's lines are already there address-family ipv4 neighbor 10.255.0.11 route-reflector-client neighbor 10.255.0.12 route-reflector-client address-family ipv6 neighbor 2001:db8:ffff::11 route-reflector-client neighbor 2001:db8:ffff::12 route-reflector-client
Then prove it where the route was missing, not where the configuration is. On HQ-E2, show bgp ipv4 unicast 203.0.113.0 should show one path, best, next hop 10.255.0.11, heard from 10.255.0.1, with "Originator: 10.255.0.11, Cluster list: 10.255.0.1", HQ-E1's router ID and HQ-C1's. The same for 2001:db8:e000::/48 with show bgp ipv6 unicast. And on HQ-C1, show bgp ipv4 unicast neighbors 10.255.0.12 advertised-routes should now list 203.0.113.0/24, here proving what the reflector sent.
The bad instinct comes in two forms. One is HQ-E2's summary: the session is up, with a prefix count, so "BGP is fine". It's fine at being a session. The other is reaching for next-hop-self, because the last missing routes were a next-hop problem. Here the route never arrived at all; there's no next hop to fix.
The interactive lesson
The whole lesson, with its drawings and its questions. Free with a Daveth account.























