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 (c) 2007, 2008 by Juliusz Chroboczek
20:
21: Permission is hereby granted, free of charge, to any person obtaining a copy
22: of this software and associated documentation files (the "Software"), to deal
23: in the Software without restriction, including without limitation the rights
24: to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
25: copies of the Software, and to permit persons to whom the Software is
26: furnished to do so, subject to the following conditions:
27:
28: The above copyright notice and this permission notice shall be included in
29: all copies or substantial portions of the Software.
30:
31: THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
32: IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
33: FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
34: AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
35: LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
36: OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
37: THE SOFTWARE.
38: */
39:
40: #include <zebra.h>
41: #include "if.h"
42:
43: #include "babeld.h"
44: #include "util.h"
45: #include "net.h"
46: #include "babel_interface.h"
47: #include "source.h"
48: #include "neighbour.h"
49: #include "route.h"
50: #include "xroute.h"
51: #include "resend.h"
52: #include "message.h"
53: #include "kernel.h"
54:
55: unsigned char packet_header[4] = {42, 2};
56:
57: int split_horizon = 1;
58:
59: unsigned short myseqno = 0;
60: struct timeval seqno_time = {0, 0};
61:
62: #define UNICAST_BUFSIZE 1024
63: int unicast_buffered = 0;
64: unsigned char *unicast_buffer = NULL;
65: struct neighbour *unicast_neighbour = NULL;
66: struct timeval unicast_flush_timeout = {0, 0};
67:
68: static const unsigned char v4prefix[16] =
69: {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, 0, 0, 0, 0 };
70:
71: /* Parse a network prefix, encoded in the somewhat baroque compressed
72: representation used by Babel. Return the number of bytes parsed. */
73: static int
74: network_prefix(int ae, int plen, unsigned int omitted,
75: const unsigned char *p, const unsigned char *dp,
76: unsigned int len, unsigned char *p_r)
77: {
78: unsigned pb;
79: unsigned char prefix[16];
80: int ret = -1;
81:
82: if(plen >= 0)
83: pb = (plen + 7) / 8;
84: else if(ae == 1)
85: pb = 4;
86: else
87: pb = 16;
88:
89: if(pb > 16)
90: return -1;
91:
92: memset(prefix, 0, 16);
93:
94: switch(ae) {
95: case 0:
96: ret = 0;
97: break;
98: case 1:
99: if(omitted > 4 || pb > 4 || (pb > omitted && len < pb - omitted))
100: return -1;
101: memcpy(prefix, v4prefix, 12);
102: if(omitted) {
103: if (dp == NULL || !v4mapped(dp)) return -1;
104: memcpy(prefix, dp, 12 + omitted);
105: }
106: if(pb > omitted) memcpy(prefix + 12 + omitted, p, pb - omitted);
107: ret = pb - omitted;
108: break;
109: case 2:
110: if(omitted > 16 || (pb > omitted && len < pb - omitted)) return -1;
111: if(omitted) {
112: if (dp == NULL || v4mapped(dp)) return -1;
113: memcpy(prefix, dp, omitted);
114: }
115: if(pb > omitted) memcpy(prefix + omitted, p, pb - omitted);
116: ret = pb - omitted;
117: break;
118: case 3:
119: if(pb > 8 && len < pb - 8) return -1;
120: prefix[0] = 0xfe;
121: prefix[1] = 0x80;
122: if(pb > 8) memcpy(prefix + 8, p, pb - 8);
123: ret = pb - 8;
124: break;
125: default:
126: return -1;
127: }
128:
129: mask_prefix(p_r, prefix, plen < 0 ? 128 : ae == 1 ? plen + 96 : plen);
130: return ret;
131: }
132:
133: static void
134: parse_route_attributes(const unsigned char *a, int alen,
135: unsigned char *channels)
136: {
137: int type, len, i = 0;
138:
139: while(i < alen) {
140: type = a[i];
141: if(type == 0) {
142: i++;
143: continue;
144: }
145:
146: if(i + 1 > alen) {
147: fprintf(stderr, "Received truncated attributes.\n");
148: return;
149: }
150: len = a[i + 1];
151: if(i + len > alen) {
152: fprintf(stderr, "Received truncated attributes.\n");
153: return;
154: }
155:
156: if(type == 1) {
157: /* Nothing. */
158: } else if(type == 2) {
159: if(len > DIVERSITY_HOPS) {
160: fprintf(stderr,
161: "Received overlong channel information (%d > %d).\n",
162: len, DIVERSITY_HOPS);
163: len = DIVERSITY_HOPS;
164: }
165: if(memchr(a + i + 2, 0, len) != NULL) {
166: /* 0 is reserved. */
167: fprintf(stderr, "Channel information contains 0!");
168: return;
169: }
170: memset(channels, 0, DIVERSITY_HOPS);
171: memcpy(channels, a + i + 2, len);
172: } else {
173: fprintf(stderr, "Received unknown route attribute %d.\n", type);
174: }
175:
176: i += len + 2;
177: }
178: }
179:
180: static int
181: network_address(int ae, const unsigned char *a, unsigned int len,
182: unsigned char *a_r)
183: {
184: return network_prefix(ae, -1, 0, a, NULL, len, a_r);
185: }
186:
187: static int
188: channels_len(unsigned char *channels)
189: {
190: unsigned char *p = memchr(channels, 0, DIVERSITY_HOPS);
191: return p ? (p - channels) : DIVERSITY_HOPS;
192: }
193:
194: void
195: parse_packet(const unsigned char *from, struct interface *ifp,
196: const unsigned char *packet, int packetlen)
197: {
198: int i;
199: const unsigned char *message;
200: unsigned char type, len;
201: int bodylen;
202: struct neighbour *neigh;
203: int have_router_id = 0, have_v4_prefix = 0, have_v6_prefix = 0,
204: have_v4_nh = 0, have_v6_nh = 0;
205: unsigned char router_id[8], v4_prefix[16], v6_prefix[16],
206: v4_nh[16], v6_nh[16];
207:
208: if(!linklocal(from)) {
209: zlog_err("Received packet from non-local address %s.",
210: format_address(from));
211: return;
212: }
213:
214: if(packet[0] != 42) {
215: zlog_err("Received malformed packet on %s from %s.",
216: ifp->name, format_address(from));
217: return;
218: }
219:
220: if(packet[1] != 2) {
221: zlog_err("Received packet with unknown version %d on %s from %s.",
222: packet[1], ifp->name, format_address(from));
223: return;
224: }
225:
226: neigh = find_neighbour(from, ifp);
227: if(neigh == NULL) {
228: zlog_err("Couldn't allocate neighbour.");
229: return;
230: }
231:
232: DO_NTOHS(bodylen, packet + 2);
233:
234: if(bodylen + 4 > packetlen) {
235: zlog_err("Received truncated packet (%d + 4 > %d).",
236: bodylen, packetlen);
237: bodylen = packetlen - 4;
238: }
239:
240: i = 0;
241: while(i < bodylen) {
242: message = packet + 4 + i;
243: type = message[0];
244: if(type == MESSAGE_PAD1) {
245: debugf(BABEL_DEBUG_COMMON,"Received pad1 from %s on %s.",
246: format_address(from), ifp->name);
247: i++;
248: continue;
249: }
250: if(i + 1 > bodylen) {
251: zlog_err("Received truncated message.");
252: break;
253: }
254: len = message[1];
255: if(i + len > bodylen) {
256: zlog_err("Received truncated message.");
257: break;
258: }
259:
260: if(type == MESSAGE_PADN) {
261: debugf(BABEL_DEBUG_COMMON,"Received pad%d from %s on %s.",
262: len, format_address(from), ifp->name);
263: } else if(type == MESSAGE_ACK_REQ) {
264: unsigned short nonce, interval;
265: if(len < 6) goto fail;
266: DO_NTOHS(nonce, message + 4);
267: DO_NTOHS(interval, message + 6);
268: debugf(BABEL_DEBUG_COMMON,"Received ack-req (%04X %d) from %s on %s.",
269: nonce, interval, format_address(from), ifp->name);
270: send_ack(neigh, nonce, interval);
271: } else if(type == MESSAGE_ACK) {
272: debugf(BABEL_DEBUG_COMMON,"Received ack from %s on %s.",
273: format_address(from), ifp->name);
274: /* Nothing right now */
275: } else if(type == MESSAGE_HELLO) {
276: unsigned short seqno, interval;
277: int changed;
278: if(len < 6) goto fail;
279: DO_NTOHS(seqno, message + 4);
280: DO_NTOHS(interval, message + 6);
281: debugf(BABEL_DEBUG_COMMON,"Received hello %d (%d) from %s on %s.",
282: seqno, interval,
283: format_address(from), ifp->name);
284: changed = update_neighbour(neigh, seqno, interval);
285: update_neighbour_metric(neigh, changed);
286: if(interval > 0)
287: schedule_neighbours_check(interval * 10, 0);
288: } else if(type == MESSAGE_IHU) {
289: unsigned short txcost, interval;
290: unsigned char address[16];
291: int rc;
292: if(len < 6) goto fail;
293: DO_NTOHS(txcost, message + 4);
294: DO_NTOHS(interval, message + 6);
295: rc = network_address(message[2], message + 8, len - 6, address);
296: if(rc < 0) goto fail;
297: debugf(BABEL_DEBUG_COMMON,"Received ihu %d (%d) from %s on %s for %s.",
298: txcost, interval,
299: format_address(from), ifp->name,
300: format_address(address));
301: if(message[2] == 0 || is_interface_ll_address(ifp, address)) {
302: int changed = txcost != neigh->txcost;
303: neigh->txcost = txcost;
304: neigh->ihu_time = babel_now;
305: neigh->ihu_interval = interval;
306: update_neighbour_metric(neigh, changed);
307: if(interval > 0)
308: schedule_neighbours_check(interval * 10 * 3, 0);
309: }
310: } else if(type == MESSAGE_ROUTER_ID) {
311: if(len < 10) {
312: have_router_id = 0;
313: goto fail;
314: }
315: memcpy(router_id, message + 4, 8);
316: have_router_id = 1;
317: debugf(BABEL_DEBUG_COMMON,"Received router-id %s from %s on %s.",
318: format_eui64(router_id), format_address(from), ifp->name);
319: } else if(type == MESSAGE_NH) {
320: unsigned char nh[16];
321: int rc;
322: if(len < 2) {
323: have_v4_nh = 0;
324: have_v6_nh = 0;
325: goto fail;
326: }
327: rc = network_address(message[2], message + 4, len - 2,
328: nh);
329: if(rc < 0) {
330: have_v4_nh = 0;
331: have_v6_nh = 0;
332: goto fail;
333: }
334: debugf(BABEL_DEBUG_COMMON,"Received nh %s (%d) from %s on %s.",
335: format_address(nh), message[2],
336: format_address(from), ifp->name);
337: if(message[2] == 1) {
338: memcpy(v4_nh, nh, 16);
339: have_v4_nh = 1;
340: } else {
341: memcpy(v6_nh, nh, 16);
342: have_v6_nh = 1;
343: }
344: } else if(type == MESSAGE_UPDATE) {
345: unsigned char prefix[16], *nh;
346: unsigned char plen;
347: unsigned char channels[DIVERSITY_HOPS];
348: unsigned short interval, seqno, metric;
349: int rc, parsed_len;
350: if(len < 10) {
351: if(len < 2 || message[3] & 0x80)
352: have_v4_prefix = have_v6_prefix = 0;
353: goto fail;
354: }
355: DO_NTOHS(interval, message + 6);
356: DO_NTOHS(seqno, message + 8);
357: DO_NTOHS(metric, message + 10);
358: if(message[5] == 0 ||
359: (message[3] == 1 ? have_v4_prefix : have_v6_prefix))
360: rc = network_prefix(message[2], message[4], message[5],
361: message + 12,
362: message[2] == 1 ? v4_prefix : v6_prefix,
363: len - 10, prefix);
364: else
365: rc = -1;
366: if(rc < 0) {
367: if(message[3] & 0x80)
368: have_v4_prefix = have_v6_prefix = 0;
369: goto fail;
370: }
371: parsed_len = 10 + rc;
372:
373: plen = message[4] + (message[2] == 1 ? 96 : 0);
374:
375: if(message[3] & 0x80) {
376: if(message[2] == 1) {
377: memcpy(v4_prefix, prefix, 16);
378: have_v4_prefix = 1;
379: } else {
380: memcpy(v6_prefix, prefix, 16);
381: have_v6_prefix = 1;
382: }
383: }
384: if(message[3] & 0x40) {
385: if(message[2] == 1) {
386: memset(router_id, 0, 4);
387: memcpy(router_id + 4, prefix + 12, 4);
388: } else {
389: memcpy(router_id, prefix + 8, 8);
390: }
391: have_router_id = 1;
392: }
393: if(!have_router_id && message[2] != 0) {
394: zlog_err("Received prefix with no router id.");
395: goto fail;
396: }
397: debugf(BABEL_DEBUG_COMMON,"Received update%s%s for %s from %s on %s.",
398: (message[3] & 0x80) ? "/prefix" : "",
399: (message[3] & 0x40) ? "/id" : "",
400: format_prefix(prefix, plen),
401: format_address(from), ifp->name);
402:
403: if(message[2] == 0) {
404: if(metric < 0xFFFF) {
405: zlog_err("Received wildcard update with finite metric.");
406: goto done;
407: }
408: retract_neighbour_routes(neigh);
409: goto done;
410: } else if(message[2] == 1) {
411: if(!have_v4_nh)
412: goto fail;
413: nh = v4_nh;
414: } else if(have_v6_nh) {
415: nh = v6_nh;
416: } else {
417: nh = neigh->address;
418: }
419:
420: if(message[2] == 1) {
421: if(!babel_get_if_nfo(ifp)->ipv4)
422: goto done;
423: }
424:
425: if((ifp->flags & BABEL_IF_FARAWAY)) {
426: channels[0] = 0;
427: } else {
428: /* This will be overwritten by parse_route_attributes below. */
429: if(metric < 256) {
430: /* Assume non-interfering (wired) link. */
431: channels[0] = 0;
432: } else {
433: /* Assume interfering. */
434: channels[0] = BABEL_IF_CHANNEL_INTERFERING;
435: channels[1] = 0;
436: }
437:
438: if(parsed_len < len)
439: parse_route_attributes(message + 2 + parsed_len,
440: len - parsed_len, channels);
441: }
442:
443: update_route(router_id, prefix, plen, seqno, metric, interval,
444: neigh, nh,
445: channels, channels_len(channels));
446: } else if(type == MESSAGE_REQUEST) {
447: unsigned char prefix[16], plen;
448: int rc;
449: if(len < 2) goto fail;
450: rc = network_prefix(message[2], message[3], 0,
451: message + 4, NULL, len - 2, prefix);
452: if(rc < 0) goto fail;
453: plen = message[3] + (message[2] == 1 ? 96 : 0);
454: debugf(BABEL_DEBUG_COMMON,"Received request for %s from %s on %s.",
455: message[2] == 0 ? "any" : format_prefix(prefix, plen),
456: format_address(from), ifp->name);
457: if(message[2] == 0) {
458: struct babel_interface *babel_ifp =babel_get_if_nfo(neigh->ifp);
459: /* If a neighbour is requesting a full route dump from us,
460: we might as well send it an IHU. */
461: send_ihu(neigh, NULL);
462: /* Since nodes send wildcard requests on boot, booting
463: a large number of nodes at the same time may cause an
464: update storm. Ignore a wildcard request that happens
465: shortly after we sent a full update. */
466: if(babel_ifp->last_update_time <
467: (time_t)(babel_now.tv_sec -
468: MAX(babel_ifp->hello_interval / 100, 1)))
469: send_update(neigh->ifp, 0, NULL, 0);
470: } else {
471: send_update(neigh->ifp, 0, prefix, plen);
472: }
473: } else if(type == MESSAGE_MH_REQUEST) {
474: unsigned char prefix[16], plen;
475: unsigned short seqno;
476: int rc;
477: if(len < 14) goto fail;
478: DO_NTOHS(seqno, message + 4);
479: rc = network_prefix(message[2], message[3], 0,
480: message + 16, NULL, len - 14, prefix);
481: if(rc < 0) goto fail;
482: plen = message[3] + (message[2] == 1 ? 96 : 0);
483: debugf(BABEL_DEBUG_COMMON,"Received request (%d) for %s from %s on %s (%s, %d).",
484: message[6],
485: format_prefix(prefix, plen),
486: format_address(from), ifp->name,
487: format_eui64(message + 8), seqno);
488: handle_request(neigh, prefix, plen, message[6],
489: seqno, message + 8);
490: } else {
491: debugf(BABEL_DEBUG_COMMON,"Received unknown packet type %d from %s on %s.",
492: type, format_address(from), ifp->name);
493: }
494: done:
495: i += len + 2;
496: continue;
497:
498: fail:
499: zlog_err("Couldn't parse packet (%d, %d) from %s on %s.",
500: message[0], message[1], format_address(from), ifp->name);
501: goto done;
502: }
503: return;
504: }
505:
506: /* Under normal circumstances, there are enough moderation mechanisms
507: elsewhere in the protocol to make sure that this last-ditch check
508: should never trigger. But I'm superstitious. */
509:
510: static int
511: check_bucket(struct interface *ifp)
512: {
513: babel_interface_nfo *babel_ifp = babel_get_if_nfo(ifp);
514: if(babel_ifp->bucket <= 0) {
515: int seconds = babel_now.tv_sec - babel_ifp->bucket_time;
516: if(seconds > 0) {
517: babel_ifp->bucket = MIN(BUCKET_TOKENS_MAX,
518: seconds * BUCKET_TOKENS_PER_SEC);
519: }
520: /* Reset bucket time unconditionally, in case clock is stepped. */
521: babel_ifp->bucket_time = babel_now.tv_sec;
522: }
523:
524: if(babel_ifp->bucket > 0) {
525: babel_ifp->bucket--;
526: return 1;
527: } else {
528: return 0;
529: }
530: }
531:
532: void
533: flushbuf(struct interface *ifp)
534: {
535: int rc;
536: struct sockaddr_in6 sin6;
537: babel_interface_nfo *babel_ifp = babel_get_if_nfo(ifp);
538:
539: assert(babel_ifp->buffered <= babel_ifp->bufsize);
540:
541: flushupdates(ifp);
542:
543: if(babel_ifp->buffered > 0) {
544: debugf(BABEL_DEBUG_COMMON," (flushing %d buffered bytes on %s)",
545: babel_ifp->buffered, ifp->name);
546: if(check_bucket(ifp)) {
547: memset(&sin6, 0, sizeof(sin6));
548: sin6.sin6_family = AF_INET6;
549: memcpy(&sin6.sin6_addr, protocol_group, 16);
550: sin6.sin6_port = htons(protocol_port);
551: sin6.sin6_scope_id = ifp->ifindex;
552: DO_HTONS(packet_header + 2, babel_ifp->buffered);
553: rc = babel_send(protocol_socket,
554: packet_header, sizeof(packet_header),
555: babel_ifp->sendbuf, babel_ifp->buffered,
556: (struct sockaddr*)&sin6, sizeof(sin6));
557: if(rc < 0)
558: zlog_err("send: %s", safe_strerror(errno));
559: } else {
560: zlog_err("Warning: bucket full, dropping packet to %s.",
561: ifp->name);
562: }
563: }
564: VALGRIND_MAKE_MEM_UNDEFINED(babel_ifp->sendbuf, babel_ifp->bufsize);
565: babel_ifp->buffered = 0;
566: babel_ifp->have_buffered_hello = 0;
567: babel_ifp->have_buffered_id = 0;
568: babel_ifp->have_buffered_nh = 0;
569: babel_ifp->have_buffered_prefix = 0;
570: babel_ifp->flush_timeout.tv_sec = 0;
571: babel_ifp->flush_timeout.tv_usec = 0;
572: }
573:
574: static void
575: schedule_flush(struct interface *ifp)
576: {
577: babel_interface_nfo *babel_ifp = babel_get_if_nfo(ifp);
578: unsigned msecs = jitter(babel_ifp, 0);
579: if(babel_ifp->flush_timeout.tv_sec != 0 &&
580: timeval_minus_msec(&babel_ifp->flush_timeout, &babel_now) < msecs)
581: return;
582: set_timeout(&babel_ifp->flush_timeout, msecs);
583: }
584:
585: static void
586: schedule_flush_now(struct interface *ifp)
587: {
588: babel_interface_nfo *babel_ifp = babel_get_if_nfo(ifp);
589: /* Almost now */
590: unsigned msecs = roughly(10);
591: if(babel_ifp->flush_timeout.tv_sec != 0 &&
592: timeval_minus_msec(&babel_ifp->flush_timeout, &babel_now) < msecs)
593: return;
594: set_timeout(&babel_ifp->flush_timeout, msecs);
595: }
596:
597: static void
598: schedule_unicast_flush(unsigned msecs)
599: {
600: if(!unicast_neighbour)
601: return;
602: if(unicast_flush_timeout.tv_sec != 0 &&
603: timeval_minus_msec(&unicast_flush_timeout, &babel_now) < msecs)
604: return;
605: unicast_flush_timeout.tv_usec = (babel_now.tv_usec + msecs * 1000) %1000000;
606: unicast_flush_timeout.tv_sec =
607: babel_now.tv_sec + (babel_now.tv_usec / 1000 + msecs) / 1000;
608: }
609:
610: static void
611: ensure_space(struct interface *ifp, int space)
612: {
613: babel_interface_nfo *babel_ifp = babel_get_if_nfo(ifp);
614: if(babel_ifp->bufsize - babel_ifp->buffered < space)
615: flushbuf(ifp);
616: }
617:
618: static void
619: start_message(struct interface *ifp, int type, int len)
620: {
621: babel_interface_nfo *babel_ifp = babel_get_if_nfo(ifp);
622: if(babel_ifp->bufsize - babel_ifp->buffered < len + 2)
623: flushbuf(ifp);
624: babel_ifp->sendbuf[babel_ifp->buffered++] = type;
625: babel_ifp->sendbuf[babel_ifp->buffered++] = len;
626: }
627:
628: static void
629: end_message(struct interface *ifp, int type, int bytes)
630: {
631: babel_interface_nfo *babel_ifp = babel_get_if_nfo(ifp);
632: assert(babel_ifp->buffered >= bytes + 2 &&
633: babel_ifp->sendbuf[babel_ifp->buffered - bytes - 2] == type &&
634: babel_ifp->sendbuf[babel_ifp->buffered - bytes - 1] == bytes);
635: schedule_flush(ifp);
636: }
637:
638: static void
639: accumulate_byte(struct interface *ifp, unsigned char value)
640: {
641: babel_interface_nfo *babel_ifp = babel_get_if_nfo(ifp);
642: babel_ifp->sendbuf[babel_ifp->buffered++] = value;
643: }
644:
645: static void
646: accumulate_short(struct interface *ifp, unsigned short value)
647: {
648: babel_interface_nfo *babel_ifp = babel_get_if_nfo(ifp);
649: DO_HTONS(babel_ifp->sendbuf + babel_ifp->buffered, value);
650: babel_ifp->buffered += 2;
651: }
652:
653: static void
654: accumulate_bytes(struct interface *ifp,
655: const unsigned char *value, unsigned len)
656: {
657: babel_interface_nfo *babel_ifp = babel_get_if_nfo(ifp);
658: memcpy(babel_ifp->sendbuf + babel_ifp->buffered, value, len);
659: babel_ifp->buffered += len;
660: }
661:
662: static int
663: start_unicast_message(struct neighbour *neigh, int type, int len)
664: {
665: if(unicast_neighbour) {
666: if(neigh != unicast_neighbour ||
667: unicast_buffered + len + 2 >=
668: MIN(UNICAST_BUFSIZE, babel_get_if_nfo(neigh->ifp)->bufsize))
669: flush_unicast(0);
670: }
671: if(!unicast_buffer)
672: unicast_buffer = malloc(UNICAST_BUFSIZE);
673: if(!unicast_buffer) {
674: zlog_err("malloc(unicast_buffer): %s", safe_strerror(errno));
675: return -1;
676: }
677:
678: unicast_neighbour = neigh;
679:
680: unicast_buffer[unicast_buffered++] = type;
681: unicast_buffer[unicast_buffered++] = len;
682: return 1;
683: }
684:
685: static void
686: end_unicast_message(struct neighbour *neigh, int type, int bytes)
687: {
688: assert(unicast_neighbour == neigh && unicast_buffered >= bytes + 2 &&
689: unicast_buffer[unicast_buffered - bytes - 2] == type &&
690: unicast_buffer[unicast_buffered - bytes - 1] == bytes);
691: schedule_unicast_flush(jitter(babel_get_if_nfo(neigh->ifp), 0));
692: }
693:
694: static void
695: accumulate_unicast_byte(struct neighbour *neigh, unsigned char value)
696: {
697: unicast_buffer[unicast_buffered++] = value;
698: }
699:
700: static void
701: accumulate_unicast_short(struct neighbour *neigh, unsigned short value)
702: {
703: DO_HTONS(unicast_buffer + unicast_buffered, value);
704: unicast_buffered += 2;
705: }
706:
707: static void
708: accumulate_unicast_bytes(struct neighbour *neigh,
709: const unsigned char *value, unsigned len)
710: {
711: memcpy(unicast_buffer + unicast_buffered, value, len);
712: unicast_buffered += len;
713: }
714:
715: void
716: send_ack(struct neighbour *neigh, unsigned short nonce, unsigned short interval)
717: {
718: int rc;
719: debugf(BABEL_DEBUG_COMMON,"Sending ack (%04x) to %s on %s.",
720: nonce, format_address(neigh->address), neigh->ifp->name);
721: rc = start_unicast_message(neigh, MESSAGE_ACK, 2); if(rc < 0) return;
722: accumulate_unicast_short(neigh, nonce);
723: end_unicast_message(neigh, MESSAGE_ACK, 2);
724: /* Roughly yields a value no larger than 3/2, so this meets the deadline */
725: schedule_unicast_flush(roughly(interval * 6));
726: }
727:
728: void
729: send_hello_noupdate(struct interface *ifp, unsigned interval)
730: {
731: babel_interface_nfo *babel_ifp = babel_get_if_nfo(ifp);
732: /* This avoids sending multiple hellos in a single packet, which breaks
733: link quality estimation. */
734: if(babel_ifp->have_buffered_hello)
735: flushbuf(ifp);
736:
737: babel_ifp->hello_seqno = seqno_plus(babel_ifp->hello_seqno, 1);
738: set_timeout(&babel_ifp->hello_timeout, babel_ifp->hello_interval);
739:
740: if(!if_up(ifp))
741: return;
742:
743: debugf(BABEL_DEBUG_COMMON,"Sending hello %d (%d) to %s.",
744: babel_ifp->hello_seqno, interval, ifp->name);
745:
746: start_message(ifp, MESSAGE_HELLO, 6);
747: accumulate_short(ifp, 0);
748: accumulate_short(ifp, babel_ifp->hello_seqno);
749: accumulate_short(ifp, interval > 0xFFFF ? 0xFFFF : interval);
750: end_message(ifp, MESSAGE_HELLO, 6);
751: babel_ifp->have_buffered_hello = 1;
752: }
753:
754: void
755: send_hello(struct interface *ifp)
756: {
757: babel_interface_nfo *babel_ifp = babel_get_if_nfo(ifp);
758: send_hello_noupdate(ifp, (babel_ifp->hello_interval + 9) / 10);
759: /* Send full IHU every 3 hellos, and marginal IHU each time */
760: if(babel_ifp->hello_seqno % 3 == 0)
761: send_ihu(NULL, ifp);
762: else
763: send_marginal_ihu(ifp);
764: }
765:
766: void
767: flush_unicast(int dofree)
768: {
769: struct sockaddr_in6 sin6;
770: int rc;
771:
772: if(unicast_buffered == 0)
773: goto done;
774:
775: if(!if_up(unicast_neighbour->ifp))
776: goto done;
777:
778: /* Preserve ordering of messages */
779: flushbuf(unicast_neighbour->ifp);
780:
781: if(check_bucket(unicast_neighbour->ifp)) {
782: memset(&sin6, 0, sizeof(sin6));
783: sin6.sin6_family = AF_INET6;
784: memcpy(&sin6.sin6_addr, unicast_neighbour->address, 16);
785: sin6.sin6_port = htons(protocol_port);
786: sin6.sin6_scope_id = unicast_neighbour->ifp->ifindex;
787: DO_HTONS(packet_header + 2, unicast_buffered);
788: rc = babel_send(protocol_socket,
789: packet_header, sizeof(packet_header),
790: unicast_buffer, unicast_buffered,
791: (struct sockaddr*)&sin6, sizeof(sin6));
792: if(rc < 0)
793: zlog_err("send(unicast): %s", safe_strerror(errno));
794: } else {
795: zlog_err("Warning: bucket full, dropping unicast packet to %s if %s.",
796: format_address(unicast_neighbour->address),
797: unicast_neighbour->ifp->name);
798: }
799:
800: done:
801: VALGRIND_MAKE_MEM_UNDEFINED(unicast_buffer, UNICAST_BUFSIZE);
802: unicast_buffered = 0;
803: if(dofree && unicast_buffer) {
804: free(unicast_buffer);
805: unicast_buffer = NULL;
806: }
807: unicast_neighbour = NULL;
808: unicast_flush_timeout.tv_sec = 0;
809: unicast_flush_timeout.tv_usec = 0;
810: }
811:
812: static void
813: really_send_update(struct interface *ifp,
814: const unsigned char *id,
815: const unsigned char *prefix, unsigned char plen,
816: unsigned short seqno, unsigned short metric,
817: unsigned char *channels, int channels_len)
818: {
819: babel_interface_nfo *babel_ifp = babel_get_if_nfo(ifp);
820: int add_metric, v4, real_plen, omit = 0;
821: const unsigned char *real_prefix;
822: unsigned short flags = 0;
823: int channels_size;
824:
825: if(diversity_kind != DIVERSITY_CHANNEL)
826: channels_len = -1;
827:
828: channels_size = channels_len >= 0 ? channels_len + 2 : 0;
829:
830: if(!if_up(ifp))
831: return;
832:
833: add_metric = output_filter(id, prefix, plen, ifp->ifindex);
834: if(add_metric >= INFINITY)
835: return;
836:
837: metric = MIN(metric + add_metric, INFINITY);
838: /* Worst case */
839: ensure_space(ifp, 20 + 12 + 28);
840:
841: v4 = plen >= 96 && v4mapped(prefix);
842:
843: if(v4) {
844: if(!babel_ifp->ipv4)
845: return;
846: if(!babel_ifp->have_buffered_nh ||
847: memcmp(babel_ifp->buffered_nh, babel_ifp->ipv4, 4) != 0) {
848: start_message(ifp, MESSAGE_NH, 6);
849: accumulate_byte(ifp, 1);
850: accumulate_byte(ifp, 0);
851: accumulate_bytes(ifp, babel_ifp->ipv4, 4);
852: end_message(ifp, MESSAGE_NH, 6);
853: memcpy(babel_ifp->buffered_nh, babel_ifp->ipv4, 4);
854: babel_ifp->have_buffered_nh = 1;
855: }
856:
857: real_prefix = prefix + 12;
858: real_plen = plen - 96;
859: } else {
860: if(babel_ifp->have_buffered_prefix) {
861: while(omit < plen / 8 &&
862: babel_ifp->buffered_prefix[omit] == prefix[omit])
863: omit++;
864: }
865: if(!babel_ifp->have_buffered_prefix || plen >= 48)
866: flags |= 0x80;
867: real_prefix = prefix;
868: real_plen = plen;
869: }
870:
871: if(!babel_ifp->have_buffered_id
872: || memcmp(id, babel_ifp->buffered_id, 8) != 0) {
873: if(real_plen == 128 && memcmp(real_prefix + 8, id, 8) == 0) {
874: flags |= 0x40;
875: } else {
876: start_message(ifp, MESSAGE_ROUTER_ID, 10);
877: accumulate_short(ifp, 0);
878: accumulate_bytes(ifp, id, 8);
879: end_message(ifp, MESSAGE_ROUTER_ID, 10);
880: }
881: memcpy(babel_ifp->buffered_id, id, 16);
882: babel_ifp->have_buffered_id = 1;
883: }
884:
885: start_message(ifp, MESSAGE_UPDATE, 10 + (real_plen + 7) / 8 - omit +
886: channels_size);
887: accumulate_byte(ifp, v4 ? 1 : 2);
888: accumulate_byte(ifp, flags);
889: accumulate_byte(ifp, real_plen);
890: accumulate_byte(ifp, omit);
891: accumulate_short(ifp, (babel_ifp->update_interval + 5) / 10);
892: accumulate_short(ifp, seqno);
893: accumulate_short(ifp, metric);
894: accumulate_bytes(ifp, real_prefix + omit, (real_plen + 7) / 8 - omit);
895: /* Note that an empty channels TLV is different from no such TLV. */
896: if(channels_len >= 0) {
897: accumulate_byte(ifp, 2);
898: accumulate_byte(ifp, channels_len);
899: accumulate_bytes(ifp, channels, channels_len);
900: }
901: end_message(ifp, MESSAGE_UPDATE, 10 + (real_plen + 7) / 8 - omit +
902: channels_size);
903:
904: if(flags & 0x80) {
905: memcpy(babel_ifp->buffered_prefix, prefix, 16);
906: babel_ifp->have_buffered_prefix = 1;
907: }
908: }
909:
910: static int
911: compare_buffered_updates(const void *av, const void *bv)
912: {
913: const struct buffered_update *a = av, *b = bv;
914: int rc, v4a, v4b, ma, mb;
915:
916: rc = memcmp(a->id, b->id, 8);
917: if(rc != 0)
918: return rc;
919:
920: v4a = (a->plen >= 96 && v4mapped(a->prefix));
921: v4b = (b->plen >= 96 && v4mapped(b->prefix));
922:
923: if(v4a > v4b)
924: return 1;
925: else if(v4a < v4b)
926: return -1;
927:
928: ma = (!v4a && a->plen == 128 && memcmp(a->prefix + 8, a->id, 8) == 0);
929: mb = (!v4b && b->plen == 128 && memcmp(b->prefix + 8, b->id, 8) == 0);
930:
931: if(ma > mb)
932: return -1;
933: else if(mb > ma)
934: return 1;
935:
936: if(a->plen < b->plen)
937: return 1;
938: else if(a->plen > b->plen)
939: return -1;
940:
941: return memcmp(a->prefix, b->prefix, 16);
942: }
943:
944: void
945: flushupdates(struct interface *ifp)
946: {
947: babel_interface_nfo *babel_ifp = NULL;
948: struct xroute *xroute;
949: struct babel_route *route;
950: const unsigned char *last_prefix = NULL;
951: unsigned char last_plen = 0xFF;
952: int i;
953:
954: if(ifp == NULL) {
955: struct interface *ifp_aux;
956: struct listnode *linklist_node = NULL;
957: FOR_ALL_INTERFACES(ifp_aux, linklist_node)
958: flushupdates(ifp_aux);
959: return;
960: }
961:
962: babel_ifp = babel_get_if_nfo(ifp);
963: if(babel_ifp->num_buffered_updates > 0) {
964: struct buffered_update *b = babel_ifp->buffered_updates;
965: int n = babel_ifp->num_buffered_updates;
966:
967: babel_ifp->buffered_updates = NULL;
968: babel_ifp->update_bufsize = 0;
969: babel_ifp->num_buffered_updates = 0;
970:
971: if(!if_up(ifp))
972: goto done;
973:
974: debugf(BABEL_DEBUG_COMMON," (flushing %d buffered updates on %s (%d))",
975: n, ifp->name, ifp->ifindex);
976:
977: /* In order to send fewer update messages, we want to send updates
978: with the same router-id together, with IPv6 going out before IPv4. */
979:
980: for(i = 0; i < n; i++) {
981: route = find_installed_route(b[i].prefix, b[i].plen);
982: if(route)
983: memcpy(b[i].id, route->src->id, 8);
984: else
985: memcpy(b[i].id, myid, 8);
986: }
987:
988: qsort(b, n, sizeof(struct buffered_update), compare_buffered_updates);
989:
990: for(i = 0; i < n; i++) {
991: /* The same update may be scheduled multiple times before it is
992: sent out. Since our buffer is now sorted, it is enough to
993: compare with the previous update. */
994:
995: if(last_prefix) {
996: if(b[i].plen == last_plen &&
997: memcmp(b[i].prefix, last_prefix, 16) == 0)
998: continue;
999: }
1000:
1001: xroute = find_xroute(b[i].prefix, b[i].plen);
1002: route = find_installed_route(b[i].prefix, b[i].plen);
1003:
1004: if(xroute && (!route || xroute->metric <= kernel_metric)) {
1005: really_send_update(ifp, myid,
1006: xroute->prefix, xroute->plen,
1007: myseqno, xroute->metric,
1008: NULL, 0);
1009: last_prefix = xroute->prefix;
1010: last_plen = xroute->plen;
1011: } else if(route) {
1012: unsigned char channels[DIVERSITY_HOPS];
1013: int chlen;
1014: struct interface *route_ifp = route->neigh->ifp;
1015: struct babel_interface *babel_route_ifp = NULL;
1016: unsigned short metric;
1017: unsigned short seqno;
1018:
1019: seqno = route->seqno;
1020: metric =
1021: route_interferes(route, ifp) ?
1022: route_metric(route) :
1023: route_metric_noninterfering(route);
1024:
1025: if(metric < INFINITY)
1026: satisfy_request(route->src->prefix, route->src->plen,
1027: seqno, route->src->id, ifp);
1028: if((babel_ifp->flags & BABEL_IF_SPLIT_HORIZON) &&
1029: route->neigh->ifp == ifp)
1030: continue;
1031:
1032: babel_route_ifp = babel_get_if_nfo(route_ifp);
1033: if(babel_route_ifp->channel ==BABEL_IF_CHANNEL_NONINTERFERING) {
1034: memcpy(channels, route->channels, DIVERSITY_HOPS);
1035: } else {
1036: if(babel_route_ifp->channel == BABEL_IF_CHANNEL_UNKNOWN)
1037: channels[0] = BABEL_IF_CHANNEL_INTERFERING;
1038: else {
1039: assert(babel_route_ifp->channel > 0 &&
1040: babel_route_ifp->channel <= 255);
1041: channels[0] = babel_route_ifp->channel;
1042: }
1043: memcpy(channels + 1, route->channels, DIVERSITY_HOPS - 1);
1044: }
1045:
1046: chlen = channels_len(channels);
1047: really_send_update(ifp, route->src->id,
1048: route->src->prefix,
1049: route->src->plen,
1050: seqno, metric,
1051: channels, chlen);
1052: update_source(route->src, seqno, metric);
1053: last_prefix = route->src->prefix;
1054: last_plen = route->src->plen;
1055: } else {
1056: /* There's no route for this prefix. This can happen shortly
1057: after an xroute has been retracted, so send a retraction. */
1058: really_send_update(ifp, myid, b[i].prefix, b[i].plen,
1059: myseqno, INFINITY, NULL, -1);
1060: }
1061: }
1062: schedule_flush_now(ifp);
1063: done:
1064: free(b);
1065: }
1066: babel_ifp->update_flush_timeout.tv_sec = 0;
1067: babel_ifp->update_flush_timeout.tv_usec = 0;
1068: }
1069:
1070: static void
1071: schedule_update_flush(struct interface *ifp, int urgent)
1072: {
1073: babel_interface_nfo *babel_ifp = babel_get_if_nfo(ifp);
1074: unsigned msecs;
1075: msecs = update_jitter(babel_ifp, urgent);
1076: if(babel_ifp->update_flush_timeout.tv_sec != 0 &&
1077: timeval_minus_msec(&babel_ifp->update_flush_timeout, &babel_now) < msecs)
1078: return;
1079: set_timeout(&babel_ifp->update_flush_timeout, msecs);
1080: }
1081:
1082: static void
1083: buffer_update(struct interface *ifp,
1084: const unsigned char *prefix, unsigned char plen)
1085: {
1086: babel_interface_nfo *babel_ifp = babel_get_if_nfo(ifp);
1087: if(babel_ifp->num_buffered_updates > 0 &&
1088: babel_ifp->num_buffered_updates >= babel_ifp->update_bufsize)
1089: flushupdates(ifp);
1090:
1091: if(babel_ifp->update_bufsize == 0) {
1092: int n;
1093: assert(babel_ifp->buffered_updates == NULL);
1094: /* Allocate enough space to hold a full update. Since the
1095: number of installed routes will grow over time, make sure we
1096: have enough space to send a full-ish frame. */
1097: n = installed_routes_estimate() + xroutes_estimate() + 4;
1098: n = MAX(n, babel_ifp->bufsize / 16);
1099: again:
1100: babel_ifp->buffered_updates = malloc(n *sizeof(struct buffered_update));
1101: if(babel_ifp->buffered_updates == NULL) {
1102: zlog_err("malloc(buffered_updates): %s", safe_strerror(errno));
1103: if(n > 4) {
1104: /* Try again with a tiny buffer. */
1105: n = 4;
1106: goto again;
1107: }
1108: return;
1109: }
1110: babel_ifp->update_bufsize = n;
1111: babel_ifp->num_buffered_updates = 0;
1112: }
1113:
1114: memcpy(babel_ifp->buffered_updates[babel_ifp->num_buffered_updates].prefix,
1115: prefix, 16);
1116: babel_ifp->buffered_updates[babel_ifp->num_buffered_updates].plen = plen;
1117: babel_ifp->num_buffered_updates++;
1118: }
1119:
1120: static void
1121: buffer_update_callback(struct babel_route *route, void *closure)
1122: {
1123: buffer_update((struct interface*)closure,
1124: route->src->prefix, route->src->plen);
1125: }
1126:
1127: void
1128: send_update(struct interface *ifp, int urgent,
1129: const unsigned char *prefix, unsigned char plen)
1130: {
1131: babel_interface_nfo *babel_ifp = NULL;
1132:
1133: if(ifp == NULL) {
1134: struct interface *ifp_aux;
1135: struct listnode *linklist_node = NULL;
1136: struct babel_route *route;
1137: FOR_ALL_INTERFACES(ifp_aux, linklist_node)
1138: send_update(ifp_aux, urgent, prefix, plen);
1139: if(prefix) {
1140: /* Since flushupdates only deals with non-wildcard interfaces, we
1141: need to do this now. */
1142: route = find_installed_route(prefix, plen);
1143: if(route && route_metric(route) < INFINITY)
1144: satisfy_request(prefix, plen, route->src->seqno, route->src->id,
1145: NULL);
1146: }
1147: return;
1148: }
1149:
1150: if(!if_up(ifp))
1151: return;
1152:
1153: babel_ifp = babel_get_if_nfo(ifp);
1154: if(prefix) {
1155: debugf(BABEL_DEBUG_COMMON,"Sending update to %s for %s.",
1156: ifp->name, format_prefix(prefix, plen));
1157: buffer_update(ifp, prefix, plen);
1158: } else {
1159: send_self_update(ifp);
1160: debugf(BABEL_DEBUG_COMMON,"Sending update to %s for any.", ifp->name);
1161: for_all_installed_routes(buffer_update_callback, ifp);
1162: set_timeout(&babel_ifp->update_timeout, babel_ifp->update_interval);
1163: babel_ifp->last_update_time = babel_now.tv_sec;
1164: }
1165: schedule_update_flush(ifp, urgent);
1166: }
1167:
1168: void
1169: send_update_resend(struct interface *ifp,
1170: const unsigned char *prefix, unsigned char plen)
1171: {
1172: assert(prefix != NULL);
1173:
1174: send_update(ifp, 1, prefix, plen);
1175: record_resend(RESEND_UPDATE, prefix, plen, 0, 0, NULL, resend_delay);
1176: }
1177:
1178: void
1179: send_wildcard_retraction(struct interface *ifp)
1180: {
1181: babel_interface_nfo *babel_ifp = NULL;
1182: if(ifp == NULL) {
1183: struct interface *ifp_aux;
1184: struct listnode *linklist_node = NULL;
1185: FOR_ALL_INTERFACES(ifp_aux, linklist_node)
1186: send_wildcard_retraction(ifp_aux);
1187: return;
1188: }
1189:
1190: if(!if_up(ifp))
1191: return;
1192:
1193: babel_ifp = babel_get_if_nfo(ifp);
1194: start_message(ifp, MESSAGE_UPDATE, 10);
1195: accumulate_byte(ifp, 0);
1196: accumulate_byte(ifp, 0x40);
1197: accumulate_byte(ifp, 0);
1198: accumulate_byte(ifp, 0);
1199: accumulate_short(ifp, 0xFFFF);
1200: accumulate_short(ifp, myseqno);
1201: accumulate_short(ifp, 0xFFFF);
1202: end_message(ifp, MESSAGE_UPDATE, 10);
1203:
1204: babel_ifp->have_buffered_id = 0;
1205: }
1206:
1207: void
1208: update_myseqno()
1209: {
1210: myseqno = seqno_plus(myseqno, 1);
1211: seqno_time = babel_now;
1212: }
1213:
1214: static void
1215: send_xroute_update_callback(struct xroute *xroute, void *closure)
1216: {
1217: struct interface *ifp = (struct interface*)closure;
1218: send_update(ifp, 0, xroute->prefix, xroute->plen);
1219: }
1220:
1221: void
1222: send_self_update(struct interface *ifp)
1223: {
1224: if(ifp == NULL) {
1225: struct interface *ifp_aux;
1226: struct listnode *linklist_node = NULL;
1227: FOR_ALL_INTERFACES(ifp_aux, linklist_node) {
1228: if(!if_up(ifp_aux))
1229: continue;
1230: send_self_update(ifp_aux);
1231: }
1232: return;
1233: }
1234:
1235: debugf(BABEL_DEBUG_COMMON,"Sending self update to %s.", ifp->name);
1236: for_all_xroutes(send_xroute_update_callback, ifp);
1237: }
1238:
1239: void
1240: send_ihu(struct neighbour *neigh, struct interface *ifp)
1241: {
1242: babel_interface_nfo *babel_ifp = NULL;
1243: int rxcost, interval;
1244: int ll;
1245:
1246: if(neigh == NULL && ifp == NULL) {
1247: struct interface *ifp_aux;
1248: struct listnode *linklist_node = NULL;
1249: FOR_ALL_INTERFACES(ifp_aux, linklist_node) {
1250: if(if_up(ifp_aux))
1251: continue;
1252: send_ihu(NULL, ifp_aux);
1253: }
1254: return;
1255: }
1256:
1257: if(neigh == NULL) {
1258: struct neighbour *ngh;
1259: FOR_ALL_NEIGHBOURS(ngh) {
1260: if(ngh->ifp == ifp)
1261: send_ihu(ngh, ifp);
1262: }
1263: return;
1264: }
1265:
1266:
1267: if(ifp && neigh->ifp != ifp)
1268: return;
1269:
1270: ifp = neigh->ifp;
1271: babel_ifp = babel_get_if_nfo(ifp);
1272: if(!if_up(ifp))
1273: return;
1274:
1275: rxcost = neighbour_rxcost(neigh);
1276: interval = (babel_ifp->hello_interval * 3 + 9) / 10;
1277:
1278: /* Conceptually, an IHU is a unicast message. We usually send them as
1279: multicast, since this allows aggregation into a single packet and
1280: avoids an ARP exchange. If we already have a unicast message queued
1281: for this neighbour, however, we might as well piggyback the IHU. */
1282: debugf(BABEL_DEBUG_COMMON,"Sending %sihu %d on %s to %s.",
1283: unicast_neighbour == neigh ? "unicast " : "",
1284: rxcost,
1285: neigh->ifp->name,
1286: format_address(neigh->address));
1287:
1288: ll = linklocal(neigh->address);
1289:
1290: if(unicast_neighbour != neigh) {
1291: start_message(ifp, MESSAGE_IHU, ll ? 14 : 22);
1292: accumulate_byte(ifp, ll ? 3 : 2);
1293: accumulate_byte(ifp, 0);
1294: accumulate_short(ifp, rxcost);
1295: accumulate_short(ifp, interval);
1296: if(ll)
1297: accumulate_bytes(ifp, neigh->address + 8, 8);
1298: else
1299: accumulate_bytes(ifp, neigh->address, 16);
1300: end_message(ifp, MESSAGE_IHU, ll ? 14 : 22);
1301: } else {
1302: int rc;
1303: rc = start_unicast_message(neigh, MESSAGE_IHU, ll ? 14 : 22);
1304: if(rc < 0) return;
1305: accumulate_unicast_byte(neigh, ll ? 3 : 2);
1306: accumulate_unicast_byte(neigh, 0);
1307: accumulate_unicast_short(neigh, rxcost);
1308: accumulate_unicast_short(neigh, interval);
1309: if(ll)
1310: accumulate_unicast_bytes(neigh, neigh->address + 8, 8);
1311: else
1312: accumulate_unicast_bytes(neigh, neigh->address, 16);
1313: end_unicast_message(neigh, MESSAGE_IHU, ll ? 14 : 22);
1314: }
1315: }
1316:
1317: /* Send IHUs to all marginal neighbours */
1318: void
1319: send_marginal_ihu(struct interface *ifp)
1320: {
1321: struct neighbour *neigh;
1322: FOR_ALL_NEIGHBOURS(neigh) {
1323: if(ifp && neigh->ifp != ifp)
1324: continue;
1325: if(neigh->txcost >= 384 || (neigh->reach & 0xF000) != 0xF000)
1326: send_ihu(neigh, ifp);
1327: }
1328: }
1329:
1330: void
1331: send_request(struct interface *ifp,
1332: const unsigned char *prefix, unsigned char plen)
1333: {
1334: int v4, len;
1335:
1336: if(ifp == NULL) {
1337: struct interface *ifp_aux;
1338: struct listnode *linklist_node = NULL;
1339: FOR_ALL_INTERFACES(ifp_aux, linklist_node) {
1340: if(if_up(ifp_aux))
1341: continue;
1342: send_request(ifp_aux, prefix, plen);
1343: }
1344: return;
1345: }
1346:
1347: /* make sure any buffered updates go out before this request. */
1348: flushupdates(ifp);
1349:
1350: if(!if_up(ifp))
1351: return;
1352:
1353: debugf(BABEL_DEBUG_COMMON,"sending request to %s for %s.",
1354: ifp->name, prefix ? format_prefix(prefix, plen) : "any");
1355: v4 = plen >= 96 && v4mapped(prefix);
1356: len = !prefix ? 2 : v4 ? 6 : 18;
1357:
1358: start_message(ifp, MESSAGE_REQUEST, len);
1359: accumulate_byte(ifp, !prefix ? 0 : v4 ? 1 : 2);
1360: accumulate_byte(ifp, !prefix ? 0 : v4 ? plen - 96 : plen);
1361: if(prefix) {
1362: if(v4)
1363: accumulate_bytes(ifp, prefix + 12, 4);
1364: else
1365: accumulate_bytes(ifp, prefix, 16);
1366: }
1367: end_message(ifp, MESSAGE_REQUEST, len);
1368: }
1369:
1370: void
1371: send_unicast_request(struct neighbour *neigh,
1372: const unsigned char *prefix, unsigned char plen)
1373: {
1374: int rc, v4, len;
1375:
1376: /* make sure any buffered updates go out before this request. */
1377: flushupdates(neigh->ifp);
1378:
1379: debugf(BABEL_DEBUG_COMMON,"sending unicast request to %s for %s.",
1380: format_address(neigh->address),
1381: prefix ? format_prefix(prefix, plen) : "any");
1382: v4 = plen >= 96 && v4mapped(prefix);
1383: len = !prefix ? 2 : v4 ? 6 : 18;
1384:
1385: rc = start_unicast_message(neigh, MESSAGE_REQUEST, len);
1386: if(rc < 0) return;
1387: accumulate_unicast_byte(neigh, !prefix ? 0 : v4 ? 1 : 2);
1388: accumulate_unicast_byte(neigh, !prefix ? 0 : v4 ? plen - 96 : plen);
1389: if(prefix) {
1390: if(v4)
1391: accumulate_unicast_bytes(neigh, prefix + 12, 4);
1392: else
1393: accumulate_unicast_bytes(neigh, prefix, 16);
1394: }
1395: end_unicast_message(neigh, MESSAGE_REQUEST, len);
1396: }
1397:
1398: void
1399: send_multihop_request(struct interface *ifp,
1400: const unsigned char *prefix, unsigned char plen,
1401: unsigned short seqno, const unsigned char *id,
1402: unsigned short hop_count)
1403: {
1404: int v4, pb, len;
1405:
1406: /* Make sure any buffered updates go out before this request. */
1407: flushupdates(ifp);
1408:
1409: if(ifp == NULL) {
1410: struct interface *ifp_aux;
1411: struct listnode *linklist_node = NULL;
1412: FOR_ALL_INTERFACES(ifp_aux, linklist_node) {
1413: if(!if_up(ifp_aux))
1414: continue;
1415: send_multihop_request(ifp_aux, prefix, plen, seqno, id, hop_count);
1416: }
1417: return;
1418: }
1419:
1420: if(!if_up(ifp))
1421: return;
1422:
1423: debugf(BABEL_DEBUG_COMMON,"Sending request (%d) on %s for %s.",
1424: hop_count, ifp->name, format_prefix(prefix, plen));
1425: v4 = plen >= 96 && v4mapped(prefix);
1426: pb = v4 ? ((plen - 96) + 7) / 8 : (plen + 7) / 8;
1427: len = 6 + 8 + pb;
1428:
1429: start_message(ifp, MESSAGE_MH_REQUEST, len);
1430: accumulate_byte(ifp, v4 ? 1 : 2);
1431: accumulate_byte(ifp, v4 ? plen - 96 : plen);
1432: accumulate_short(ifp, seqno);
1433: accumulate_byte(ifp, hop_count);
1434: accumulate_byte(ifp, 0);
1435: accumulate_bytes(ifp, id, 8);
1436: if(prefix) {
1437: if(v4)
1438: accumulate_bytes(ifp, prefix + 12, pb);
1439: else
1440: accumulate_bytes(ifp, prefix, pb);
1441: }
1442: end_message(ifp, MESSAGE_MH_REQUEST, len);
1443: }
1444:
1445: void
1446: send_unicast_multihop_request(struct neighbour *neigh,
1447: const unsigned char *prefix, unsigned char plen,
1448: unsigned short seqno, const unsigned char *id,
1449: unsigned short hop_count)
1450: {
1451: int rc, v4, pb, len;
1452:
1453: /* Make sure any buffered updates go out before this request. */
1454: flushupdates(neigh->ifp);
1455:
1456: debugf(BABEL_DEBUG_COMMON,"Sending multi-hop request to %s for %s (%d hops).",
1457: format_address(neigh->address),
1458: format_prefix(prefix, plen), hop_count);
1459: v4 = plen >= 96 && v4mapped(prefix);
1460: pb = v4 ? ((plen - 96) + 7) / 8 : (plen + 7) / 8;
1461: len = 6 + 8 + pb;
1462:
1463: rc = start_unicast_message(neigh, MESSAGE_MH_REQUEST, len);
1464: if(rc < 0) return;
1465: accumulate_unicast_byte(neigh, v4 ? 1 : 2);
1466: accumulate_unicast_byte(neigh, v4 ? plen - 96 : plen);
1467: accumulate_unicast_short(neigh, seqno);
1468: accumulate_unicast_byte(neigh, hop_count);
1469: accumulate_unicast_byte(neigh, 0);
1470: accumulate_unicast_bytes(neigh, id, 8);
1471: if(prefix) {
1472: if(v4)
1473: accumulate_unicast_bytes(neigh, prefix + 12, pb);
1474: else
1475: accumulate_unicast_bytes(neigh, prefix, pb);
1476: }
1477: end_unicast_message(neigh, MESSAGE_MH_REQUEST, len);
1478: }
1479:
1480: void
1481: send_request_resend(struct neighbour *neigh,
1482: const unsigned char *prefix, unsigned char plen,
1483: unsigned short seqno, unsigned char *id)
1484: {
1485: if(neigh)
1486: send_unicast_multihop_request(neigh, prefix, plen, seqno, id, 127);
1487: else
1488: send_multihop_request(NULL, prefix, plen, seqno, id, 127);
1489:
1490: record_resend(RESEND_REQUEST, prefix, plen, seqno, id,
1491: neigh ? neigh->ifp : NULL, resend_delay);
1492: }
1493:
1494: void
1495: handle_request(struct neighbour *neigh, const unsigned char *prefix,
1496: unsigned char plen, unsigned char hop_count,
1497: unsigned short seqno, const unsigned char *id)
1498: {
1499: struct xroute *xroute;
1500: struct babel_route *route;
1501: struct neighbour *successor = NULL;
1502:
1503: xroute = find_xroute(prefix, plen);
1504: route = find_installed_route(prefix, plen);
1505:
1506: if(xroute && (!route || xroute->metric <= kernel_metric)) {
1507: if(hop_count > 0 && memcmp(id, myid, 8) == 0) {
1508: if(seqno_compare(seqno, myseqno) > 0) {
1509: if(seqno_minus(seqno, myseqno) > 100) {
1510: /* Hopelessly out-of-date request */
1511: return;
1512: }
1513: update_myseqno();
1514: }
1515: }
1516: send_update(neigh->ifp, 1, prefix, plen);
1517: return;
1518: }
1519:
1520: if(route &&
1521: (memcmp(id, route->src->id, 8) != 0 ||
1522: seqno_compare(seqno, route->seqno) <= 0)) {
1523: send_update(neigh->ifp, 1, prefix, plen);
1524: return;
1525: }
1526:
1527: if(hop_count <= 1)
1528: return;
1529:
1530: if(route && memcmp(id, route->src->id, 8) == 0 &&
1531: seqno_minus(seqno, route->seqno) > 100) {
1532: /* Hopelessly out-of-date */
1533: return;
1534: }
1535:
1536: if(request_redundant(neigh->ifp, prefix, plen, seqno, id))
1537: return;
1538:
1539: /* Let's try to forward this request. */
1540: if(route && route_metric(route) < INFINITY)
1541: successor = route->neigh;
1542:
1543: if(!successor || successor == neigh) {
1544: /* We were about to forward a request to its requestor. Try to
1545: find a different neighbour to forward the request to. */
1546: struct babel_route *other_route;
1547:
1548: other_route = find_best_route(prefix, plen, 0, neigh);
1549: if(other_route && route_metric(other_route) < INFINITY)
1550: successor = other_route->neigh;
1551: }
1552:
1553: if(!successor || successor == neigh)
1554: /* Give up */
1555: return;
1556:
1557: send_unicast_multihop_request(successor, prefix, plen, seqno, id,
1558: hop_count - 1);
1559: record_resend(RESEND_REQUEST, prefix, plen, seqno, id,
1560: neigh->ifp, 0);
1561: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to message.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