Annotation of embedaddon/quagga/lib/zclient.c, revision 1.1.1.1
1.1 misho 1: /* Zebra's client library.
2: * Copyright (C) 1999 Kunihiro Ishiguro
3: * Copyright (C) 2005 Andrew J. Schorr
4: *
5: * This file is part of GNU Zebra.
6: *
7: * GNU Zebra is free software; you can redistribute it and/or modify
8: * it under the terms of the GNU General Public License as published
9: * by the Free Software Foundation; either version 2, or (at your
10: * option) any later version.
11: *
12: * GNU Zebra is distributed in the hope that it will be useful, but
13: * WITHOUT ANY WARRANTY; without even the implied warranty of
14: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15: * General Public License for more details.
16: *
17: * You should have received a copy of the GNU General Public License
18: * along with GNU Zebra; see the file COPYING. If not, write to the
19: * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
20: * MA 02111-1307, USA.
21: */
22:
23: #include <zebra.h>
24:
25: #include "prefix.h"
26: #include "stream.h"
27: #include "buffer.h"
28: #include "network.h"
29: #include "if.h"
30: #include "log.h"
31: #include "thread.h"
32: #include "zclient.h"
33: #include "memory.h"
34: #include "table.h"
35:
36: /* Zebra client events. */
37: enum event {ZCLIENT_SCHEDULE, ZCLIENT_READ, ZCLIENT_CONNECT};
38:
39: /* Prototype for event manager. */
40: static void zclient_event (enum event, struct zclient *);
41:
42: extern struct thread_master *master;
43:
44: /* This file local debug flag. */
45: int zclient_debug = 0;
46:
47: /* Allocate zclient structure. */
48: struct zclient *
49: zclient_new ()
50: {
51: struct zclient *zclient;
52: zclient = XCALLOC (MTYPE_ZCLIENT, sizeof (struct zclient));
53:
54: zclient->ibuf = stream_new (ZEBRA_MAX_PACKET_SIZ);
55: zclient->obuf = stream_new (ZEBRA_MAX_PACKET_SIZ);
56: zclient->wb = buffer_new(0);
57:
58: return zclient;
59: }
60:
61: /* This function is only called when exiting, because
62: many parts of the code do not check for I/O errors, so they could
63: reference an invalid pointer if the structure was ever freed.
64:
65: Free zclient structure. */
66: void
67: zclient_free (struct zclient *zclient)
68: {
69: if (zclient->ibuf)
70: stream_free(zclient->ibuf);
71: if (zclient->obuf)
72: stream_free(zclient->obuf);
73: if (zclient->wb)
74: buffer_free(zclient->wb);
75:
76: XFREE (MTYPE_ZCLIENT, zclient);
77: }
78:
79: /* Initialize zebra client. Argument redist_default is unwanted
80: redistribute route type. */
81: void
82: zclient_init (struct zclient *zclient, int redist_default)
83: {
84: int i;
85:
86: /* Enable zebra client connection by default. */
87: zclient->enable = 1;
88:
89: /* Set -1 to the default socket value. */
90: zclient->sock = -1;
91:
92: /* Clear redistribution flags. */
93: for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
94: zclient->redist[i] = 0;
95:
96: /* Set unwanted redistribute route. bgpd does not need BGP route
97: redistribution. */
98: zclient->redist_default = redist_default;
99: zclient->redist[redist_default] = 1;
100:
101: /* Set default-information redistribute to zero. */
102: zclient->default_information = 0;
103:
104: /* Schedule first zclient connection. */
105: if (zclient_debug)
106: zlog_debug ("zclient start scheduled");
107:
108: zclient_event (ZCLIENT_SCHEDULE, zclient);
109: }
110:
111: /* Stop zebra client services. */
112: void
113: zclient_stop (struct zclient *zclient)
114: {
115: if (zclient_debug)
116: zlog_debug ("zclient stopped");
117:
118: /* Stop threads. */
119: THREAD_OFF(zclient->t_read);
120: THREAD_OFF(zclient->t_connect);
121: THREAD_OFF(zclient->t_write);
122:
123: /* Reset streams. */
124: stream_reset(zclient->ibuf);
125: stream_reset(zclient->obuf);
126:
127: /* Empty the write buffer. */
128: buffer_reset(zclient->wb);
129:
130: /* Close socket. */
131: if (zclient->sock >= 0)
132: {
133: close (zclient->sock);
134: zclient->sock = -1;
135: }
136: zclient->fail = 0;
137: }
138:
139: void
140: zclient_reset (struct zclient *zclient)
141: {
142: zclient_stop (zclient);
143: zclient_init (zclient, zclient->redist_default);
144: }
145:
146: /* Make socket to zebra daemon. Return zebra socket. */
147: int
148: zclient_socket(void)
149: {
150: int sock;
151: int ret;
152: struct sockaddr_in serv;
153:
154: /* We should think about IPv6 connection. */
155: sock = socket (AF_INET, SOCK_STREAM, 0);
156: if (sock < 0)
157: return -1;
158:
159: /* Make server socket. */
160: memset (&serv, 0, sizeof (struct sockaddr_in));
161: serv.sin_family = AF_INET;
162: serv.sin_port = htons (ZEBRA_PORT);
163: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
164: serv.sin_len = sizeof (struct sockaddr_in);
165: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
166: serv.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
167:
168: /* Connect to zebra. */
169: ret = connect (sock, (struct sockaddr *) &serv, sizeof (serv));
170: if (ret < 0)
171: {
172: close (sock);
173: return -1;
174: }
175: return sock;
176: }
177:
178: /* For sockaddr_un. */
179: #include <sys/un.h>
180:
181: int
182: zclient_socket_un (const char *path)
183: {
184: int ret;
185: int sock, len;
186: struct sockaddr_un addr;
187:
188: sock = socket (AF_UNIX, SOCK_STREAM, 0);
189: if (sock < 0)
190: return -1;
191:
192: /* Make server socket. */
193: memset (&addr, 0, sizeof (struct sockaddr_un));
194: addr.sun_family = AF_UNIX;
195: strncpy (addr.sun_path, path, strlen (path));
196: #ifdef HAVE_STRUCT_SOCKADDR_UN_SUN_LEN
197: len = addr.sun_len = SUN_LEN(&addr);
198: #else
199: len = sizeof (addr.sun_family) + strlen (addr.sun_path);
200: #endif /* HAVE_STRUCT_SOCKADDR_UN_SUN_LEN */
201:
202: ret = connect (sock, (struct sockaddr *) &addr, len);
203: if (ret < 0)
204: {
205: close (sock);
206: return -1;
207: }
208: return sock;
209: }
210:
211: static int
212: zclient_failed(struct zclient *zclient)
213: {
214: zclient->fail++;
215: zclient_stop(zclient);
216: zclient_event(ZCLIENT_CONNECT, zclient);
217: return -1;
218: }
219:
220: static int
221: zclient_flush_data(struct thread *thread)
222: {
223: struct zclient *zclient = THREAD_ARG(thread);
224:
225: zclient->t_write = NULL;
226: if (zclient->sock < 0)
227: return -1;
228: switch (buffer_flush_available(zclient->wb, zclient->sock))
229: {
230: case BUFFER_ERROR:
231: zlog_warn("%s: buffer_flush_available failed on zclient fd %d, closing",
232: __func__, zclient->sock);
233: return zclient_failed(zclient);
234: break;
235: case BUFFER_PENDING:
236: zclient->t_write = thread_add_write(master, zclient_flush_data,
237: zclient, zclient->sock);
238: break;
239: case BUFFER_EMPTY:
240: break;
241: }
242: return 0;
243: }
244:
245: int
246: zclient_send_message(struct zclient *zclient)
247: {
248: if (zclient->sock < 0)
249: return -1;
250: switch (buffer_write(zclient->wb, zclient->sock, STREAM_DATA(zclient->obuf),
251: stream_get_endp(zclient->obuf)))
252: {
253: case BUFFER_ERROR:
254: zlog_warn("%s: buffer_write failed to zclient fd %d, closing",
255: __func__, zclient->sock);
256: return zclient_failed(zclient);
257: break;
258: case BUFFER_EMPTY:
259: THREAD_OFF(zclient->t_write);
260: break;
261: case BUFFER_PENDING:
262: THREAD_WRITE_ON(master, zclient->t_write,
263: zclient_flush_data, zclient, zclient->sock);
264: break;
265: }
266: return 0;
267: }
268:
269: void
270: zclient_create_header (struct stream *s, uint16_t command)
271: {
272: /* length placeholder, caller can update */
273: stream_putw (s, ZEBRA_HEADER_SIZE);
274: stream_putc (s, ZEBRA_HEADER_MARKER);
275: stream_putc (s, ZSERV_VERSION);
276: stream_putw (s, command);
277: }
278:
279: /* Send simple Zebra message. */
280: static int
281: zebra_message_send (struct zclient *zclient, int command)
282: {
283: struct stream *s;
284:
285: /* Get zclient output buffer. */
286: s = zclient->obuf;
287: stream_reset (s);
288:
289: /* Send very simple command only Zebra message. */
290: zclient_create_header (s, command);
291:
292: return zclient_send_message(zclient);
293: }
294:
295: /* Make connection to zebra daemon. */
296: int
297: zclient_start (struct zclient *zclient)
298: {
299: int i;
300:
301: if (zclient_debug)
302: zlog_debug ("zclient_start is called");
303:
304: /* zclient is disabled. */
305: if (! zclient->enable)
306: return 0;
307:
308: /* If already connected to the zebra. */
309: if (zclient->sock >= 0)
310: return 0;
311:
312: /* Check connect thread. */
313: if (zclient->t_connect)
314: return 0;
315:
316: /* Make socket. */
317: #ifdef HAVE_TCP_ZEBRA
318: zclient->sock = zclient_socket ();
319: #else
320: zclient->sock = zclient_socket_un (ZEBRA_SERV_PATH);
321: #endif /* HAVE_TCP_ZEBRA */
322: if (zclient->sock < 0)
323: {
324: if (zclient_debug)
325: zlog_debug ("zclient connection fail");
326: zclient->fail++;
327: zclient_event (ZCLIENT_CONNECT, zclient);
328: return -1;
329: }
330:
331: if (set_nonblocking(zclient->sock) < 0)
332: zlog_warn("%s: set_nonblocking(%d) failed", __func__, zclient->sock);
333:
334: /* Clear fail count. */
335: zclient->fail = 0;
336: if (zclient_debug)
337: zlog_debug ("zclient connect success with socket [%d]", zclient->sock);
338:
339: /* Create read thread. */
340: zclient_event (ZCLIENT_READ, zclient);
341:
342: /* We need router-id information. */
343: zebra_message_send (zclient, ZEBRA_ROUTER_ID_ADD);
344:
345: /* We need interface information. */
346: zebra_message_send (zclient, ZEBRA_INTERFACE_ADD);
347:
348: /* Flush all redistribute request. */
349: for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
350: if (i != zclient->redist_default && zclient->redist[i])
351: zebra_redistribute_send (ZEBRA_REDISTRIBUTE_ADD, zclient, i);
352:
353: /* If default information is needed. */
354: if (zclient->default_information)
355: zebra_message_send (zclient, ZEBRA_REDISTRIBUTE_DEFAULT_ADD);
356:
357: return 0;
358: }
359:
360: /* This function is a wrapper function for calling zclient_start from
361: timer or event thread. */
362: static int
363: zclient_connect (struct thread *t)
364: {
365: struct zclient *zclient;
366:
367: zclient = THREAD_ARG (t);
368: zclient->t_connect = NULL;
369:
370: if (zclient_debug)
371: zlog_debug ("zclient_connect is called");
372:
373: return zclient_start (zclient);
374: }
375:
376: /*
377: * "xdr_encode"-like interface that allows daemon (client) to send
378: * a message to zebra server for a route that needs to be
379: * added/deleted to the kernel. Info about the route is specified
380: * by the caller in a struct zapi_ipv4. zapi_ipv4_read() then writes
381: * the info down the zclient socket using the stream_* functions.
382: *
383: * The corresponding read ("xdr_decode") function on the server
384: * side is zread_ipv4_add()/zread_ipv4_delete().
385: *
386: * 0 1 2 3 4 5 6 7 8 9 A B C D E F 0 1 2 3 4 5 6 7 8 9 A B C D E F
387: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
388: * | Length (2) | Command | Route Type |
389: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
390: * | ZEBRA Flags | Message Flags | Prefix length |
391: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
392: * | Destination IPv4 Prefix for route |
393: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
394: * | Nexthop count |
395: * +-+-+-+-+-+-+-+-+
396: *
397: *
398: * A number of IPv4 nexthop(s) or nexthop interface index(es) are then
399: * described, as per the Nexthop count. Each nexthop described as:
400: *
401: * +-+-+-+-+-+-+-+-+
402: * | Nexthop Type | Set to one of ZEBRA_NEXTHOP_*
403: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
404: * | IPv4 Nexthop address or Interface Index number |
405: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
406: *
407: * Alternatively, if the flags field has ZEBRA_FLAG_BLACKHOLE or
408: * ZEBRA_FLAG_REJECT is set then Nexthop count is set to 1, then _no_
409: * nexthop information is provided, and the message describes a prefix
410: * to blackhole or reject route.
411: *
412: * If ZAPI_MESSAGE_DISTANCE is set, the distance value is written as a 1
413: * byte value.
414: *
415: * If ZAPI_MESSAGE_METRIC is set, the metric value is written as an 8
416: * byte value.
417: *
418: * XXX: No attention paid to alignment.
419: */
420: int
421: zapi_ipv4_route (u_char cmd, struct zclient *zclient, struct prefix_ipv4 *p,
422: struct zapi_ipv4 *api)
423: {
424: int i;
425: int psize;
426: struct stream *s;
427:
428: /* Reset stream. */
429: s = zclient->obuf;
430: stream_reset (s);
431:
432: zclient_create_header (s, cmd);
433:
434: /* Put type and nexthop. */
435: stream_putc (s, api->type);
436: stream_putc (s, api->flags);
437: stream_putc (s, api->message);
438:
439: /* Put prefix information. */
440: psize = PSIZE (p->prefixlen);
441: stream_putc (s, p->prefixlen);
442: stream_write (s, (u_char *) & p->prefix, psize);
443:
444: /* Nexthop, ifindex, distance and metric information. */
445: if (CHECK_FLAG (api->message, ZAPI_MESSAGE_NEXTHOP))
446: {
447: if (CHECK_FLAG (api->flags, ZEBRA_FLAG_BLACKHOLE))
448: {
449: stream_putc (s, 1);
450: stream_putc (s, ZEBRA_NEXTHOP_BLACKHOLE);
451: /* XXX assert(api->nexthop_num == 0); */
452: /* XXX assert(api->ifindex_num == 0); */
453: }
454: else
455: stream_putc (s, api->nexthop_num + api->ifindex_num);
456:
457: for (i = 0; i < api->nexthop_num; i++)
458: {
459: stream_putc (s, ZEBRA_NEXTHOP_IPV4);
460: stream_put_in_addr (s, api->nexthop[i]);
461: }
462: for (i = 0; i < api->ifindex_num; i++)
463: {
464: stream_putc (s, ZEBRA_NEXTHOP_IFINDEX);
465: stream_putl (s, api->ifindex[i]);
466: }
467: }
468:
469: if (CHECK_FLAG (api->message, ZAPI_MESSAGE_DISTANCE))
470: stream_putc (s, api->distance);
471: if (CHECK_FLAG (api->message, ZAPI_MESSAGE_METRIC))
472: stream_putl (s, api->metric);
473:
474: /* Put length at the first point of the stream. */
475: stream_putw_at (s, 0, stream_get_endp (s));
476:
477: return zclient_send_message(zclient);
478: }
479:
480: #ifdef HAVE_IPV6
481: int
482: zapi_ipv6_route (u_char cmd, struct zclient *zclient, struct prefix_ipv6 *p,
483: struct zapi_ipv6 *api)
484: {
485: int i;
486: int psize;
487: struct stream *s;
488:
489: /* Reset stream. */
490: s = zclient->obuf;
491: stream_reset (s);
492:
493: zclient_create_header (s, cmd);
494:
495: /* Put type and nexthop. */
496: stream_putc (s, api->type);
497: stream_putc (s, api->flags);
498: stream_putc (s, api->message);
499:
500: /* Put prefix information. */
501: psize = PSIZE (p->prefixlen);
502: stream_putc (s, p->prefixlen);
503: stream_write (s, (u_char *)&p->prefix, psize);
504:
505: /* Nexthop, ifindex, distance and metric information. */
506: if (CHECK_FLAG (api->message, ZAPI_MESSAGE_NEXTHOP))
507: {
508: stream_putc (s, api->nexthop_num + api->ifindex_num);
509:
510: for (i = 0; i < api->nexthop_num; i++)
511: {
512: stream_putc (s, ZEBRA_NEXTHOP_IPV6);
513: stream_write (s, (u_char *)api->nexthop[i], 16);
514: }
515: for (i = 0; i < api->ifindex_num; i++)
516: {
517: stream_putc (s, ZEBRA_NEXTHOP_IFINDEX);
518: stream_putl (s, api->ifindex[i]);
519: }
520: }
521:
522: if (CHECK_FLAG (api->message, ZAPI_MESSAGE_DISTANCE))
523: stream_putc (s, api->distance);
524: if (CHECK_FLAG (api->message, ZAPI_MESSAGE_METRIC))
525: stream_putl (s, api->metric);
526:
527: /* Put length at the first point of the stream. */
528: stream_putw_at (s, 0, stream_get_endp (s));
529:
530: return zclient_send_message(zclient);
531: }
532: #endif /* HAVE_IPV6 */
533:
534: /*
535: * send a ZEBRA_REDISTRIBUTE_ADD or ZEBRA_REDISTRIBUTE_DELETE
536: * for the route type (ZEBRA_ROUTE_KERNEL etc.). The zebra server will
537: * then set/unset redist[type] in the client handle (a struct zserv) for the
538: * sending client
539: */
540: int
541: zebra_redistribute_send (int command, struct zclient *zclient, int type)
542: {
543: struct stream *s;
544:
545: s = zclient->obuf;
546: stream_reset(s);
547:
548: zclient_create_header (s, command);
549: stream_putc (s, type);
550:
551: stream_putw_at (s, 0, stream_get_endp (s));
552:
553: return zclient_send_message(zclient);
554: }
555:
556: /* Router-id update from zebra daemon. */
557: void
558: zebra_router_id_update_read (struct stream *s, struct prefix *rid)
559: {
560: int plen;
561:
562: /* Fetch interface address. */
563: rid->family = stream_getc (s);
564:
565: plen = prefix_blen (rid);
566: stream_get (&rid->u.prefix, s, plen);
567: rid->prefixlen = stream_getc (s);
568: }
569:
570: /* Interface addition from zebra daemon. */
571: /*
572: * The format of the message sent with type ZEBRA_INTERFACE_ADD or
573: * ZEBRA_INTERFACE_DELETE from zebra to the client is:
574: * 0 1 2 3
575: * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
576: * +-+-+-+-+-+-+-+-+
577: * | type |
578: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
579: * | ifname |
580: * | |
581: * | |
582: * | |
583: * | |
584: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
585: * | ifindex |
586: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
587: * | if_flags |
588: * | |
589: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
590: * | metric |
591: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
592: * | ifmtu |
593: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
594: * | ifmtu6 |
595: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
596: * | bandwidth |
597: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
598: * | sockaddr_dl |
599: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
600: */
601:
602: struct interface *
603: zebra_interface_add_read (struct stream *s)
604: {
605: struct interface *ifp;
606: char ifname_tmp[INTERFACE_NAMSIZ];
607:
608: /* Read interface name. */
609: stream_get (ifname_tmp, s, INTERFACE_NAMSIZ);
610:
611: /* Lookup/create interface by name. */
612: ifp = if_get_by_name_len (ifname_tmp, strnlen(ifname_tmp, INTERFACE_NAMSIZ));
613:
614: /* Read interface's index. */
615: ifp->ifindex = stream_getl (s);
616:
617: /* Read interface's value. */
618: ifp->status = stream_getc (s);
619: ifp->flags = stream_getq (s);
620: ifp->metric = stream_getl (s);
621: ifp->mtu = stream_getl (s);
622: ifp->mtu6 = stream_getl (s);
623: ifp->bandwidth = stream_getl (s);
624: #ifdef HAVE_STRUCT_SOCKADDR_DL
625: stream_get (&ifp->sdl, s, sizeof (ifp->sdl));
626: #else
627: ifp->hw_addr_len = stream_getl (s);
628: if (ifp->hw_addr_len)
629: stream_get (ifp->hw_addr, s, ifp->hw_addr_len);
630: #endif /* HAVE_STRUCT_SOCKADDR_DL */
631:
632: return ifp;
633: }
634:
635: /*
636: * Read interface up/down msg (ZEBRA_INTERFACE_UP/ZEBRA_INTERFACE_DOWN)
637: * from zebra server. The format of this message is the same as
638: * that sent for ZEBRA_INTERFACE_ADD/ZEBRA_INTERFACE_DELETE (see
639: * comments for zebra_interface_add_read), except that no sockaddr_dl
640: * is sent at the tail of the message.
641: */
642: struct interface *
643: zebra_interface_state_read (struct stream *s)
644: {
645: struct interface *ifp;
646: char ifname_tmp[INTERFACE_NAMSIZ];
647:
648: /* Read interface name. */
649: stream_get (ifname_tmp, s, INTERFACE_NAMSIZ);
650:
651: /* Lookup this by interface index. */
652: ifp = if_lookup_by_name_len (ifname_tmp,
653: strnlen(ifname_tmp, INTERFACE_NAMSIZ));
654:
655: /* If such interface does not exist, indicate an error */
656: if (! ifp)
657: return NULL;
658:
659: /* Read interface's index. */
660: ifp->ifindex = stream_getl (s);
661:
662: /* Read interface's value. */
663: ifp->status = stream_getc (s);
664: ifp->flags = stream_getq (s);
665: ifp->metric = stream_getl (s);
666: ifp->mtu = stream_getl (s);
667: ifp->mtu6 = stream_getl (s);
668: ifp->bandwidth = stream_getl (s);
669:
670: return ifp;
671: }
672:
673: /*
674: * format of message for address additon is:
675: * 0
676: * 0 1 2 3 4 5 6 7
677: * +-+-+-+-+-+-+-+-+
678: * | type | ZEBRA_INTERFACE_ADDRESS_ADD or
679: * +-+-+-+-+-+-+-+-+ ZEBRA_INTERFACE_ADDRES_DELETE
680: * | |
681: * + +
682: * | ifindex |
683: * + +
684: * | |
685: * + +
686: * | |
687: * +-+-+-+-+-+-+-+-+
688: * | ifc_flags | flags for connected address
689: * +-+-+-+-+-+-+-+-+
690: * | addr_family |
691: * +-+-+-+-+-+-+-+-+
692: * | addr... |
693: * : :
694: * | |
695: * +-+-+-+-+-+-+-+-+
696: * | addr_len | len of addr. E.g., addr_len = 4 for ipv4 addrs.
697: * +-+-+-+-+-+-+-+-+
698: * | daddr.. |
699: * : :
700: * | |
701: * +-+-+-+-+-+-+-+-+
702: *
703: */
704:
705: void
706: zebra_interface_if_set_value (struct stream *s, struct interface *ifp)
707: {
708: /* Read interface's index. */
709: ifp->ifindex = stream_getl (s);
710: ifp->status = stream_getc (s);
711:
712: /* Read interface's value. */
713: ifp->flags = stream_getq (s);
714: ifp->metric = stream_getl (s);
715: ifp->mtu = stream_getl (s);
716: ifp->mtu6 = stream_getl (s);
717: ifp->bandwidth = stream_getl (s);
718: }
719:
720: static int
721: memconstant(const void *s, int c, size_t n)
722: {
723: const u_char *p = s;
724:
725: while (n-- > 0)
726: if (*p++ != c)
727: return 0;
728: return 1;
729: }
730:
731: struct connected *
732: zebra_interface_address_read (int type, struct stream *s)
733: {
734: unsigned int ifindex;
735: struct interface *ifp;
736: struct connected *ifc;
737: struct prefix p, d;
738: int family;
739: int plen;
740: u_char ifc_flags;
741:
742: memset (&p, 0, sizeof(p));
743: memset (&d, 0, sizeof(d));
744:
745: /* Get interface index. */
746: ifindex = stream_getl (s);
747:
748: /* Lookup index. */
749: ifp = if_lookup_by_index (ifindex);
750: if (ifp == NULL)
751: {
752: zlog_warn ("zebra_interface_address_read(%s): "
753: "Can't find interface by ifindex: %d ",
754: (type == ZEBRA_INTERFACE_ADDRESS_ADD? "ADD" : "DELETE"),
755: ifindex);
756: return NULL;
757: }
758:
759: /* Fetch flag. */
760: ifc_flags = stream_getc (s);
761:
762: /* Fetch interface address. */
763: family = p.family = stream_getc (s);
764:
765: plen = prefix_blen (&p);
766: stream_get (&p.u.prefix, s, plen);
767: p.prefixlen = stream_getc (s);
768:
769: /* Fetch destination address. */
770: stream_get (&d.u.prefix, s, plen);
771: d.family = family;
772:
773: if (type == ZEBRA_INTERFACE_ADDRESS_ADD)
774: {
775: /* N.B. NULL destination pointers are encoded as all zeroes */
776: ifc = connected_add_by_prefix(ifp, &p,(memconstant(&d.u.prefix,0,plen) ?
777: NULL : &d));
778: if (ifc != NULL)
779: {
780: ifc->flags = ifc_flags;
781: if (ifc->destination)
782: ifc->destination->prefixlen = ifc->address->prefixlen;
783: }
784: }
785: else
786: {
787: assert (type == ZEBRA_INTERFACE_ADDRESS_DELETE);
788: ifc = connected_delete_by_prefix(ifp, &p);
789: }
790:
791: return ifc;
792: }
793:
794:
795: /* Zebra client message read function. */
796: static int
797: zclient_read (struct thread *thread)
798: {
799: int ret;
800: size_t already;
801: uint16_t length, command;
802: uint8_t marker, version;
803: struct zclient *zclient;
804:
805: /* Get socket to zebra. */
806: zclient = THREAD_ARG (thread);
807: zclient->t_read = NULL;
808:
809: /* Read zebra header (if we don't have it already). */
810: if ((already = stream_get_endp(zclient->ibuf)) < ZEBRA_HEADER_SIZE)
811: {
812: ssize_t nbyte;
813: if (((nbyte = stream_read_try(zclient->ibuf, zclient->sock,
814: ZEBRA_HEADER_SIZE-already)) == 0) ||
815: (nbyte == -1))
816: {
817: if (zclient_debug)
818: zlog_debug ("zclient connection closed socket [%d].", zclient->sock);
819: return zclient_failed(zclient);
820: }
821: if (nbyte != (ssize_t)(ZEBRA_HEADER_SIZE-already))
822: {
823: /* Try again later. */
824: zclient_event (ZCLIENT_READ, zclient);
825: return 0;
826: }
827: already = ZEBRA_HEADER_SIZE;
828: }
829:
830: /* Reset to read from the beginning of the incoming packet. */
831: stream_set_getp(zclient->ibuf, 0);
832:
833: /* Fetch header values. */
834: length = stream_getw (zclient->ibuf);
835: marker = stream_getc (zclient->ibuf);
836: version = stream_getc (zclient->ibuf);
837: command = stream_getw (zclient->ibuf);
838:
839: if (marker != ZEBRA_HEADER_MARKER || version != ZSERV_VERSION)
840: {
841: zlog_err("%s: socket %d version mismatch, marker %d, version %d",
842: __func__, zclient->sock, marker, version);
843: return zclient_failed(zclient);
844: }
845:
846: if (length < ZEBRA_HEADER_SIZE)
847: {
848: zlog_err("%s: socket %d message length %u is less than %d ",
849: __func__, zclient->sock, length, ZEBRA_HEADER_SIZE);
850: return zclient_failed(zclient);
851: }
852:
853: /* Length check. */
854: if (length > STREAM_SIZE(zclient->ibuf))
855: {
856: struct stream *ns;
857: zlog_warn("%s: message size %u exceeds buffer size %lu, expanding...",
858: __func__, length, (u_long)STREAM_SIZE(zclient->ibuf));
859: ns = stream_new(length);
860: stream_copy(ns, zclient->ibuf);
861: stream_free (zclient->ibuf);
862: zclient->ibuf = ns;
863: }
864:
865: /* Read rest of zebra packet. */
866: if (already < length)
867: {
868: ssize_t nbyte;
869: if (((nbyte = stream_read_try(zclient->ibuf, zclient->sock,
870: length-already)) == 0) ||
871: (nbyte == -1))
872: {
873: if (zclient_debug)
874: zlog_debug("zclient connection closed socket [%d].", zclient->sock);
875: return zclient_failed(zclient);
876: }
877: if (nbyte != (ssize_t)(length-already))
878: {
879: /* Try again later. */
880: zclient_event (ZCLIENT_READ, zclient);
881: return 0;
882: }
883: }
884:
885: length -= ZEBRA_HEADER_SIZE;
886:
887: if (zclient_debug)
888: zlog_debug("zclient 0x%p command 0x%x \n", zclient, command);
889:
890: switch (command)
891: {
892: case ZEBRA_ROUTER_ID_UPDATE:
893: if (zclient->router_id_update)
894: ret = (*zclient->router_id_update) (command, zclient, length);
895: break;
896: case ZEBRA_INTERFACE_ADD:
897: if (zclient->interface_add)
898: ret = (*zclient->interface_add) (command, zclient, length);
899: break;
900: case ZEBRA_INTERFACE_DELETE:
901: if (zclient->interface_delete)
902: ret = (*zclient->interface_delete) (command, zclient, length);
903: break;
904: case ZEBRA_INTERFACE_ADDRESS_ADD:
905: if (zclient->interface_address_add)
906: ret = (*zclient->interface_address_add) (command, zclient, length);
907: break;
908: case ZEBRA_INTERFACE_ADDRESS_DELETE:
909: if (zclient->interface_address_delete)
910: ret = (*zclient->interface_address_delete) (command, zclient, length);
911: break;
912: case ZEBRA_INTERFACE_UP:
913: if (zclient->interface_up)
914: ret = (*zclient->interface_up) (command, zclient, length);
915: break;
916: case ZEBRA_INTERFACE_DOWN:
917: if (zclient->interface_down)
918: ret = (*zclient->interface_down) (command, zclient, length);
919: break;
920: case ZEBRA_IPV4_ROUTE_ADD:
921: if (zclient->ipv4_route_add)
922: ret = (*zclient->ipv4_route_add) (command, zclient, length);
923: break;
924: case ZEBRA_IPV4_ROUTE_DELETE:
925: if (zclient->ipv4_route_delete)
926: ret = (*zclient->ipv4_route_delete) (command, zclient, length);
927: break;
928: case ZEBRA_IPV6_ROUTE_ADD:
929: if (zclient->ipv6_route_add)
930: ret = (*zclient->ipv6_route_add) (command, zclient, length);
931: break;
932: case ZEBRA_IPV6_ROUTE_DELETE:
933: if (zclient->ipv6_route_delete)
934: ret = (*zclient->ipv6_route_delete) (command, zclient, length);
935: break;
936: default:
937: break;
938: }
939:
940: if (zclient->sock < 0)
941: /* Connection was closed during packet processing. */
942: return -1;
943:
944: /* Register read thread. */
945: stream_reset(zclient->ibuf);
946: zclient_event (ZCLIENT_READ, zclient);
947:
948: return 0;
949: }
950:
951: void
952: zclient_redistribute (int command, struct zclient *zclient, int type)
953: {
954:
955: if (command == ZEBRA_REDISTRIBUTE_ADD)
956: {
957: if (zclient->redist[type])
958: return;
959: zclient->redist[type] = 1;
960: }
961: else
962: {
963: if (!zclient->redist[type])
964: return;
965: zclient->redist[type] = 0;
966: }
967:
968: if (zclient->sock > 0)
969: zebra_redistribute_send (command, zclient, type);
970: }
971:
972:
973: void
974: zclient_redistribute_default (int command, struct zclient *zclient)
975: {
976:
977: if (command == ZEBRA_REDISTRIBUTE_DEFAULT_ADD)
978: {
979: if (zclient->default_information)
980: return;
981: zclient->default_information = 1;
982: }
983: else
984: {
985: if (!zclient->default_information)
986: return;
987: zclient->default_information = 0;
988: }
989:
990: if (zclient->sock > 0)
991: zebra_message_send (zclient, command);
992: }
993:
994: static void
995: zclient_event (enum event event, struct zclient *zclient)
996: {
997: switch (event)
998: {
999: case ZCLIENT_SCHEDULE:
1000: if (! zclient->t_connect)
1001: zclient->t_connect =
1002: thread_add_event (master, zclient_connect, zclient, 0);
1003: break;
1004: case ZCLIENT_CONNECT:
1005: if (zclient->fail >= 10)
1006: return;
1007: if (zclient_debug)
1008: zlog_debug ("zclient connect schedule interval is %d",
1009: zclient->fail < 3 ? 10 : 60);
1010: if (! zclient->t_connect)
1011: zclient->t_connect =
1012: thread_add_timer (master, zclient_connect, zclient,
1013: zclient->fail < 3 ? 10 : 60);
1014: break;
1015: case ZCLIENT_READ:
1016: zclient->t_read =
1017: thread_add_read (master, zclient_read, zclient, zclient->sock);
1018: break;
1019: }
1020: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to zclient.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / lib