Annotation of embedaddon/bird/proto/rip/packets.c, revision 1.1.1.1
1.1 misho 1: /*
2: * BIRD -- Routing Information Protocol (RIP)
3: *
4: * (c) 1998--1999 Pavel Machek <pavel@ucw.cz>
5: * (c) 2004--2013 Ondrej Filip <feela@network.cz>
6: * (c) 2009--2015 Ondrej Zajicek <santiago@crfreenet.org>
7: * (c) 2009--2015 CZ.NIC z.s.p.o.
8: *
9: * Can be freely distributed and used under the terms of the GNU GPL.
10: */
11:
12: #include "rip.h"
13: #include "lib/mac.h"
14:
15:
16: #define RIP_CMD_REQUEST 1 /* want info */
17: #define RIP_CMD_RESPONSE 2 /* responding to request */
18:
19: #define RIP_BLOCK_LENGTH 20
20: #define RIP_PASSWD_LENGTH 16
21:
22: #define RIP_AF_IPV4 2
23: #define RIP_AF_AUTH 0xffff
24:
25:
26: /* RIP packet header */
27: struct rip_packet
28: {
29: u8 command;
30: u8 version;
31: u16 unused;
32: };
33:
34: /* RTE block for RIPv2 */
35: struct rip_block_v2
36: {
37: u16 family;
38: u16 tag;
39: ip4_addr network;
40: ip4_addr netmask;
41: ip4_addr next_hop;
42: u32 metric;
43: };
44:
45: /* RTE block for RIPng */
46: struct rip_block_ng
47: {
48: ip6_addr prefix;
49: u16 tag;
50: u8 pxlen;
51: u8 metric;
52: };
53:
54: /* Authentication block for RIPv2 */
55: struct rip_block_auth
56: {
57: u16 must_be_ffff;
58: u16 auth_type;
59: char password[0];
60: u16 packet_len;
61: u8 key_id;
62: u8 auth_len;
63: u32 seq_num;
64: u32 unused1;
65: u32 unused2;
66: };
67:
68: /* Authentication tail, RFC 4822 */
69: struct rip_auth_tail
70: {
71: u16 must_be_ffff;
72: u16 must_be_0001;
73: byte auth_data[0];
74: };
75:
76: /* Internal representation of RTE block data */
77: struct rip_block
78: {
79: ip_addr prefix;
80: int pxlen;
81: u32 metric;
82: u16 tag;
83: u16 no_af;
84: ip_addr next_hop;
85: };
86:
87:
88: #define DROP(DSC,VAL) do { err_dsc = DSC; err_val = VAL; goto drop; } while(0)
89: #define DROP1(DSC) do { err_dsc = DSC; goto drop; } while(0)
90: #define SKIP(DSC) do { err_dsc = DSC; goto skip; } while(0)
91:
92: #define LOG_PKT(msg, args...) \
93: log_rl(&p->log_pkt_tbf, L_REMOTE "%s: " msg, p->p.name, args)
94:
95: #define LOG_PKT_AUTH(msg, args...) \
96: log_rl(&p->log_pkt_tbf, L_AUTH "%s: " msg, p->p.name, args)
97:
98: #define LOG_RTE(msg, args...) \
99: log_rl(&p->log_rte_tbf, L_REMOTE "%s: " msg, p->p.name, args)
100:
101:
102: static inline void * rip_tx_buffer(struct rip_iface *ifa)
103: { return ifa->sk->tbuf; }
104:
105: static inline uint rip_pkt_hdrlen(struct rip_iface *ifa)
106: { return sizeof(struct rip_packet) + (ifa->cf->auth_type ? RIP_BLOCK_LENGTH : 0); }
107:
108: static inline void
109: rip_put_block(struct rip_proto *p UNUSED4 UNUSED6, byte *pos, struct rip_block *rte)
110: {
111: if (rip_is_v2(p))
112: {
113: struct rip_block_v2 *block = (void *) pos;
114: block->family = rte->no_af ? 0 : htons(RIP_AF_IPV4);
115: block->tag = htons(rte->tag);
116: block->network = ip4_hton(ipa_to_ip4(rte->prefix));
117: block->netmask = ip4_hton(ip4_mkmask(rte->pxlen));
118: block->next_hop = ip4_hton(ipa_to_ip4(rte->next_hop));
119: block->metric = htonl(rte->metric);
120: }
121: else /* RIPng */
122: {
123: struct rip_block_ng *block = (void *) pos;
124: block->prefix = ip6_hton(ipa_to_ip6(rte->prefix));
125: block->tag = htons(rte->tag);
126: block->pxlen = rte->pxlen;
127: block->metric = rte->metric;
128: }
129: }
130:
131: static inline void
132: rip_put_next_hop(struct rip_proto *p UNUSED, byte *pos, struct rip_block *rte UNUSED4)
133: {
134: struct rip_block_ng *block = (void *) pos;
135: block->prefix = ip6_hton(ipa_to_ip6(rte->next_hop));
136: block->tag = 0;
137: block->pxlen = 0;
138: block->metric = 0xff;
139: }
140:
141: static inline int
142: rip_get_block(struct rip_proto *p UNUSED4 UNUSED6, byte *pos, struct rip_block *rte)
143: {
144: if (rip_is_v2(p))
145: {
146: struct rip_block_v2 *block = (void *) pos;
147:
148: /* Skip blocks with strange AF, including authentication blocks */
149: if (block->family != (rte->no_af ? 0 : htons(RIP_AF_IPV4)))
150: return 0;
151:
152: rte->prefix = ipa_from_ip4(ip4_ntoh(block->network));
153: rte->pxlen = ip4_masklen(ip4_ntoh(block->netmask));
154: rte->metric = ntohl(block->metric);
155: rte->tag = ntohs(block->tag);
156: rte->next_hop = ipa_from_ip4(ip4_ntoh(block->next_hop));
157:
158: return 1;
159: }
160: else /* RIPng */
161: {
162: struct rip_block_ng *block = (void *) pos;
163:
164: /* Handle and skip next hop blocks */
165: if (block->metric == 0xff)
166: {
167: rte->next_hop = ipa_from_ip6(ip6_ntoh(block->prefix));
168: if (!ipa_is_link_local(rte->next_hop)) rte->next_hop = IPA_NONE;
169: return 0;
170: }
171:
172: rte->prefix = ipa_from_ip6(ip6_ntoh(block->prefix));
173: rte->pxlen = block->pxlen;
174: rte->metric = block->metric;
175: rte->tag = ntohs(block->tag);
176: /* rte->next_hop is deliberately kept unmodified */;
177:
178: return 1;
179: }
180: }
181:
182: static inline void
183: rip_update_csn(struct rip_proto *p UNUSED, struct rip_iface *ifa)
184: {
185: /*
186: * We update crypto sequence numbers at the beginning of update session to
187: * avoid issues with packet reordering, so packets inside one update session
188: * have the same CSN. We are using real time, but enforcing monotonicity.
189: */
190: if (ifa->cf->auth_type == RIP_AUTH_CRYPTO)
191: ifa->csn = (ifa->csn < (u32) now_real) ? (u32) now_real : ifa->csn + 1;
192: }
193:
194: static void
195: rip_fill_authentication(struct rip_proto *p, struct rip_iface *ifa, struct rip_packet *pkt, uint *plen)
196: {
197: struct rip_block_auth *auth = (void *) (pkt + 1);
198: struct password_item *pass = password_find(ifa->cf->passwords, 0);
199:
200: if (!pass)
201: {
202: /* FIXME: This should not happen */
203: log(L_ERR "%s: No suitable password found for authentication", p->p.name);
204: memset(auth, 0, sizeof(struct rip_block_auth));
205: return;
206: }
207:
208: switch (ifa->cf->auth_type)
209: {
210: case RIP_AUTH_PLAIN:
211: auth->must_be_ffff = htons(0xffff);
212: auth->auth_type = htons(RIP_AUTH_PLAIN);
213: strncpy(auth->password, pass->password, RIP_PASSWD_LENGTH);
214: return;
215:
216: case RIP_AUTH_CRYPTO:
217: auth->must_be_ffff = htons(0xffff);
218: auth->auth_type = htons(RIP_AUTH_CRYPTO);
219: auth->packet_len = htons(*plen);
220: auth->key_id = pass->id;
221: auth->auth_len = mac_type_length(pass->alg);
222: auth->seq_num = ifa->csn_ready ? htonl(ifa->csn) : 0;
223: auth->unused1 = 0;
224: auth->unused2 = 0;
225: ifa->csn_ready = 1;
226:
227: if (pass->alg < ALG_HMAC)
228: auth->auth_len += sizeof(struct rip_auth_tail);
229:
230: /*
231: * Note that RFC 4822 is unclear whether auth_len should cover whole
232: * authentication trailer or just auth_data length.
233: *
234: * FIXME: We should use just auth_data length by default. Currently we put
235: * the whole auth trailer length in keyed hash case to keep old behavior,
236: * but we put just auth_data length in the new HMAC case. Note that Quagga
237: * has config option for this.
238: *
239: * Crypto sequence numbers are increased by sender in rip_update_csn().
240: * First CSN should be zero, this is handled by csn_ready.
241: */
242:
243: struct rip_auth_tail *tail = (void *) ((byte *) pkt + *plen);
244: tail->must_be_ffff = htons(0xffff);
245: tail->must_be_0001 = htons(0x0001);
246:
247: uint auth_len = mac_type_length(pass->alg);
248: *plen += sizeof(struct rip_auth_tail) + auth_len;
249:
250: /* Append key for keyed hash, append padding for HMAC (RFC 4822 2.5) */
251: if (pass->alg < ALG_HMAC)
252: strncpy(tail->auth_data, pass->password, auth_len);
253: else
254: memset32(tail->auth_data, HMAC_MAGIC, auth_len / 4);
255:
256: mac_fill(pass->alg, pass->password, pass->length,
257: (byte *) pkt, *plen, tail->auth_data);
258: return;
259:
260: default:
261: bug("Unknown authentication type");
262: }
263: }
264:
265: static int
266: rip_check_authentication(struct rip_proto *p, struct rip_iface *ifa, struct rip_packet *pkt, uint *plen, struct rip_neighbor *n)
267: {
268: struct rip_block_auth *auth = (void *) (pkt + 1);
269: struct password_item *pass = NULL;
270: const char *err_dsc = NULL;
271: uint err_val = 0;
272: uint auth_type = 0;
273:
274: /* Check for authentication entry */
275: if ((*plen >= (sizeof(struct rip_packet) + sizeof(struct rip_block_auth))) &&
276: (auth->must_be_ffff == htons(0xffff)))
277: auth_type = ntohs(auth->auth_type);
278:
279: if (auth_type != ifa->cf->auth_type)
280: DROP("authentication method mismatch", auth_type);
281:
282: switch (auth_type)
283: {
284: case RIP_AUTH_NONE:
285: return 1;
286:
287: case RIP_AUTH_PLAIN:
288: pass = password_find_by_value(ifa->cf->passwords, auth->password, RIP_PASSWD_LENGTH);
289: if (!pass)
290: DROP1("wrong password");
291:
292: return 1;
293:
294: case RIP_AUTH_CRYPTO:
295: pass = password_find_by_id(ifa->cf->passwords, auth->key_id);
296: if (!pass)
297: DROP("no suitable password found", auth->key_id);
298:
299: uint data_len = ntohs(auth->packet_len);
300: uint auth_len = mac_type_length(pass->alg);
301: uint auth_len2 = sizeof(struct rip_auth_tail) + auth_len;
302:
303: /*
304: * Ideally, first check should be check for internal consistency:
305: * (data_len + sizeof(struct rip_auth_tail) + auth->auth_len) != *plen
306: *
307: * Second one should check expected code length:
308: * auth->auth_len != auth_len
309: *
310: * But as auth->auth_len has two interpretations, we simplify this
311: */
312:
313: if (data_len + auth_len2 != *plen)
314: DROP("packet length mismatch", *plen);
315:
316: /* Warning: two interpretations of auth_len field */
317: if ((auth->auth_len != auth_len) && (auth->auth_len != auth_len2))
318: DROP("wrong authentication length", auth->auth_len);
319:
320: struct rip_auth_tail *tail = (void *) ((byte *) pkt + data_len);
321: if ((tail->must_be_ffff != htons(0xffff)) || (tail->must_be_0001 != htons(0x0001)))
322: DROP1("authentication trailer is missing");
323:
324: /* Accept higher sequence number, or zero if connectivity is lost */
325: /* FIXME: sequence number must be password/SA specific */
326: u32 rcv_csn = ntohl(auth->seq_num);
327: if ((rcv_csn < n->csn) && (rcv_csn || n->uc))
328: {
329: /* We want to report both new and old CSN */
330: LOG_PKT_AUTH("Authentication failed for %I on %s - "
331: "lower sequence number (rcv %u, old %u)",
332: n->nbr->addr, ifa->iface->name, rcv_csn, n->csn);
333: return 0;
334: }
335:
336: byte *auth_data = alloca(auth_len);
337: memcpy(auth_data, tail->auth_data, auth_len);
338:
339: /* Append key for keyed hash, append padding for HMAC (RFC 4822 2.5) */
340: if (pass->alg < ALG_HMAC)
341: strncpy(tail->auth_data, pass->password, auth_len);
342: else
343: memset32(tail->auth_data, HMAC_MAGIC, auth_len / 4);
344:
345: if (!mac_verify(pass->alg, pass->password, pass->length,
346: (byte *) pkt, *plen, auth_data))
347: DROP("wrong authentication code", pass->id);
348:
349: *plen = data_len;
350: n->csn = rcv_csn;
351:
352: return 1;
353: }
354:
355: drop:
356: LOG_PKT_AUTH("Authentication failed for %I on %s - %s (%u)",
357: n->nbr->addr, ifa->iface->name, err_dsc, err_val);
358:
359: return 0;
360: }
361:
362: static inline int
363: rip_send_to(struct rip_proto *p, struct rip_iface *ifa, struct rip_packet *pkt, uint plen, ip_addr dst)
364: {
365: if (ifa->cf->auth_type)
366: rip_fill_authentication(p, ifa, pkt, &plen);
367:
368: return sk_send_to(ifa->sk, plen, dst, 0);
369: }
370:
371:
372: void
373: rip_send_request(struct rip_proto *p, struct rip_iface *ifa)
374: {
375: byte *pos = rip_tx_buffer(ifa);
376:
377: struct rip_packet *pkt = (void *) pos;
378: pkt->command = RIP_CMD_REQUEST;
379: pkt->version = ifa->cf->version;
380: pkt->unused = 0;
381: pos += rip_pkt_hdrlen(ifa);
382:
383: struct rip_block b = { .no_af = 1, .metric = p->infinity };
384: rip_put_block(p, pos, &b);
385: pos += RIP_BLOCK_LENGTH;
386:
387: rip_update_csn(p, ifa);
388:
389: TRACE(D_PACKETS, "Sending request via %s", ifa->iface->name);
390: rip_send_to(p, ifa, pkt, pos - (byte *) pkt, ifa->addr);
391: }
392:
393: static void
394: rip_receive_request(struct rip_proto *p, struct rip_iface *ifa, struct rip_packet *pkt, uint plen, struct rip_neighbor *from)
395: {
396: TRACE(D_PACKETS, "Request received from %I on %s", from->nbr->addr, ifa->iface->name);
397:
398: byte *pos = (byte *) pkt + rip_pkt_hdrlen(ifa);
399:
400: /* We expect one regular block */
401: if (plen != (rip_pkt_hdrlen(ifa) + RIP_BLOCK_LENGTH))
402: return;
403:
404: struct rip_block b = { .no_af = 1 };
405:
406: if (!rip_get_block(p, pos, &b))
407: return;
408:
409: /* Special case - zero prefix, infinity metric */
410: if (ipa_nonzero(b.prefix) || b.pxlen || (b.metric != p->infinity))
411: return;
412:
413: /* We do nothing if TX is already active */
414: if (ifa->tx_active)
415: {
416: TRACE(D_EVENTS, "Skipping request from %I on %s, TX is busy", from->nbr->addr, ifa->iface->name);
417: return;
418: }
419:
420: if (!ifa->cf->passive)
421: rip_send_table(p, ifa, from->nbr->addr, 0);
422: }
423:
424:
425: static int
426: rip_send_response(struct rip_proto *p, struct rip_iface *ifa)
427: {
428: if (! ifa->tx_active)
429: return 0;
430:
431: byte *pos = rip_tx_buffer(ifa);
432: byte *max = rip_tx_buffer(ifa) + ifa->tx_plen -
433: (rip_is_v2(p) ? RIP_BLOCK_LENGTH : 2*RIP_BLOCK_LENGTH);
434: ip_addr last_next_hop = IPA_NONE;
435: int send = 0;
436:
437: struct rip_packet *pkt = (void *) pos;
438: pkt->command = RIP_CMD_RESPONSE;
439: pkt->version = ifa->cf->version;
440: pkt->unused = 0;
441: pos += rip_pkt_hdrlen(ifa);
442:
443: FIB_ITERATE_START(&p->rtable, &ifa->tx_fit, z)
444: {
445: struct rip_entry *en = (struct rip_entry *) z;
446:
447: /* Dummy entries */
448: if (!en->valid)
449: goto next_entry;
450:
451: /* Stale entries that should be removed */
452: if ((en->valid == RIP_ENTRY_STALE) &&
453: ((en->changed + ifa->cf->garbage_time) <= now))
454: goto next_entry;
455:
456: /* Triggered updates */
457: if (en->changed < ifa->tx_changed)
458: goto next_entry;
459:
460: /* Not enough space for current entry */
461: if (pos > max)
462: {
463: FIB_ITERATE_PUT(&ifa->tx_fit, z);
464: goto break_loop;
465: }
466:
467: struct rip_block rte = {
468: .prefix = en->n.prefix,
469: .pxlen = en->n.pxlen,
470: .metric = en->metric,
471: .tag = en->tag
472: };
473:
474: if (en->iface == ifa->iface)
475: rte.next_hop = en->next_hop;
476:
477: if (rip_is_v2(p) && (ifa->cf->version == RIP_V1))
478: {
479: /* Skipping subnets (i.e. not hosts, classful networks or default route) */
480: if (ip4_masklen(ip4_class_mask(ipa_to_ip4(en->n.prefix))) != en->n.pxlen)
481: goto next_entry;
482:
483: rte.tag = 0;
484: rte.pxlen = 0;
485: rte.next_hop = IPA_NONE;
486: }
487:
488: /* Split horizon */
489: if (en->from == ifa->iface && ifa->cf->split_horizon)
490: {
491: if (ifa->cf->poison_reverse)
492: {
493: rte.metric = p->infinity;
494: rte.next_hop = IPA_NONE;
495: }
496: else
497: goto next_entry;
498: }
499:
500: // TRACE(D_PACKETS, " %I/%d -> %I metric %d", rte.prefix, rte.pxlen, rte.next_hop, rte.metric);
501:
502: /* RIPng next hop entry */
503: if (rip_is_ng(p) && !ipa_equal(rte.next_hop, last_next_hop))
504: {
505: last_next_hop = rte.next_hop;
506: rip_put_next_hop(p, pos, &rte);
507: pos += RIP_BLOCK_LENGTH;
508: }
509:
510: rip_put_block(p, pos, &rte);
511: pos += RIP_BLOCK_LENGTH;
512: send = 1;
513:
514: next_entry: ;
515: }
516: FIB_ITERATE_END(z);
517: ifa->tx_active = 0;
518:
519: /* Do not send empty packet */
520: if (!send)
521: return 0;
522:
523: break_loop:
524: TRACE(D_PACKETS, "Sending response via %s", ifa->iface->name);
525: return rip_send_to(p, ifa, pkt, pos - (byte *) pkt, ifa->tx_addr);
526: }
527:
528: /**
529: * rip_send_table - RIP interface timer hook
530: * @p: RIP instance
531: * @ifa: RIP interface
532: * @addr: destination IP address
533: * @changed: time limit for triggered updates
534: *
535: * The function activates an update session and starts sending routing update
536: * packets (using rip_send_response()). The session may be finished during the
537: * call or may continue in rip_tx_hook() until all appropriate routes are
538: * transmitted. Note that there may be at most one active update session per
539: * interface, the function will terminate the old active session before
540: * activating the new one.
541: */
542: void
543: rip_send_table(struct rip_proto *p, struct rip_iface *ifa, ip_addr addr, bird_clock_t changed)
544: {
545: DBG("RIP: Opening TX session to %I on %s\n", dst, ifa->iface->name);
546:
547: rip_reset_tx_session(p, ifa);
548:
549: ifa->tx_active = 1;
550: ifa->tx_addr = addr;
551: ifa->tx_changed = changed;
552: FIB_ITERATE_INIT(&ifa->tx_fit, &p->rtable);
553:
554: rip_update_csn(p, ifa);
555:
556: while (rip_send_response(p, ifa) > 0)
557: ;
558: }
559:
560: static void
561: rip_tx_hook(sock *sk)
562: {
563: struct rip_iface *ifa = sk->data;
564: struct rip_proto *p = ifa->rip;
565:
566: DBG("RIP: TX hook called (iface %s, src %I, dst %I)\n",
567: sk->iface->name, sk->saddr, sk->daddr);
568:
569: while (rip_send_response(p, ifa) > 0)
570: ;
571: }
572:
573: static void
574: rip_err_hook(sock *sk, int err)
575: {
576: struct rip_iface *ifa = sk->data;
577: struct rip_proto *p = ifa->rip;
578:
579: log(L_ERR "%s: Socket error on %s: %M", p->p.name, ifa->iface->name, err);
580:
581: rip_reset_tx_session(p, ifa);
582: }
583:
584: static void
585: rip_receive_response(struct rip_proto *p, struct rip_iface *ifa, struct rip_packet *pkt, uint plen, struct rip_neighbor *from)
586: {
587: struct rip_block rte = {};
588: const char *err_dsc = NULL;
589:
590: TRACE(D_PACKETS, "Response received from %I on %s", from->nbr->addr, ifa->iface->name);
591:
592: byte *pos = (byte *) pkt + sizeof(struct rip_packet);
593: byte *end = (byte *) pkt + plen;
594:
595: for (; pos < end; pos += RIP_BLOCK_LENGTH)
596: {
597: /* Find next regular RTE */
598: if (!rip_get_block(p, pos, &rte))
599: continue;
600:
601: int c = ipa_classify_net(rte.prefix);
602: if ((c < 0) || !(c & IADDR_HOST) || ((c & IADDR_SCOPE_MASK) <= SCOPE_LINK))
603: SKIP("invalid prefix");
604:
605: if (rip_is_v2(p) && (pkt->version == RIP_V1))
606: {
607: if (ifa->cf->check_zero && (rte.tag || rte.pxlen || ipa_nonzero(rte.next_hop)))
608: SKIP("RIPv1 reserved field is nonzero");
609:
610: rte.tag = 0;
611: rte.pxlen = ip4_masklen(ip4_class_mask(ipa_to_ip4(rte.prefix)));
612: rte.next_hop = IPA_NONE;
613: }
614:
615: if ((rte.pxlen < 0) || (rte.pxlen > MAX_PREFIX_LENGTH))
616: SKIP("invalid prefix length");
617:
618: if (rte.metric > p->infinity)
619: SKIP("invalid metric");
620:
621: if (ipa_nonzero(rte.next_hop))
622: {
623: neighbor *nbr = neigh_find2(&p->p, &rte.next_hop, ifa->iface, 0);
624: if (!nbr || (nbr->scope <= 0))
625: rte.next_hop = IPA_NONE;
626: }
627:
628: // TRACE(D_PACKETS, " %I/%d -> %I metric %d", rte.prefix, rte.pxlen, rte.next_hop, rte.metric);
629:
630: rte.metric += ifa->cf->metric;
631:
632: if (rte.metric < p->infinity)
633: {
634: struct rip_rte new = {
635: .from = from,
636: .next_hop = ipa_nonzero(rte.next_hop) ? rte.next_hop : from->nbr->addr,
637: .metric = rte.metric,
638: .tag = rte.tag,
639: .expires = now + ifa->cf->timeout_time
640: };
641:
642: rip_update_rte(p, &rte.prefix, rte.pxlen, &new);
643: }
644: else
645: rip_withdraw_rte(p, &rte.prefix, rte.pxlen, from);
646:
647: continue;
648:
649: skip:
650: LOG_RTE("Ignoring route %I/%d received from %I - %s",
651: rte.prefix, rte.pxlen, from->nbr->addr, err_dsc);
652: }
653: }
654:
655: static int
656: rip_rx_hook(sock *sk, uint len)
657: {
658: struct rip_iface *ifa = sk->data;
659: struct rip_proto *p = ifa->rip;
660: const char *err_dsc = NULL;
661: uint err_val = 0;
662:
663: if (sk->lifindex != sk->iface->index)
664: return 1;
665:
666: DBG("RIP: RX hook called (iface %s, src %I, dst %I)\n",
667: sk->iface->name, sk->faddr, sk->laddr);
668:
669: /* Silently ignore my own packets */
670: /* FIXME: Better local address check */
671: if (ipa_equal(ifa->iface->addr->ip, sk->faddr))
672: return 1;
673:
674: if (rip_is_ng(p) && !ipa_is_link_local(sk->faddr))
675: DROP1("wrong src address");
676:
677: struct rip_neighbor *n = rip_get_neighbor(p, &sk->faddr, ifa);
678:
679: if (!n)
680: DROP1("not from neighbor");
681:
682: if ((ifa->cf->ttl_security == 1) && (sk->rcv_ttl < 255))
683: DROP("wrong TTL", sk->rcv_ttl);
684:
685: if (sk->fport != sk->dport)
686: DROP("wrong src port", sk->fport);
687:
688: if (len < sizeof(struct rip_packet))
689: DROP("too short", len);
690:
691: if (sk->flags & SKF_TRUNCATED)
692: DROP("truncated", len);
693:
694: struct rip_packet *pkt = (struct rip_packet *) sk->rbuf;
695: uint plen = len;
696:
697: if (!pkt->version || (ifa->cf->version_only && (pkt->version != ifa->cf->version)))
698: DROP("wrong version", pkt->version);
699:
700: /* rip_check_authentication() has its own error logging */
701: if (rip_is_v2(p) && !rip_check_authentication(p, ifa, pkt, &plen, n))
702: return 1;
703:
704: if ((plen - sizeof(struct rip_packet)) % RIP_BLOCK_LENGTH)
705: DROP("invalid length", plen);
706:
707: n->last_seen = now;
708: rip_update_bfd(p, n);
709:
710: switch (pkt->command)
711: {
712: case RIP_CMD_REQUEST:
713: rip_receive_request(p, ifa, pkt, plen, n);
714: break;
715:
716: case RIP_CMD_RESPONSE:
717: rip_receive_response(p, ifa, pkt, plen, n);
718: break;
719:
720: default:
721: DROP("unknown command", pkt->command);
722: }
723: return 1;
724:
725: drop:
726: LOG_PKT("Bad packet from %I via %s - %s (%u)",
727: sk->faddr, sk->iface->name, err_dsc, err_val);
728:
729: return 1;
730: }
731:
732: int
733: rip_open_socket(struct rip_iface *ifa)
734: {
735: struct rip_proto *p = ifa->rip;
736:
737: sock *sk = sk_new(p->p.pool);
738: sk->type = SK_UDP;
739: sk->sport = ifa->cf->port;
740: sk->dport = ifa->cf->port;
741: sk->iface = ifa->iface;
742:
743: /*
744: * For RIPv2, we explicitly choose a primary address, mainly to ensure that
745: * RIP and BFD uses the same one. For RIPng, we left it to kernel, which
746: * should choose some link-local address based on the same scope rule.
747: */
748: if (rip_is_v2(p))
749: sk->saddr = ifa->iface->addr->ip;
750:
751: sk->rx_hook = rip_rx_hook;
752: sk->tx_hook = rip_tx_hook;
753: sk->err_hook = rip_err_hook;
754: sk->data = ifa;
755:
756: sk->tos = ifa->cf->tx_tos;
757: sk->priority = ifa->cf->tx_priority;
758: sk->ttl = ifa->cf->ttl_security ? 255 : 1;
759: sk->flags = SKF_LADDR_RX | ((ifa->cf->ttl_security == 1) ? SKF_TTL_RX : 0);
760:
761: /* sk->rbsize and sk->tbsize are handled in rip_iface_update_buffers() */
762:
763: if (sk_open(sk) < 0)
764: goto err;
765:
766: if (ifa->cf->mode == RIP_IM_MULTICAST)
767: {
768: if (sk_setup_multicast(sk) < 0)
769: goto err;
770:
771: if (sk_join_group(sk, ifa->addr) < 0)
772: goto err;
773: }
774: else /* Broadcast */
775: {
776: if (sk_setup_broadcast(sk) < 0)
777: goto err;
778:
779: if (ipa_zero(ifa->addr))
780: {
781: sk->err = "Missing broadcast address";
782: goto err;
783: }
784: }
785:
786: ifa->sk = sk;
787: return 1;
788:
789: err:
790: sk_log_error(sk, p->p.name);
791: rfree(sk);
792: return 0;
793: }
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 / rip