Annotation of embedaddon/bird/proto/babel/packets.c, revision 1.1.1.1
1.1 misho 1: /*
2: * BIRD -- The Babel protocol
3: *
4: * Copyright (c) 2015--2016 Toke Hoiland-Jorgensen
5: *
6: * Can be freely distributed and used under the terms of the GNU GPL.
7: *
8: * This file contains the packet and TLV handling code for the protocol.
9: */
10:
11: #include "babel.h"
12:
13:
14: struct babel_pkt_header {
15: u8 magic;
16: u8 version;
17: u16 length;
18: } PACKED;
19:
20: struct babel_tlv {
21: u8 type;
22: u8 length;
23: u8 value[0];
24: } PACKED;
25:
26: struct babel_tlv_ack_req {
27: u8 type;
28: u8 length;
29: u16 reserved;
30: u16 nonce;
31: u16 interval;
32: } PACKED;
33:
34: struct babel_tlv_ack {
35: u8 type;
36: u8 length;
37: u16 nonce;
38: } PACKED;
39:
40: struct babel_tlv_hello {
41: u8 type;
42: u8 length;
43: u16 reserved;
44: u16 seqno;
45: u16 interval;
46: } PACKED;
47:
48: struct babel_tlv_ihu {
49: u8 type;
50: u8 length;
51: u8 ae;
52: u8 reserved;
53: u16 rxcost;
54: u16 interval;
55: u8 addr[0];
56: } PACKED;
57:
58: struct babel_tlv_router_id {
59: u8 type;
60: u8 length;
61: u16 reserved;
62: u64 router_id;
63: } PACKED;
64:
65: struct babel_tlv_next_hop {
66: u8 type;
67: u8 length;
68: u8 ae;
69: u8 reserved;
70: u8 addr[0];
71: } PACKED;
72:
73: struct babel_tlv_update {
74: u8 type;
75: u8 length;
76: u8 ae;
77: u8 flags;
78: u8 plen;
79: u8 omitted;
80: u16 interval;
81: u16 seqno;
82: u16 metric;
83: u8 addr[0];
84: } PACKED;
85:
86: struct babel_tlv_route_request {
87: u8 type;
88: u8 length;
89: u8 ae;
90: u8 plen;
91: u8 addr[0];
92: } PACKED;
93:
94: struct babel_tlv_seqno_request {
95: u8 type;
96: u8 length;
97: u8 ae;
98: u8 plen;
99: u16 seqno;
100: u8 hop_count;
101: u8 reserved;
102: u64 router_id;
103: u8 addr[0];
104: } PACKED;
105:
106:
107: #define BABEL_FLAG_DEF_PREFIX 0x80
108: #define BABEL_FLAG_ROUTER_ID 0x40
109:
110:
111: struct babel_parse_state {
112: struct babel_proto *proto;
113: struct babel_iface *ifa;
114: ip_addr saddr;
115: ip_addr next_hop;
116: u64 router_id; /* Router ID used in subsequent updates */
117: u8 def_ip6_prefix[16]; /* Implicit IPv6 prefix in network order */
118: u8 def_ip4_prefix[4]; /* Implicit IPv4 prefix in network order */
119: u8 router_id_seen; /* router_id field is valid */
120: u8 def_ip6_prefix_seen; /* def_ip6_prefix is valid */
121: u8 def_ip4_prefix_seen; /* def_ip4_prefix is valid */
122: };
123:
124: enum parse_result {
125: PARSE_SUCCESS,
126: PARSE_ERROR,
127: PARSE_IGNORE,
128: };
129:
130: struct babel_write_state {
131: u64 router_id;
132: u8 router_id_seen;
133: // ip_addr next_hop;
134: };
135:
136:
137: #define DROP(DSC,VAL) do { err_dsc = DSC; err_val = VAL; goto drop; } while(0)
138: #define DROP1(DSC) do { err_dsc = DSC; goto drop; } while(0)
139: #define LOG_PKT(msg, args...) \
140: log_rl(&p->log_pkt_tbf, L_REMOTE "%s: " msg, p->p.name, args)
141:
142: #define FIRST_TLV(p) ((struct babel_tlv *) (((struct babel_pkt_header *) p) + 1))
143: #define NEXT_TLV(t) ((struct babel_tlv *) (((byte *) t) + TLV_LENGTH(t)))
144: #define TLV_LENGTH(t) (t->type == BABEL_TLV_PAD1 ? 1 : t->length + sizeof(struct babel_tlv))
145: #define TLV_OPT_LENGTH(t) (t->length + sizeof(struct babel_tlv) - sizeof(*t))
146: #define TLV_HDR(tlv,t,l) ({ tlv->type = t; tlv->length = l - sizeof(struct babel_tlv); })
147: #define TLV_HDR0(tlv,t) TLV_HDR(tlv, t, tlv_data[t].min_length)
148:
149: #define BYTES(n) ((((uint) n) + 7) / 8)
150:
151: static inline u16
152: get_time16(const void *p)
153: {
154: u16 v = get_u16(p) / BABEL_TIME_UNITS;
155: return MAX(1, v);
156: }
157:
158: static inline void
159: put_time16(void *p, u16 v)
160: {
161: put_u16(p, v * BABEL_TIME_UNITS);
162: }
163:
164: static inline ip6_addr
165: get_ip6_px(const void *p, uint plen)
166: {
167: ip6_addr addr = IPA_NONE;
168: memcpy(&addr, p, BYTES(plen));
169: return ip6_ntoh(addr);
170: }
171:
172: static inline void
173: put_ip6_px(void *p, ip6_addr addr, uint plen)
174: {
175: addr = ip6_hton(addr);
176: memcpy(p, &addr, BYTES(plen));
177: }
178:
179: static inline ip6_addr
180: get_ip6_ll(const void *p)
181: {
182: return ip6_build(0xfe800000, 0, get_u32(p+0), get_u32(p+4));
183: }
184:
185: static inline void
186: put_ip6_ll(void *p, ip6_addr addr)
187: {
188: put_u32(p+0, _I2(addr));
189: put_u32(p+4, _I3(addr));
190: }
191:
192:
193: /*
194: * TLV read/write functions
195: */
196:
197: static int babel_read_ack_req(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
198: static int babel_read_hello(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
199: static int babel_read_ihu(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
200: static int babel_read_router_id(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
201: static int babel_read_next_hop(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
202: static int babel_read_update(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
203: static int babel_read_route_request(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
204: static int babel_read_seqno_request(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
205:
206: static uint babel_write_ack(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
207: static uint babel_write_hello(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
208: static uint babel_write_ihu(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
209: static uint babel_write_update(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
210: static uint babel_write_route_request(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
211: static uint babel_write_seqno_request(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
212:
213: struct babel_tlv_data {
214: u8 min_length;
215: int (*read_tlv)(struct babel_tlv *hdr, union babel_msg *m, struct babel_parse_state *state);
216: uint (*write_tlv)(struct babel_tlv *hdr, union babel_msg *m, struct babel_write_state *state, uint max_len);
217: void (*handle_tlv)(union babel_msg *m, struct babel_iface *ifa);
218: };
219:
220: static const struct babel_tlv_data tlv_data[BABEL_TLV_MAX] = {
221: [BABEL_TLV_ACK_REQ] = {
222: sizeof(struct babel_tlv_ack_req),
223: babel_read_ack_req,
224: NULL,
225: babel_handle_ack_req
226: },
227: [BABEL_TLV_ACK] = {
228: sizeof(struct babel_tlv_ack),
229: NULL,
230: babel_write_ack,
231: NULL
232: },
233: [BABEL_TLV_HELLO] = {
234: sizeof(struct babel_tlv_hello),
235: babel_read_hello,
236: babel_write_hello,
237: babel_handle_hello
238: },
239: [BABEL_TLV_IHU] = {
240: sizeof(struct babel_tlv_ihu),
241: babel_read_ihu,
242: babel_write_ihu,
243: babel_handle_ihu
244: },
245: [BABEL_TLV_ROUTER_ID] = {
246: sizeof(struct babel_tlv_router_id),
247: babel_read_router_id,
248: NULL,
249: NULL
250: },
251: [BABEL_TLV_NEXT_HOP] = {
252: sizeof(struct babel_tlv_next_hop),
253: babel_read_next_hop,
254: NULL,
255: NULL
256: },
257: [BABEL_TLV_UPDATE] = {
258: sizeof(struct babel_tlv_update),
259: babel_read_update,
260: babel_write_update,
261: babel_handle_update
262: },
263: [BABEL_TLV_ROUTE_REQUEST] = {
264: sizeof(struct babel_tlv_route_request),
265: babel_read_route_request,
266: babel_write_route_request,
267: babel_handle_route_request
268: },
269: [BABEL_TLV_SEQNO_REQUEST] = {
270: sizeof(struct babel_tlv_seqno_request),
271: babel_read_seqno_request,
272: babel_write_seqno_request,
273: babel_handle_seqno_request
274: },
275: };
276:
277: static int
278: babel_read_ack_req(struct babel_tlv *hdr, union babel_msg *m,
279: struct babel_parse_state *state)
280: {
281: struct babel_tlv_ack_req *tlv = (void *) hdr;
282: struct babel_msg_ack_req *msg = &m->ack_req;
283:
284: msg->type = BABEL_TLV_ACK_REQ;
285: msg->nonce = get_u16(&tlv->nonce);
286: msg->interval = get_time16(&tlv->interval);
287: msg->sender = state->saddr;
288:
289: if (!msg->interval)
290: return PARSE_ERROR;
291:
292: return PARSE_SUCCESS;
293: }
294:
295: static uint
296: babel_write_ack(struct babel_tlv *hdr, union babel_msg *m,
297: struct babel_write_state *state UNUSED, uint max_len UNUSED)
298: {
299: struct babel_tlv_ack *tlv = (void *) hdr;
300: struct babel_msg_ack *msg = &m->ack;
301:
302: TLV_HDR0(tlv, BABEL_TLV_ACK);
303: put_u16(&tlv->nonce, msg->nonce);
304:
305: return sizeof(struct babel_tlv_ack);
306: }
307:
308: static int
309: babel_read_hello(struct babel_tlv *hdr, union babel_msg *m,
310: struct babel_parse_state *state)
311: {
312: struct babel_tlv_hello *tlv = (void *) hdr;
313: struct babel_msg_hello *msg = &m->hello;
314:
315: msg->type = BABEL_TLV_HELLO;
316: msg->seqno = get_u16(&tlv->seqno);
317: msg->interval = get_time16(&tlv->interval);
318: msg->sender = state->saddr;
319:
320: return PARSE_SUCCESS;
321: }
322:
323: static uint
324: babel_write_hello(struct babel_tlv *hdr, union babel_msg *m,
325: struct babel_write_state *state UNUSED, uint max_len UNUSED)
326: {
327: struct babel_tlv_hello *tlv = (void *) hdr;
328: struct babel_msg_hello *msg = &m->hello;
329:
330: TLV_HDR0(tlv, BABEL_TLV_HELLO);
331: put_u16(&tlv->seqno, msg->seqno);
332: put_time16(&tlv->interval, msg->interval);
333:
334: return sizeof(struct babel_tlv_hello);
335: }
336:
337: static int
338: babel_read_ihu(struct babel_tlv *hdr, union babel_msg *m,
339: struct babel_parse_state *state)
340: {
341: struct babel_tlv_ihu *tlv = (void *) hdr;
342: struct babel_msg_ihu *msg = &m->ihu;
343:
344: msg->type = BABEL_TLV_IHU;
345: msg->ae = tlv->ae;
346: msg->rxcost = get_u16(&tlv->rxcost);
347: msg->interval = get_time16(&tlv->interval);
348: msg->addr = IPA_NONE;
349: msg->sender = state->saddr;
350:
351: if (msg->ae >= BABEL_AE_MAX)
352: return PARSE_IGNORE;
353:
354: // We handle link-local IPs. In every other case, the addr field will be 0 but
355: // validation will succeed. The handler takes care of these cases.
356: if (msg->ae == BABEL_AE_IP6_LL)
357: {
358: if (TLV_OPT_LENGTH(tlv) < 8)
359: return PARSE_ERROR;
360:
361: msg->addr = ipa_from_ip6(get_ip6_ll(&tlv->addr));
362: }
363:
364: return PARSE_SUCCESS;
365: }
366:
367: static uint
368: babel_write_ihu(struct babel_tlv *hdr, union babel_msg *m,
369: struct babel_write_state *state UNUSED, uint max_len)
370: {
371: struct babel_tlv_ihu *tlv = (void *) hdr;
372: struct babel_msg_ihu *msg = &m->ihu;
373:
374: if (ipa_is_link_local(msg->addr) && max_len < sizeof(struct babel_tlv_ihu) + 8)
375: return 0;
376:
377: TLV_HDR0(tlv, BABEL_TLV_IHU);
378: put_u16(&tlv->rxcost, msg->rxcost);
379: put_time16(&tlv->interval, msg->interval);
380:
381: if (!ipa_is_link_local(msg->addr))
382: {
383: tlv->ae = BABEL_AE_WILDCARD;
384: return sizeof(struct babel_tlv_ihu);
385: }
386: put_ip6_ll(&tlv->addr, msg->addr);
387: tlv->ae = BABEL_AE_IP6_LL;
388: hdr->length += 8;
389: return sizeof(struct babel_tlv_ihu) + 8;
390: }
391:
392: static int
393: babel_read_router_id(struct babel_tlv *hdr, union babel_msg *m UNUSED,
394: struct babel_parse_state *state)
395: {
396: struct babel_tlv_router_id *tlv = (void *) hdr;
397:
398: state->router_id = get_u64(&tlv->router_id);
399: state->router_id_seen = 1;
400:
401: return PARSE_IGNORE;
402: }
403:
404: /* This is called directly from babel_write_update() */
405: static uint
406: babel_write_router_id(struct babel_tlv *hdr, u64 router_id,
407: struct babel_write_state *state, uint max_len UNUSED)
408: {
409: struct babel_tlv_router_id *tlv = (void *) hdr;
410:
411: /* We still assume that first min_length bytes are available and zeroed */
412:
413: TLV_HDR0(tlv, BABEL_TLV_ROUTER_ID);
414: put_u64(&tlv->router_id, router_id);
415:
416: state->router_id = router_id;
417: state->router_id_seen = 1;
418:
419: return sizeof(struct babel_tlv_router_id);
420: }
421:
422: static int
423: babel_read_next_hop(struct babel_tlv *hdr, union babel_msg *m UNUSED,
424: struct babel_parse_state *state)
425: {
426: struct babel_tlv_next_hop *tlv = (void *) hdr;
427:
428: switch (tlv->ae)
429: {
430: case BABEL_AE_WILDCARD:
431: return PARSE_ERROR;
432:
433: case BABEL_AE_IP4:
434: /* TODO */
435: return PARSE_IGNORE;
436:
437: case BABEL_AE_IP6:
438: if (TLV_OPT_LENGTH(tlv) < sizeof(ip6_addr))
439: return PARSE_ERROR;
440:
441: state->next_hop = ipa_from_ip6(get_ip6(&tlv->addr));
442: return PARSE_IGNORE;
443:
444: case BABEL_AE_IP6_LL:
445: if (TLV_OPT_LENGTH(tlv) < 8)
446: return PARSE_ERROR;
447:
448: state->next_hop = ipa_from_ip6(get_ip6_ll(&tlv->addr));
449: return PARSE_IGNORE;
450:
451: default:
452: return PARSE_IGNORE;
453: }
454:
455: return PARSE_IGNORE;
456: }
457:
458: static int
459: babel_read_update(struct babel_tlv *hdr, union babel_msg *m,
460: struct babel_parse_state *state)
461: {
462: struct babel_tlv_update *tlv = (void *) hdr;
463: struct babel_msg_update *msg = &m->update;
464:
465: msg->type = BABEL_TLV_UPDATE;
466: msg->interval = get_time16(&tlv->interval);
467: msg->seqno = get_u16(&tlv->seqno);
468: msg->metric = get_u16(&tlv->metric);
469:
470: /* Length of received prefix data without omitted part */
471: int len = BYTES(tlv->plen) - (int) tlv->omitted;
472: u8 buf[16] = {};
473:
474: if ((len < 0) || ((uint) len > TLV_OPT_LENGTH(tlv)))
475: return PARSE_ERROR;
476:
477: switch (tlv->ae)
478: {
479: case BABEL_AE_WILDCARD:
480: if (tlv->plen > 0)
481: return PARSE_ERROR;
482:
483: msg->wildcard = 1;
484: break;
485:
486: case BABEL_AE_IP4:
487: /* TODO */
488: return PARSE_IGNORE;
489:
490: case BABEL_AE_IP6:
491: if (tlv->plen > MAX_PREFIX_LENGTH)
492: return PARSE_ERROR;
493:
494: /* Cannot omit data if there is no saved prefix */
495: if (tlv->omitted && !state->def_ip6_prefix_seen)
496: return PARSE_ERROR;
497:
498: /* Merge saved prefix and received prefix parts */
499: memcpy(buf, state->def_ip6_prefix, tlv->omitted);
500: memcpy(buf + tlv->omitted, tlv->addr, len);
501:
502: msg->plen = tlv->plen;
503: msg->prefix = ipa_from_ip6(get_ip6(buf));
504:
505: if (tlv->flags & BABEL_FLAG_DEF_PREFIX)
506: {
507: put_ip6(state->def_ip6_prefix, msg->prefix);
508: state->def_ip6_prefix_seen = 1;
509: }
510:
511: if (tlv->flags & BABEL_FLAG_ROUTER_ID)
512: {
513: state->router_id = ((u64) _I2(msg->prefix)) << 32 | _I3(msg->prefix);
514: state->router_id_seen = 1;
515: }
516: break;
517:
518: case BABEL_AE_IP6_LL:
519: /* ??? */
520: return PARSE_IGNORE;
521:
522: default:
523: return PARSE_IGNORE;
524: }
525:
526: /* Update must have Router ID, unless it is retraction */
527: if (!state->router_id_seen && (msg->metric != BABEL_INFINITY))
528: {
529: DBG("Babel: No router ID seen before update\n");
530: return PARSE_ERROR;
531: }
532:
533: msg->router_id = state->router_id;
534: msg->next_hop = state->next_hop;
535: msg->sender = state->saddr;
536:
537: return PARSE_SUCCESS;
538: }
539:
540: static uint
541: babel_write_update(struct babel_tlv *hdr, union babel_msg *m,
542: struct babel_write_state *state, uint max_len)
543: {
544: struct babel_tlv_update *tlv = (void *) hdr;
545: struct babel_msg_update *msg = &m->update;
546: uint len0 = 0;
547:
548: /*
549: * When needed, we write Router-ID TLV before Update TLV and return size of
550: * both of them. There is enough space for the Router-ID TLV, because
551: * sizeof(struct babel_tlv_router_id) == sizeof(struct babel_tlv_update).
552: *
553: * Router ID is not used for retractions, so do not us it in such case.
554: */
555: if ((msg->metric < BABEL_INFINITY) &&
556: (!state->router_id_seen || (msg->router_id != state->router_id)))
557: {
558: len0 = babel_write_router_id(hdr, msg->router_id, state, max_len);
559: tlv = (struct babel_tlv_update *) NEXT_TLV(tlv);
560: }
561:
562: uint len = sizeof(struct babel_tlv_update) + BYTES(msg->plen);
563:
564: if (len0 + len > max_len)
565: return 0;
566:
567: memset(tlv, 0, sizeof(struct babel_tlv_update));
568: TLV_HDR(tlv, BABEL_TLV_UPDATE, len);
569:
570: if (msg->wildcard)
571: {
572: tlv->ae = BABEL_AE_WILDCARD;
573: tlv->plen = 0;
574: }
575: else
576: {
577: tlv->ae = BABEL_AE_IP6;
578: tlv->plen = msg->plen;
579: put_ip6_px(tlv->addr, msg->prefix, msg->plen);
580: }
581:
582: put_time16(&tlv->interval, msg->interval);
583: put_u16(&tlv->seqno, msg->seqno);
584: put_u16(&tlv->metric, msg->metric);
585:
586: return len0 + len;
587: }
588:
589: static int
590: babel_read_route_request(struct babel_tlv *hdr, union babel_msg *m,
591: struct babel_parse_state *state UNUSED)
592: {
593: struct babel_tlv_route_request *tlv = (void *) hdr;
594: struct babel_msg_route_request *msg = &m->route_request;
595:
596: msg->type = BABEL_TLV_ROUTE_REQUEST;
597:
598: switch (tlv->ae)
599: {
600: case BABEL_AE_WILDCARD:
601: /* Wildcard requests must have plen 0 */
602: if (tlv->plen > 0)
603: return PARSE_ERROR;
604:
605: msg->full = 1;
606: return PARSE_SUCCESS;
607:
608: case BABEL_AE_IP4:
609: /* TODO */
610: return PARSE_IGNORE;
611:
612: case BABEL_AE_IP6:
613: if (tlv->plen > MAX_PREFIX_LENGTH)
614: return PARSE_ERROR;
615:
616: if (TLV_OPT_LENGTH(tlv) < BYTES(tlv->plen))
617: return PARSE_ERROR;
618:
619: msg->plen = tlv->plen;
620: msg->prefix = get_ip6_px(tlv->addr, tlv->plen);
621: return PARSE_SUCCESS;
622:
623: case BABEL_AE_IP6_LL:
624: return PARSE_ERROR;
625:
626: default:
627: return PARSE_IGNORE;
628: }
629:
630: return PARSE_IGNORE;
631: }
632:
633: static uint
634: babel_write_route_request(struct babel_tlv *hdr, union babel_msg *m,
635: struct babel_write_state *state UNUSED, uint max_len)
636: {
637: struct babel_tlv_route_request *tlv = (void *) hdr;
638: struct babel_msg_route_request *msg = &m->route_request;
639:
640: uint len = sizeof(struct babel_tlv_route_request) + BYTES(msg->plen);
641:
642: if (len > max_len)
643: return 0;
644:
645: TLV_HDR(tlv, BABEL_TLV_ROUTE_REQUEST, len);
646:
647: if (msg->full)
648: {
649: tlv->ae = BABEL_AE_WILDCARD;
650: tlv->plen = 0;
651: }
652: else
653: {
654: tlv->ae = BABEL_AE_IP6;
655: tlv->plen = msg->plen;
656: put_ip6_px(tlv->addr, msg->prefix, msg->plen);
657: }
658:
659: return len;
660: }
661:
662: static int
663: babel_read_seqno_request(struct babel_tlv *hdr, union babel_msg *m,
664: struct babel_parse_state *state)
665: {
666: struct babel_tlv_seqno_request *tlv = (void *) hdr;
667: struct babel_msg_seqno_request *msg = &m->seqno_request;
668:
669: msg->type = BABEL_TLV_SEQNO_REQUEST;
670: msg->seqno = get_u16(&tlv->seqno);
671: msg->hop_count = tlv->hop_count;
672: msg->router_id = get_u64(&tlv->router_id);
673: msg->sender = state->saddr;
674:
675: if (tlv->hop_count == 0)
676: return PARSE_ERROR;
677:
678: switch (tlv->ae)
679: {
680: case BABEL_AE_WILDCARD:
681: return PARSE_ERROR;
682:
683: case BABEL_AE_IP4:
684: /* TODO */
685: return PARSE_IGNORE;
686:
687: case BABEL_AE_IP6:
688: if (tlv->plen > MAX_PREFIX_LENGTH)
689: return PARSE_ERROR;
690:
691: if (TLV_OPT_LENGTH(tlv) < BYTES(tlv->plen))
692: return PARSE_ERROR;
693:
694: msg->plen = tlv->plen;
695: msg->prefix = get_ip6_px(tlv->addr, tlv->plen);
696: return PARSE_SUCCESS;
697:
698: case BABEL_AE_IP6_LL:
699: return PARSE_ERROR;
700:
701: default:
702: return PARSE_IGNORE;
703: }
704:
705: return PARSE_IGNORE;
706: }
707:
708: static uint
709: babel_write_seqno_request(struct babel_tlv *hdr, union babel_msg *m,
710: struct babel_write_state *state UNUSED, uint max_len)
711: {
712: struct babel_tlv_seqno_request *tlv = (void *) hdr;
713: struct babel_msg_seqno_request *msg = &m->seqno_request;
714:
715: uint len = sizeof(struct babel_tlv_seqno_request) + BYTES(msg->plen);
716:
717: if (len > max_len)
718: return 0;
719:
720: TLV_HDR(tlv, BABEL_TLV_SEQNO_REQUEST, len);
721: tlv->ae = BABEL_AE_IP6;
722: tlv->plen = msg->plen;
723: put_u16(&tlv->seqno, msg->seqno);
724: tlv->hop_count = msg->hop_count;
725: put_u64(&tlv->router_id, msg->router_id);
726: put_ip6_px(tlv->addr, msg->prefix, msg->plen);
727:
728: return len;
729: }
730:
731: static inline int
732: babel_read_tlv(struct babel_tlv *hdr,
733: union babel_msg *msg,
734: struct babel_parse_state *state)
735: {
736: if ((hdr->type <= BABEL_TLV_PADN) ||
737: (hdr->type >= BABEL_TLV_MAX) ||
738: !tlv_data[hdr->type].read_tlv)
739: return PARSE_IGNORE;
740:
741: if (TLV_LENGTH(hdr) < tlv_data[hdr->type].min_length)
742: return PARSE_ERROR;
743:
744: memset(msg, 0, sizeof(*msg));
745: return tlv_data[hdr->type].read_tlv(hdr, msg, state);
746: }
747:
748: static uint
749: babel_write_tlv(struct babel_tlv *hdr,
750: union babel_msg *msg,
751: struct babel_write_state *state,
752: uint max_len)
753: {
754: if ((msg->type <= BABEL_TLV_PADN) ||
755: (msg->type >= BABEL_TLV_MAX) ||
756: !tlv_data[msg->type].write_tlv)
757: return 0;
758:
759: if (tlv_data[msg->type].min_length > max_len)
760: return 0;
761:
762: memset(hdr, 0, tlv_data[msg->type].min_length);
763: return tlv_data[msg->type].write_tlv(hdr, msg, state, max_len);
764: }
765:
766:
767: /*
768: * Packet RX/TX functions
769: */
770:
771: static int
772: babel_send_to(struct babel_iface *ifa, ip_addr dest)
773: {
774: sock *sk = ifa->sk;
775: struct babel_pkt_header *hdr = (void *) sk->tbuf;
776: int len = get_u16(&hdr->length) + sizeof(struct babel_pkt_header);
777:
778: DBG("Babel: Sending %d bytes to %I\n", len, dest);
779: return sk_send_to(sk, len, dest, 0);
780: }
781:
782: /**
783: * babel_write_queue - Write a TLV queue to a transmission buffer
784: * @ifa: Interface holding the transmission buffer
785: * @queue: TLV queue to write (containing internal-format TLVs)
786: *
787: * This function writes a packet to the interface transmission buffer with as
788: * many TLVs from the &queue as will fit in the buffer. It returns the number of
789: * bytes written (NOT counting the packet header). The function is called by
790: * babel_send_queue() and babel_send_unicast() to construct packets for
791: * transmission, and uses per-TLV helper functions to convert the
792: * internal-format TLVs to their wire representations.
793: *
794: * The TLVs in the queue are freed after they are written to the buffer.
795: */
796: static uint
797: babel_write_queue(struct babel_iface *ifa, list *queue)
798: {
799: struct babel_proto *p = ifa->proto;
800: struct babel_write_state state = {};
801:
802: if (EMPTY_LIST(*queue))
803: return 0;
804:
805: byte *pos = ifa->sk->tbuf;
806: byte *end = pos + ifa->tx_length;
807:
808: struct babel_pkt_header *pkt = (void *) pos;
809: pkt->magic = BABEL_MAGIC;
810: pkt->version = BABEL_VERSION;
811: pkt->length = 0;
812: pos += sizeof(struct babel_pkt_header);
813:
814: struct babel_msg_node *msg;
815: WALK_LIST_FIRST(msg, *queue)
816: {
817: if (pos >= end)
818: break;
819:
820: int len = babel_write_tlv((struct babel_tlv *) pos, &msg->msg, &state, end - pos);
821:
822: if (!len)
823: break;
824:
825: pos += len;
826: rem_node(NODE msg);
827: sl_free(p->msg_slab, msg);
828: }
829:
830: uint plen = pos - (byte *) pkt;
831: put_u16(&pkt->length, plen - sizeof(struct babel_pkt_header));
832:
833: return plen;
834: }
835:
836: void
837: babel_send_queue(void *arg)
838: {
839: struct babel_iface *ifa = arg;
840: while ((babel_write_queue(ifa, &ifa->msg_queue) > 0) &&
841: (babel_send_to(ifa, IP6_BABEL_ROUTERS) > 0));
842: }
843:
844: static inline void
845: babel_kick_queue(struct babel_iface *ifa)
846: {
847: /*
848: * Only schedule send event if there is not already data in the socket buffer.
849: * Otherwise we may overwrite the data already in the buffer.
850: */
851:
852: if ((ifa->sk->tpos == ifa->sk->tbuf) && !ev_active(ifa->send_event))
853: ev_schedule(ifa->send_event);
854: }
855:
856: /**
857: * babel_send_unicast - send a single TLV via unicast to a destination
858: * @msg: TLV to send
859: * @ifa: Interface to send via
860: * @dest: Destination of the TLV
861: *
862: * This function is used to send a single TLV via unicast to a designated
863: * receiver. This is used for replying to certain incoming requests, and for
864: * sending unicast requests to refresh routes before they expire.
865: */
866: void
867: babel_send_unicast(union babel_msg *msg, struct babel_iface *ifa, ip_addr dest)
868: {
869: struct babel_proto *p = ifa->proto;
870: struct babel_msg_node *msgn = sl_alloc(p->msg_slab);
871: list queue;
872:
873: msgn->msg = *msg;
874: init_list(&queue);
875: add_tail(&queue, NODE msgn);
876: babel_write_queue(ifa, &queue);
877: babel_send_to(ifa, dest);
878:
879: /* We could overwrite waiting packet here, we may have to kick TX queue */
880: if (!EMPTY_LIST(ifa->msg_queue))
881: babel_kick_queue(ifa);
882: }
883:
884: /**
885: * babel_enqueue - enqueue a TLV for transmission on an interface
886: * @msg: TLV to enqueue (in internal TLV format)
887: * @ifa: Interface to enqueue to
888: *
889: * This function is called to enqueue a TLV for subsequent transmission on an
890: * interface. The transmission event is triggered whenever a TLV is enqueued;
891: * this ensures that TLVs will be transmitted in a timely manner, but that TLVs
892: * which are enqueued in rapid succession can be transmitted together in one
893: * packet.
894: */
895: void
896: babel_enqueue(union babel_msg *msg, struct babel_iface *ifa)
897: {
898: struct babel_proto *p = ifa->proto;
899: struct babel_msg_node *msgn = sl_alloc(p->msg_slab);
900: msgn->msg = *msg;
901: add_tail(&ifa->msg_queue, NODE msgn);
902: babel_kick_queue(ifa);
903: }
904:
905: /**
906: * babel_process_packet - process incoming data packet
907: * @pkt: Pointer to the packet data
908: * @len: Length of received packet
909: * @saddr: Address of packet sender
910: * @ifa: Interface packet was received on.
911: *
912: * This function is the main processing hook of incoming Babel packets. It
913: * checks that the packet header is well-formed, then processes the TLVs
914: * contained in the packet. This is done in two passes: First all TLVs are
915: * parsed into the internal TLV format. If a TLV parser fails, processing of the
916: * rest of the packet is aborted.
917: *
918: * After the parsing step, the TLV handlers are called for each parsed TLV in
919: * order.
920: */
921: static void
922: babel_process_packet(struct babel_pkt_header *pkt, int len,
923: ip_addr saddr, struct babel_iface *ifa)
924: {
925: struct babel_proto *p = ifa->proto;
926: struct babel_tlv *tlv;
927: struct babel_msg_node *msg;
928: list msgs;
929: int res;
930:
931: int plen = sizeof(struct babel_pkt_header) + get_u16(&pkt->length);
932: byte *pos;
933: byte *end = (byte *)pkt + plen;
934:
935: struct babel_parse_state state = {
936: .proto = p,
937: .ifa = ifa,
938: .saddr = saddr,
939: .next_hop = saddr,
940: };
941:
942: if ((pkt->magic != BABEL_MAGIC) || (pkt->version != BABEL_VERSION))
943: {
944: TRACE(D_PACKETS, "Strange packet from %I via %s - magic %d version %d",
945: saddr, ifa->iface->name, pkt->magic, pkt->version);
946: return;
947: }
948:
949: if (plen > len)
950: {
951: LOG_PKT("Bad packet from %I via %s - %s (%u)",
952: saddr, ifa->iface->name, "length mismatch", plen);
953: return;
954: }
955:
956: TRACE(D_PACKETS, "Packet received from %I via %s",
957: saddr, ifa->iface->name);
958:
959: init_list(&msgs);
960:
961: /* First pass through the packet TLV by TLV, parsing each into internal data
962: structures. */
963: for (tlv = FIRST_TLV(pkt);
964: (byte *)tlv < end;
965: tlv = NEXT_TLV(tlv))
966: {
967: /* Ugly special case */
968: if (tlv->type == BABEL_TLV_PAD1)
969: continue;
970:
971: /* The end of the common TLV header */
972: pos = (byte *)tlv + sizeof(struct babel_tlv);
973: if ((pos > end) || (pos + tlv->length > end))
974: {
975: LOG_PKT("Bad TLV from %I via %s type %d pos %d - framing error",
976: saddr, ifa->iface->name, tlv->type, (byte *)tlv - (byte *)pkt);
977: break;
978: }
979:
980: msg = sl_alloc(p->msg_slab);
981: res = babel_read_tlv(tlv, &msg->msg, &state);
982: if (res == PARSE_SUCCESS)
983: {
984: add_tail(&msgs, NODE msg);
985: }
986: else if (res == PARSE_IGNORE)
987: {
988: DBG("Babel: Ignoring TLV of type %d\n", tlv->type);
989: sl_free(p->msg_slab, msg);
990: }
991: else /* PARSE_ERROR */
992: {
993: LOG_PKT("Bad TLV from %I via %s type %d pos %d - parse error",
994: saddr, ifa->iface->name, tlv->type, (byte *)tlv - (byte *)pkt);
995: sl_free(p->msg_slab, msg);
996: break;
997: }
998: }
999:
1000: /* Parsing done, handle all parsed TLVs */
1001: WALK_LIST_FIRST(msg, msgs)
1002: {
1003: if (tlv_data[msg->msg.type].handle_tlv)
1004: tlv_data[msg->msg.type].handle_tlv(&msg->msg, ifa);
1005: rem_node(NODE msg);
1006: sl_free(p->msg_slab, msg);
1007: }
1008: }
1009:
1010: static void
1011: babel_err_hook(sock *sk, int err)
1012: {
1013: struct babel_iface *ifa = sk->data;
1014: struct babel_proto *p = ifa->proto;
1015:
1016: log(L_ERR "%s: Socket error on %s: %M", p->p.name, ifa->iface->name, err);
1017: /* FIXME: Drop queued TLVs here? */
1018: }
1019:
1020:
1021: static void
1022: babel_tx_hook(sock *sk)
1023: {
1024: struct babel_iface *ifa = sk->data;
1025:
1026: DBG("Babel: TX hook called (iface %s, src %I, dst %I)\n",
1027: sk->iface->name, sk->saddr, sk->daddr);
1028:
1029: babel_send_queue(ifa);
1030: }
1031:
1032:
1033: static int
1034: babel_rx_hook(sock *sk, uint len)
1035: {
1036: struct babel_iface *ifa = sk->data;
1037: struct babel_proto *p = ifa->proto;
1038: const char *err_dsc = NULL;
1039: uint err_val = 0;
1040:
1041: if (sk->lifindex != ifa->iface->index)
1042: return 1;
1043:
1044: DBG("Babel: RX hook called (iface %s, src %I, dst %I)\n",
1045: sk->iface->name, sk->faddr, sk->laddr);
1046:
1047: /* Silently ignore my own packets */
1048: if (ipa_equal(ifa->iface->addr->ip, sk->faddr))
1049: return 1;
1050:
1051: if (!ipa_is_link_local(sk->faddr))
1052: DROP1("wrong src address");
1053:
1054: if (sk->fport != ifa->cf->port)
1055: DROP("wrong src port", sk->fport);
1056:
1057: if (len < sizeof(struct babel_pkt_header))
1058: DROP("too short", len);
1059:
1060: if (sk->flags & SKF_TRUNCATED)
1061: DROP("truncated", len);
1062:
1063: babel_process_packet((struct babel_pkt_header *) sk->rbuf, len, sk->faddr, ifa);
1064: return 1;
1065:
1066: drop:
1067: LOG_PKT("Bad packet from %I via %s - %s (%u)",
1068: sk->faddr, sk->iface->name, err_dsc, err_val);
1069: return 1;
1070: }
1071:
1072: int
1073: babel_open_socket(struct babel_iface *ifa)
1074: {
1075: struct babel_proto *p = ifa->proto;
1076:
1077: sock *sk;
1078: sk = sk_new(ifa->pool);
1079: sk->type = SK_UDP;
1080: sk->sport = ifa->cf->port;
1081: sk->dport = ifa->cf->port;
1082: sk->iface = ifa->iface;
1083:
1084: sk->rx_hook = babel_rx_hook;
1085: sk->tx_hook = babel_tx_hook;
1086: sk->err_hook = babel_err_hook;
1087: sk->data = ifa;
1088:
1089: sk->tos = ifa->cf->tx_tos;
1090: sk->priority = ifa->cf->tx_priority;
1091: sk->ttl = 1;
1092: sk->flags = SKF_LADDR_RX;
1093:
1094: if (sk_open(sk) < 0)
1095: goto err;
1096:
1097: if (sk_setup_multicast(sk) < 0)
1098: goto err;
1099:
1100: if (sk_join_group(sk, IP6_BABEL_ROUTERS) < 0)
1101: goto err;
1102:
1103: ifa->sk = sk;
1104: return 1;
1105:
1106: err:
1107: sk_log_error(sk, p->p.name);
1108: rfree(sk);
1109: return 0;
1110: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to packets.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird / proto / babel