3 Copyright (C) 2008 Everton da Silva Marques
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; see the file COPYING; if not, write to the
17 Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
20 $QuaggaId: $Format:%an, %ai, %h$ $
24 #include "zebra/rib.h"
36 #include "pim_zlookup.h"
38 extern int zclient_debug
;
40 static void zclient_lookup_sched(struct zclient
*zlookup
, int delay
);
42 /* Connect to zebra for nexthop lookup. */
43 static int zclient_lookup_connect(struct thread
*t
)
45 struct zclient
*zlookup
;
47 zlookup
= THREAD_ARG(t
);
48 zlookup
->t_connect
= NULL
;
50 if (zlookup
->sock
>= 0) {
54 if (zclient_socket_connect(zlookup
) < 0) {
56 zlog_warn("%s: failure connecting zclient socket: failures=%d",
57 __PRETTY_FUNCTION__
, zlookup
->fail
);
60 zlookup
->fail
= 0; /* reset counter on connection */
63 zassert(!zlookup
->t_connect
);
64 if (zlookup
->sock
< 0) {
65 /* Since last connect failed, retry within 10 secs */
66 zclient_lookup_sched(zlookup
, 10);
73 /* Schedule connection with delay. */
74 static void zclient_lookup_sched(struct zclient
*zlookup
, int delay
)
76 zassert(!zlookup
->t_connect
);
78 THREAD_TIMER_ON(master
, zlookup
->t_connect
,
79 zclient_lookup_connect
,
82 zlog_notice("%s: zclient lookup connection scheduled for %d seconds",
83 __PRETTY_FUNCTION__
, delay
);
86 /* Schedule connection for now. */
87 static void zclient_lookup_sched_now(struct zclient
*zlookup
)
89 zassert(!zlookup
->t_connect
);
91 zlookup
->t_connect
= thread_add_event(master
, zclient_lookup_connect
,
94 zlog_notice("%s: zclient lookup immediate connection scheduled",
98 /* Schedule reconnection, if needed. */
99 static void zclient_lookup_reconnect(struct zclient
*zlookup
)
101 if (zlookup
->t_connect
) {
105 zclient_lookup_sched_now(zlookup
);
108 static void zclient_lookup_failed(struct zclient
*zlookup
)
110 if (zlookup
->sock
>= 0) {
111 if (close(zlookup
->sock
)) {
112 zlog_warn("%s: closing fd=%d: errno=%d %s", __func__
, zlookup
->sock
,
113 errno
, safe_strerror(errno
));
118 zclient_lookup_reconnect(zlookup
);
121 struct zclient
*zclient_lookup_new()
123 struct zclient
*zlookup
;
125 zlookup
= zclient_new (master
);
127 zlog_err("%s: zclient_new() failure",
128 __PRETTY_FUNCTION__
);
133 zlookup
->ibuf
= stream_new(ZEBRA_MAX_PACKET_SIZ
);
134 zlookup
->obuf
= stream_new(ZEBRA_MAX_PACKET_SIZ
);
135 zlookup
->t_connect
= 0;
137 zclient_lookup_sched_now(zlookup
);
139 zlog_notice("%s: zclient lookup socket initialized",
140 __PRETTY_FUNCTION__
);
145 static int zclient_read_nexthop(struct zclient
*zlookup
,
146 struct pim_zlookup_nexthop nexthop_tab
[],
152 const uint16_t MIN_LEN
= 10; /* getipv4=4 getc=1 getl=4 getc=1 */
157 uint16_t command
= 0;
158 struct in_addr raddr
;
164 if (PIM_DEBUG_ZEBRA
) {
166 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
167 zlog_debug("%s: addr=%s",
174 while (command
!= ZEBRA_IPV4_NEXTHOP_LOOKUP_MRIB
)
177 err
= zclient_read_header (s
, zlookup
->sock
, &length
, &marker
, &version
,
180 zlog_err("%s %s: zclient_read_header() failed",
181 __FILE__
, __PRETTY_FUNCTION__
);
182 zclient_lookup_failed(zlookup
);
186 if (length
< MIN_LEN
) {
187 zlog_err("%s %s: failure reading zclient lookup socket: len=%d < MIN_LEN=%d",
188 __FILE__
, __PRETTY_FUNCTION__
, length
, MIN_LEN
);
189 zclient_lookup_failed(zlookup
);
193 if (version
!= ZSERV_VERSION
|| marker
!= ZEBRA_HEADER_MARKER
) {
194 zlog_err("%s: socket %d version mismatch, marker %d, version %d",
195 __func__
, zlookup
->sock
, marker
, version
);
196 zclient_lookup_failed(zlookup
);
201 raddr
.s_addr
= stream_get_ipv4(s
);
203 if (raddr
.s_addr
!= addr
.s_addr
) {
206 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
207 pim_inet4_dump("<raddr?>", raddr
, raddr_str
, sizeof(raddr_str
));
208 zlog_warn("%s: address mismatch: addr=%s raddr=%s",
210 addr_str
, raddr_str
);
214 distance
= stream_getc(s
);
215 metric
= stream_getl(s
);
216 nexthop_num
= stream_getc(s
);
218 if (nexthop_num
< 1) {
219 zlog_err("%s: socket %d bad nexthop_num=%d",
220 __func__
, zlookup
->sock
, nexthop_num
);
226 for (i
= 0; i
< nexthop_num
; ++i
) {
227 enum nexthop_types_t nexthop_type
;
230 zlog_err("%s: socket %d empty input expecting nexthop_type: len=%d",
231 __func__
, zlookup
->sock
, length
);
235 nexthop_type
= stream_getc(s
);
238 switch (nexthop_type
) {
239 case ZEBRA_NEXTHOP_IFINDEX
:
240 case ZEBRA_NEXTHOP_IPV4_IFINDEX
:
241 if (num_ifindex
>= tab_size
) {
243 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
244 zlog_warn("%s %s: found too many nexthop ifindexes (%d > %d) for address %s",
245 __FILE__
, __PRETTY_FUNCTION__
,
246 (num_ifindex
+ 1), tab_size
, addr_str
);
249 if (nexthop_type
== ZEBRA_NEXTHOP_IPV4_IFINDEX
) {
251 zlog_err("%s: socket %d short input expecting nexthop IPv4-addr: len=%d",
252 __func__
, zlookup
->sock
, length
);
255 nexthop_tab
[num_ifindex
].nexthop_addr
.s_addr
= stream_get_ipv4(s
);
259 nexthop_tab
[num_ifindex
].nexthop_addr
.s_addr
= PIM_NET_INADDR_ANY
;
261 nexthop_tab
[num_ifindex
].ifindex
= stream_getl(s
);
262 nexthop_tab
[num_ifindex
].protocol_distance
= distance
;
263 nexthop_tab
[num_ifindex
].route_metric
= metric
;
266 case ZEBRA_NEXTHOP_IPV4
:
267 if (num_ifindex
>= tab_size
) {
269 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
270 zlog_warn("%s %s: found too many nexthop ifindexes (%d > %d) for address %s",
271 __FILE__
, __PRETTY_FUNCTION__
,
272 (num_ifindex
+ 1), tab_size
, addr_str
);
275 nexthop_tab
[num_ifindex
].nexthop_addr
.s_addr
= stream_get_ipv4(s
);
277 nexthop_tab
[num_ifindex
].ifindex
= 0;
278 nexthop_tab
[num_ifindex
].protocol_distance
= distance
;
279 nexthop_tab
[num_ifindex
].route_metric
= metric
;
280 if (PIM_DEBUG_ZEBRA
) {
282 char nexthop_str
[100];
283 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
284 pim_inet4_dump("<nexthop?>", nexthop_tab
[num_ifindex
].nexthop_addr
, nexthop_str
, sizeof(nexthop_str
));
285 zlog_debug("%s %s: zebra returned recursive nexthop %s for address %s",
286 __FILE__
, __PRETTY_FUNCTION__
,
287 nexthop_str
, addr_str
);
295 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
296 zlog_warn("%s %s: found non-ifindex nexthop type=%d for address %s",
297 __FILE__
, __PRETTY_FUNCTION__
,
298 nexthop_type
, addr_str
);
307 static int zclient_lookup_nexthop_once(struct zclient
*zlookup
,
308 struct pim_zlookup_nexthop nexthop_tab
[],
315 if (PIM_DEBUG_ZEBRA
) {
317 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
318 zlog_debug("%s: addr=%s",
324 if (zlookup
->sock
< 0) {
325 zlog_err("%s %s: zclient lookup socket is not connected",
326 __FILE__
, __PRETTY_FUNCTION__
);
327 zclient_lookup_failed(zlookup
);
333 zclient_create_header(s
, ZEBRA_IPV4_NEXTHOP_LOOKUP_MRIB
, VRF_DEFAULT
);
334 stream_put_in_addr(s
, &addr
);
335 stream_putw_at(s
, 0, stream_get_endp(s
));
337 ret
= writen(zlookup
->sock
, s
->data
, stream_get_endp(s
));
339 zlog_err("%s %s: writen() failure writing to zclient lookup socket",
340 __FILE__
, __PRETTY_FUNCTION__
);
341 zclient_lookup_failed(zlookup
);
345 zlog_err("%s %s: connection closed on zclient lookup socket",
346 __FILE__
, __PRETTY_FUNCTION__
);
347 zclient_lookup_failed(zlookup
);
351 return zclient_read_nexthop(zlookup
, nexthop_tab
,
355 int zclient_lookup_nexthop(struct zclient
*zlookup
,
356 struct pim_zlookup_nexthop nexthop_tab
[],
362 uint32_t route_metric
= 0xFFFFFFFF;
363 uint8_t protocol_distance
= 0xFF;
365 for (lookup
= 0; lookup
< max_lookup
; ++lookup
) {
368 struct in_addr nexthop_addr
;
370 num_ifindex
= zclient_lookup_nexthop_once(qpim_zclient_lookup
, nexthop_tab
,
371 PIM_NEXTHOP_IFINDEX_TAB_SIZE
, addr
);
372 if (num_ifindex
< 1) {
373 if (PIM_DEBUG_ZEBRA
) {
375 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
376 zlog_debug("%s %s: lookup=%d/%d: could not find nexthop ifindex for address %s",
377 __FILE__
, __PRETTY_FUNCTION__
,
378 lookup
, max_lookup
, addr_str
);
384 /* this is the non-recursive lookup - save original metric/distance */
385 route_metric
= nexthop_tab
[0].route_metric
;
386 protocol_distance
= nexthop_tab
[0].protocol_distance
;
390 FIXME: Non-recursive nexthop ensured only for first ifindex.
391 However, recursive route lookup should really be fixed in zebra daemon.
394 first_ifindex
= nexthop_tab
[0].ifindex
;
395 nexthop_addr
= nexthop_tab
[0].nexthop_addr
;
396 if (first_ifindex
> 0) {
397 /* found: first ifindex is non-recursive nexthop */
400 /* Report non-recursive success after first lookup */
401 if (PIM_DEBUG_ZEBRA
) {
403 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
404 zlog_debug("%s %s: lookup=%d/%d: found non-recursive ifindex=%d for address %s dist=%d met=%d",
405 __FILE__
, __PRETTY_FUNCTION__
,
406 lookup
, max_lookup
, first_ifindex
, addr_str
,
407 nexthop_tab
[0].protocol_distance
,
408 nexthop_tab
[0].route_metric
);
411 /* use last address as nexthop address */
412 nexthop_tab
[0].nexthop_addr
= addr
;
414 /* report original route metric/distance */
415 nexthop_tab
[0].route_metric
= route_metric
;
416 nexthop_tab
[0].protocol_distance
= protocol_distance
;
422 if (PIM_DEBUG_ZEBRA
) {
424 char nexthop_str
[100];
425 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
426 pim_inet4_dump("<nexthop?>", nexthop_addr
, nexthop_str
, sizeof(nexthop_str
));
427 zlog_debug("%s %s: lookup=%d/%d: zebra returned recursive nexthop %s for address %s dist=%d met=%d",
428 __FILE__
, __PRETTY_FUNCTION__
,
429 lookup
, max_lookup
, nexthop_str
, addr_str
,
430 nexthop_tab
[0].protocol_distance
,
431 nexthop_tab
[0].route_metric
);
434 addr
= nexthop_addr
; /* use nexthop addr for recursive lookup */
436 } /* for (max_lookup) */
438 if (PIM_DEBUG_ZEBRA
) {
440 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
441 zlog_warn("%s %s: lookup=%d/%d: failure searching recursive nexthop ifindex for address %s",
442 __FILE__
, __PRETTY_FUNCTION__
,
443 lookup
, max_lookup
, addr_str
);