Annotation of embedaddon/bird/proto/radv/packets.c, revision 1.1.1.1
1.1 misho 1: /*
2: * BIRD -- RAdv Packet Processing
3: *
4: *
5: * Can be freely distributed and used under the terms of the GNU GPL.
6: */
7:
8:
9: #include <stdlib.h>
10: #include "radv.h"
11:
12: struct radv_ra_packet
13: {
14: u8 type;
15: u8 code;
16: u16 checksum;
17: u8 current_hop_limit;
18: u8 flags;
19: u16 router_lifetime;
20: u32 reachable_time;
21: u32 retrans_timer;
22: };
23:
24: #define OPT_RA_MANAGED 0x80
25: #define OPT_RA_OTHER_CFG 0x40
26:
27: #define OPT_PREFIX 3
28: #define OPT_MTU 5
29: #define OPT_RDNSS 25
30: #define OPT_DNSSL 31
31:
32: struct radv_opt_prefix
33: {
34: u8 type;
35: u8 length;
36: u8 pxlen;
37: u8 flags;
38: u32 valid_lifetime;
39: u32 preferred_lifetime;
40: u32 reserved;
41: ip_addr prefix;
42: };
43:
44: #define OPT_PX_ONLINK 0x80
45: #define OPT_PX_AUTONOMOUS 0x40
46:
47: struct radv_opt_mtu
48: {
49: u8 type;
50: u8 length;
51: u16 reserved;
52: u32 mtu;
53: };
54:
55: struct radv_opt_rdnss
56: {
57: u8 type;
58: u8 length;
59: u16 reserved;
60: u32 lifetime;
61: ip_addr servers[];
62: };
63:
64: struct radv_opt_dnssl
65: {
66: u8 type;
67: u8 length;
68: u16 reserved;
69: u32 lifetime;
70: char domain[];
71: };
72:
73:
74: static struct radv_prefix_config default_prefix = {
75: .onlink = 1,
76: .autonomous = 1,
77: .valid_lifetime = DEFAULT_VALID_LIFETIME,
78: .preferred_lifetime = DEFAULT_PREFERRED_LIFETIME
79: };
80:
81:
82: static struct radv_prefix_config *
83: radv_prefix_match(struct radv_iface *ifa, struct ifa *a)
84: {
85: struct proto *p = &ifa->ra->p;
86: struct radv_config *cf = (struct radv_config *) (p->cf);
87: struct radv_prefix_config *pc;
88:
89: if (a->scope <= SCOPE_LINK)
90: return NULL;
91:
92: WALK_LIST(pc, ifa->cf->pref_list)
93: if ((a->pxlen >= pc->pxlen) && ipa_in_net(a->prefix, pc->prefix, pc->pxlen))
94: return pc;
95:
96: WALK_LIST(pc, cf->pref_list)
97: if ((a->pxlen >= pc->pxlen) && ipa_in_net(a->prefix, pc->prefix, pc->pxlen))
98: return pc;
99:
100: return &default_prefix;
101: }
102:
103: static int
104: radv_prepare_rdnss(struct radv_iface *ifa, list *rdnss_list, char **buf, char *bufend)
105: {
106: struct radv_rdnss_config *rcf = HEAD(*rdnss_list);
107:
108: while(NODE_VALID(rcf))
109: {
110: struct radv_rdnss_config *rcf_base = rcf;
111: struct radv_opt_rdnss *op = (void *) *buf;
112: int max_i = (bufend - *buf - sizeof(struct radv_opt_rdnss)) / sizeof(ip_addr);
113: int i = 0;
114:
115: if (max_i < 1)
116: goto too_much;
117:
118: op->type = OPT_RDNSS;
119: op->reserved = 0;
120:
121: if (rcf->lifetime_mult)
122: op->lifetime = htonl(rcf->lifetime_mult * ifa->cf->max_ra_int);
123: else
124: op->lifetime = htonl(rcf->lifetime);
125:
126: while(NODE_VALID(rcf) &&
127: (rcf->lifetime == rcf_base->lifetime) &&
128: (rcf->lifetime_mult == rcf_base->lifetime_mult))
129: {
130: if (i >= max_i)
131: goto too_much;
132:
133: op->servers[i] = rcf->server;
134: ipa_hton(op->servers[i]);
135: i++;
136:
137: rcf = NODE_NEXT(rcf);
138: }
139:
140: op->length = 1+2*i;
141: *buf += 8 * op->length;
142: }
143:
144: return 0;
145:
146: too_much:
147: log(L_WARN "%s: Too many RA options on interface %s",
148: ifa->ra->p.name, ifa->iface->name);
149: return -1;
150: }
151:
152: int
153: radv_process_domain(struct radv_dnssl_config *cf)
154: {
155: /* Format of domain in search list is <size> <label> <size> <label> ... 0 */
156:
157: char *dom = cf->domain;
158: char *dom_end = dom; /* Just to */
159: u8 *dlen_save = &cf->dlen_first;
160: uint len;
161:
162: while (dom_end)
163: {
164: dom_end = strchr(dom, '.');
165: len = dom_end ? (uint)(dom_end - dom) : strlen(dom);
166:
167: if (len < 1 || len > 63)
168: return -1;
169:
170: *dlen_save = len;
171: dlen_save = (u8 *) dom_end;
172:
173: dom += len + 1;
174: }
175:
176: len = dom - cf->domain;
177: if (len > 254)
178: return -1;
179:
180: cf->dlen_all = len;
181:
182: return 0;
183: }
184:
185: static int
186: radv_prepare_dnssl(struct radv_iface *ifa, list *dnssl_list, char **buf, char *bufend)
187: {
188: struct radv_dnssl_config *dcf = HEAD(*dnssl_list);
189:
190: while(NODE_VALID(dcf))
191: {
192: struct radv_dnssl_config *dcf_base = dcf;
193: struct radv_opt_dnssl *op = (void *) *buf;
194: int bsize = bufend - *buf - sizeof(struct radv_opt_dnssl);
195: int bpos = 0;
196:
197: if (bsize < 0)
198: goto too_much;
199:
200: bsize = bsize & ~7; /* Round down to multiples of 8 */
201:
202: op->type = OPT_DNSSL;
203: op->reserved = 0;
204:
205: if (dcf->lifetime_mult)
206: op->lifetime = htonl(dcf->lifetime_mult * ifa->cf->max_ra_int);
207: else
208: op->lifetime = htonl(dcf->lifetime);
209:
210: while(NODE_VALID(dcf) &&
211: (dcf->lifetime == dcf_base->lifetime) &&
212: (dcf->lifetime_mult == dcf_base->lifetime_mult))
213: {
214: if (bpos + dcf->dlen_all + 1 > bsize)
215: goto too_much;
216:
217: op->domain[bpos++] = dcf->dlen_first;
218: memcpy(op->domain + bpos, dcf->domain, dcf->dlen_all);
219: bpos += dcf->dlen_all;
220:
221: dcf = NODE_NEXT(dcf);
222: }
223:
224: int blen = (bpos + 7) / 8;
225: bzero(op->domain + bpos, 8 * blen - bpos);
226: op->length = 1 + blen;
227: *buf += 8 * op->length;
228: }
229:
230: return 0;
231:
232: too_much:
233: log(L_WARN "%s: Too many RA options on interface %s",
234: ifa->ra->p.name, ifa->iface->name);
235: return -1;
236: }
237:
238: static void
239: radv_prepare_ra(struct radv_iface *ifa)
240: {
241: struct proto_radv *ra = ifa->ra;
242: struct radv_config *cf = (struct radv_config *) (ra->p.cf);
243: struct radv_iface_config *ic = ifa->cf;
244:
245: char *buf = ifa->sk->tbuf;
246: char *bufstart = buf;
247: char *bufend = buf + ifa->sk->tbsize;
248:
249: struct radv_ra_packet *pkt = (void *) buf;
250: pkt->type = ICMPV6_RA;
251: pkt->code = 0;
252: pkt->checksum = 0;
253: pkt->current_hop_limit = ic->current_hop_limit;
254: pkt->router_lifetime = (ra->active || !ic->default_lifetime_sensitive) ?
255: htons(ic->default_lifetime) : 0;
256: pkt->flags = (ic->managed ? OPT_RA_MANAGED : 0) |
257: (ic->other_config ? OPT_RA_OTHER_CFG : 0) |
258: (pkt->router_lifetime ? ic->default_preference : 0);
259: pkt->reachable_time = htonl(ic->reachable_time);
260: pkt->retrans_timer = htonl(ic->retrans_timer);
261: buf += sizeof(*pkt);
262:
263: if (ic->link_mtu)
264: {
265: struct radv_opt_mtu *om = (void *) buf;
266: om->type = OPT_MTU;
267: om->length = 1;
268: om->reserved = 0;
269: om->mtu = htonl(ic->link_mtu);
270: buf += sizeof (*om);
271: }
272:
273: struct ifa *addr;
274: WALK_LIST(addr, ifa->iface->addrs)
275: {
276: struct radv_prefix_config *pc;
277: pc = radv_prefix_match(ifa, addr);
278:
279: if (!pc || pc->skip)
280: continue;
281:
282: if (buf + sizeof(struct radv_opt_prefix) > bufend)
283: {
284: log(L_WARN "%s: Too many prefixes on interface %s", ra->p.name, ifa->iface->name);
285: goto done;
286: }
287:
288: struct radv_opt_prefix *op = (void *) buf;
289: op->type = OPT_PREFIX;
290: op->length = 4;
291: op->pxlen = addr->pxlen;
292: op->flags = (pc->onlink ? OPT_PX_ONLINK : 0) |
293: (pc->autonomous ? OPT_PX_AUTONOMOUS : 0);
294: op->valid_lifetime = (ra->active || !pc->valid_lifetime_sensitive) ?
295: htonl(pc->valid_lifetime) : 0;
296: op->preferred_lifetime = (ra->active || !pc->preferred_lifetime_sensitive) ?
297: htonl(pc->preferred_lifetime) : 0;
298: op->reserved = 0;
299: op->prefix = addr->prefix;
300: ipa_hton(op->prefix);
301: buf += sizeof(*op);
302: }
303:
304: if (! ic->rdnss_local)
305: if (radv_prepare_rdnss(ifa, &cf->rdnss_list, &buf, bufend) < 0)
306: goto done;
307:
308: if (radv_prepare_rdnss(ifa, &ic->rdnss_list, &buf, bufend) < 0)
309: goto done;
310:
311: if (! ic->dnssl_local)
312: if (radv_prepare_dnssl(ifa, &cf->dnssl_list, &buf, bufend) < 0)
313: goto done;
314:
315: if (radv_prepare_dnssl(ifa, &ic->dnssl_list, &buf, bufend) < 0)
316: goto done;
317:
318: done:
319: ifa->plen = buf - bufstart;
320: }
321:
322:
323: void
324: radv_send_ra(struct radv_iface *ifa, int shutdown)
325: {
326: struct proto_radv *ra = ifa->ra;
327:
328: /* We store prepared RA in tbuf */
329: if (!ifa->plen)
330: radv_prepare_ra(ifa);
331:
332: if (shutdown)
333: {
334: /*
335: * Modify router lifetime to 0, it is not restored because we suppose that
336: * the iface will be removed. The preference value also has to be zeroed.
337: * (RFC 4191 2.2: If router lifetime is 0, the preference value must be 0.)
338: */
339:
340: struct radv_ra_packet *pkt = (void *) ifa->sk->tbuf;
341: pkt->router_lifetime = 0;
342: pkt->flags &= ~RA_PREF_MASK;
343: }
344:
345: RADV_TRACE(D_PACKETS, "Sending RA via %s", ifa->iface->name);
346: sk_send_to(ifa->sk, ifa->plen, IP6_ALL_NODES, 0);
347: }
348:
349:
350: static int
351: radv_rx_hook(sock *sk, uint size)
352: {
353: struct radv_iface *ifa = sk->data;
354: struct proto_radv *ra = ifa->ra;
355:
356: /* We want just packets from sk->iface */
357: if (sk->lifindex != sk->iface->index)
358: return 1;
359:
360: if (ipa_equal(sk->faddr, ifa->addr->ip))
361: return 1;
362:
363: if (size < 8)
364: return 1;
365:
366: byte *buf = sk->rbuf;
367:
368: if (buf[1] != 0)
369: return 1;
370:
371: /* Validation is a bit sloppy - Hop Limit is not checked and
372: length of options is ignored for RS and left to later for RA */
373:
374: switch (buf[0])
375: {
376: case ICMPV6_RS:
377: RADV_TRACE(D_PACKETS, "Received RS from %I via %s",
378: sk->faddr, ifa->iface->name);
379: radv_iface_notify(ifa, RA_EV_RS);
380: return 1;
381:
382: case ICMPV6_RA:
383: RADV_TRACE(D_PACKETS, "Received RA from %I via %s",
384: sk->faddr, ifa->iface->name);
385: /* FIXME - there should be some checking of received RAs, but we just ignore them */
386: return 1;
387:
388: default:
389: return 1;
390: }
391: }
392:
393: static void
394: radv_tx_hook(sock *sk)
395: {
396: struct radv_iface *ifa = sk->data;
397: log(L_WARN "%s: TX hook called", ifa->ra->p.name);
398: }
399:
400: static void
401: radv_err_hook(sock *sk, int err)
402: {
403: struct radv_iface *ifa = sk->data;
404: log(L_ERR "%s: Socket error on %s: %M", ifa->ra->p.name, ifa->iface->name, err);
405: }
406:
407: int
408: radv_sk_open(struct radv_iface *ifa)
409: {
410: sock *sk = sk_new(ifa->ra->p.pool);
411: sk->type = SK_IP;
412: sk->dport = ICMPV6_PROTO;
413: sk->saddr = ifa->addr->ip;
414:
415: sk->ttl = 255; /* Mandatory for Neighbor Discovery packets */
416: sk->rx_hook = radv_rx_hook;
417: sk->tx_hook = radv_tx_hook;
418: sk->err_hook = radv_err_hook;
419: sk->iface = ifa->iface;
420: sk->rbsize = 1024; // bufsize(ifa);
421: sk->tbsize = 1024; // bufsize(ifa);
422: sk->data = ifa;
423: sk->flags = SKF_LADDR_RX;
424:
425: if (sk_open(sk) < 0)
426: goto err;
427:
428: /* We want listen just to ICMPv6 messages of type RS and RA */
429: if (sk_set_icmp6_filter(sk, ICMPV6_RS, ICMPV6_RA) < 0)
430: goto err;
431:
432: if (sk_setup_multicast(sk) < 0)
433: goto err;
434:
435: if (sk_join_group(sk, IP6_ALL_ROUTERS) < 0)
436: goto err;
437:
438: ifa->sk = sk;
439: return 1;
440:
441: err:
442: sk_log_error(sk, ifa->ra->p.name);
443: rfree(sk);
444: return 0;
445: }
446:
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 / radv