Annotation of embedaddon/quagga/babeld/kernel.c, revision 1.1.1.1
1.1 misho 1: /*
2: * This file is free software: you may copy, redistribute and/or modify it
3: * under the terms of the GNU General Public License as published by the
4: * Free Software Foundation, either version 2 of the License, or (at your
5: * option) any later version.
6: *
7: * This file is distributed in the hope that it will be useful, but
8: * WITHOUT ANY WARRANTY; without even the implied warranty of
9: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
10: * General Public License for more details.
11: *
12: * You should have received a copy of the GNU General Public License
13: * along with this program. If not, see <http://www.gnu.org/licenses/>.
14: *
15: * This file incorporates work covered by the following copyright and
16: * permission notice:
17: *
18:
19: Copyright 2007, 2008 by Grégoire Henry, Julien Cristau and Juliusz Chroboczek
20: Copyright 2011, 2012 by Matthieu Boutier and Juliusz Chroboczek
21:
22: Permission is hereby granted, free of charge, to any person obtaining a copy
23: of this software and associated documentation files (the "Software"), to deal
24: in the Software without restriction, including without limitation the rights
25: to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
26: copies of the Software, and to permit persons to whom the Software is
27: furnished to do so, subject to the following conditions:
28:
29: The above copyright notice and this permission notice shall be included in
30: all copies or substantial portions of the Software.
31:
32: THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
33: IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
34: FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
35: AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
36: LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
37: OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
38: THE SOFTWARE.
39: */
40:
41: #include <sys/time.h>
42: #include <sys/param.h>
43: #include <time.h>
44:
45: #include "babeld.h"
46:
47:
48: #include <sys/types.h>
49: #include <sys/socket.h>
50: #include <netinet/in.h>
51: #include <netdb.h>
52: #include <arpa/inet.h>
53:
54: #include <zebra.h>
55: #include "prefix.h"
56: #include "zclient.h"
57: #include "kernel.h"
58: #include "privs.h"
59: #include "command.h"
60: #include "vty.h"
61: #include "memory.h"
62: #include "thread.h"
63:
64: #include "util.h"
65: #include "babel_interface.h"
66: #include "babel_zebra.h"
67:
68:
69: static int
70: kernel_route_v4(int add, const unsigned char *pref, unsigned short plen,
71: const unsigned char *gate, int ifindex,
72: unsigned int metric);
73: static int
74: kernel_route_v6(int add, const unsigned char *pref, unsigned short plen,
75: const unsigned char *gate, int ifindex,
76: unsigned int metric);
77:
78: int
79: kernel_interface_operational(struct interface *interface)
80: {
81: return if_is_operative(interface);
82: }
83:
84: int
85: kernel_interface_mtu(struct interface *interface)
86: {
87: return MIN(interface->mtu, interface->mtu6);
88: }
89:
90: int
91: kernel_interface_wireless(struct interface *interface)
92: {
93: return 0;
94: }
95:
96: int
97: kernel_route(int operation, const unsigned char *pref, unsigned short plen,
98: const unsigned char *gate, int ifindex, unsigned int metric,
99: const unsigned char *newgate, int newifindex,
100: unsigned int newmetric)
101: {
102: int rc;
103: int ipv4;
104:
105: /* Check that the protocol family is consistent. */
106: if(plen >= 96 && v4mapped(pref)) {
107: if(!v4mapped(gate)) {
108: errno = EINVAL;
109: return -1;
110: }
111: ipv4 = 1;
112: } else {
113: if(v4mapped(gate)) {
114: errno = EINVAL;
115: return -1;
116: }
117: ipv4 = 0;
118: }
119:
120: switch (operation) {
121: case ROUTE_ADD:
122: return ipv4 ?
123: kernel_route_v4(1, pref, plen, gate, ifindex, metric):
124: kernel_route_v6(1, pref, plen, gate, ifindex, metric);
125: break;
126: case ROUTE_FLUSH:
127: return ipv4 ?
128: kernel_route_v4(0, pref, plen, gate, ifindex, metric):
129: kernel_route_v6(0, pref, plen, gate, ifindex, metric);
130: break;
131: case ROUTE_MODIFY:
132: if(newmetric == metric && memcmp(newgate, gate, 16) == 0 &&
133: newifindex == ifindex)
134: return 0;
135: debugf(BABEL_DEBUG_ROUTE, "Modify route: delete old; add new.");
136: rc = ipv4 ?
137: kernel_route_v4(0, pref, plen, gate, ifindex, metric):
138: kernel_route_v6(0, pref, plen, gate, ifindex, metric);
139:
140: if (rc < 0)
141: return -1;
142:
143: rc = ipv4 ?
144: kernel_route_v4(1, pref, plen, newgate, newifindex, newmetric):
145: kernel_route_v6(1, pref, plen, newgate, newifindex, newmetric);
146:
147: return rc;
148: break;
149: default:
150: zlog_err("this should never appens (false value - kernel_route)");
151: assert(0);
152: exit(1);
153: break;
154: }
155: }
156:
157: static int
158: kernel_route_v4(int add,
159: const unsigned char *pref, unsigned short plen,
160: const unsigned char *gate, int ifindex, unsigned int metric)
161: {
162: struct zapi_ipv4 api; /* quagga's communication system */
163: struct prefix_ipv4 quagga_prefix; /* quagga's prefix */
164: struct in_addr babel_prefix_addr; /* babeld's prefix addr */
165: struct in_addr nexthop; /* next router to go */
166: struct in_addr *nexthop_pointer = &nexthop; /* it's an array! */
167:
168: /* convert to be understandable by quagga */
169: /* convert given addresses */
170: uchar_to_inaddr(&babel_prefix_addr, pref);
171: uchar_to_inaddr(&nexthop, gate);
172:
173: /* make prefix structure */
174: memset (&quagga_prefix, 0, sizeof(quagga_prefix));
175: quagga_prefix.family = AF_INET;
176: IPV4_ADDR_COPY (&quagga_prefix.prefix, &babel_prefix_addr);
177: quagga_prefix.prefixlen = plen - 96; /* our plen is for v4mapped's addr */
178: apply_mask_ipv4(&quagga_prefix);
179:
180: api.type = ZEBRA_ROUTE_BABEL;
181: api.flags = 0;
182: api.message = 0;
183: api.safi = SAFI_UNICAST;
184:
185: /* Unlike the native Linux and BSD interfaces, Quagga doesn't like
186: there to be both and IPv4 nexthop and an ifindex. Omit the
187: ifindex, and assume that the connected prefixes be set up
188: correctly. */
189:
190: SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
191: api.ifindex_num = 0;
192: if(metric >= KERNEL_INFINITY) {
193: api.flags = ZEBRA_FLAG_BLACKHOLE;
194: api.nexthop_num = 0;
195: } else {
196: api.nexthop_num = 1;
197: api.nexthop = &nexthop_pointer;
198: SET_FLAG(api.message, ZAPI_MESSAGE_METRIC);
199: api.metric = metric;
200: }
201:
202: debugf(BABEL_DEBUG_ROUTE, "%s route (ipv4) to zebra",
203: add ? "adding" : "removing" );
204: return zapi_ipv4_route (add ? ZEBRA_IPV4_ROUTE_ADD :
205: ZEBRA_IPV4_ROUTE_DELETE,
206: zclient, &quagga_prefix, &api);
207: }
208:
209: static int
210: kernel_route_v6(int add, const unsigned char *pref, unsigned short plen,
211: const unsigned char *gate, int ifindex, unsigned int metric)
212: {
213: unsigned int tmp_ifindex = ifindex; /* (for typing) */
214: struct zapi_ipv6 api; /* quagga's communication system */
215: struct prefix_ipv6 quagga_prefix; /* quagga's prefix */
216: struct in6_addr babel_prefix_addr; /* babeld's prefix addr */
217: struct in6_addr nexthop; /* next router to go */
218: struct in6_addr *nexthop_pointer = &nexthop;
219:
220: /* convert to be understandable by quagga */
221: /* convert given addresses */
222: uchar_to_in6addr(&babel_prefix_addr, pref);
223: uchar_to_in6addr(&nexthop, gate);
224:
225: /* make prefix structure */
226: memset (&quagga_prefix, 0, sizeof(quagga_prefix));
227: quagga_prefix.family = AF_INET6;
228: IPV6_ADDR_COPY (&quagga_prefix.prefix, &babel_prefix_addr);
229: quagga_prefix.prefixlen = plen;
230: apply_mask_ipv6(&quagga_prefix);
231:
232: api.type = ZEBRA_ROUTE_BABEL;
233: api.flags = 0;
234: api.message = 0;
235: api.safi = SAFI_UNICAST;
236: SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
237: if(metric >= KERNEL_INFINITY) {
238: api.flags = ZEBRA_FLAG_BLACKHOLE;
239: api.nexthop_num = 0;
240: api.ifindex_num = 0;
241: } else {
242: api.nexthop_num = 1;
243: api.nexthop = &nexthop_pointer;
244: SET_FLAG(api.message, ZAPI_MESSAGE_IFINDEX);
245: api.ifindex_num = 1;
246: api.ifindex = &tmp_ifindex;
247: SET_FLAG(api.message, ZAPI_MESSAGE_METRIC);
248: api.metric = metric;
249: }
250:
251: debugf(BABEL_DEBUG_ROUTE, "%s route (ipv6) to zebra",
252: add ? "adding" : "removing" );
253: return zapi_ipv6_route (add ? ZEBRA_IPV6_ROUTE_ADD :
254: ZEBRA_IPV6_ROUTE_DELETE,
255: zclient, &quagga_prefix, &api);
256: }
257:
258: int
259: if_eui64(char *ifname, int ifindex, unsigned char *eui)
260: {
261: struct interface *ifp = if_lookup_by_index(ifindex);
262: if (ifp == NULL) {
263: return -1;
264: }
265: #ifdef HAVE_STRUCT_SOCKADDR_DL
266: u_char len = ifp->sdl.sdl_alen;
267: char *tmp = ifp->sdl.sdl_data + ifp->sdl.sdl_nlen;
268: #else
269: u_char len = (u_char) ifp->hw_addr_len;
270: char *tmp = (void*) ifp->hw_addr;
271: #endif
272: if (len == 8) {
273: memcpy(eui, tmp, 8);
274: eui[0] ^= 2;
275: } else if (len == 6) {
276: memcpy(eui, tmp, 3);
277: eui[3] = 0xFF;
278: eui[4] = 0xFE;
279: memcpy(eui+5, tmp+3, 3);
280: } else {
281: return -1;
282: }
283: return 0;
284: }
285:
286: /* Like gettimeofday, but returns monotonic time. If POSIX clocks are not
287: available, falls back to gettimeofday but enforces monotonicity. */
288: int
289: gettime(struct timeval *tv)
290: {
291: return quagga_gettime(QUAGGA_CLK_MONOTONIC, tv);
292: }
293:
294: /* If /dev/urandom doesn't exist, this will fail with ENOENT, which the
295: caller will deal with gracefully. */
296:
297: int
298: read_random_bytes(void *buf, size_t len)
299: {
300: int fd;
301: int rc;
302:
303: fd = open("/dev/urandom", O_RDONLY);
304: if(fd < 0) {
305: rc = -1;
306: } else {
307: rc = read(fd, buf, len);
308: if(rc < 0 || (unsigned) rc < len)
309: rc = -1;
310: close(fd);
311: }
312: return rc;
313: }
314:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to kernel.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 / babeld