Statistics
| Branch: | Revision:

iof-bird-daemon / proto / radv / packets.c @ 05476c4d

History | View | Annotate | Download (9.35 KB)

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
  int len;
161

    
162
  while (dom_end)
163
  {
164
    dom_end = strchr(dom, '.');
165
    len = dom_end ? (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->flags = (ic->managed ? OPT_RA_MANAGED : 0) |
255
    (ic->other_config ? OPT_RA_OTHER_CFG : 0);
256
  pkt->router_lifetime = (ra->active || !ic->default_lifetime_sensitive) ?
257
    htons(ic->default_lifetime) : 0;
258
  pkt->reachable_time = htonl(ic->reachable_time);
259
  pkt->retrans_timer = htonl(ic->retrans_timer);
260
  buf += sizeof(*pkt);
261

    
262
  if (ic->link_mtu)
263
  {
264
    struct radv_opt_mtu *om = (void *) buf;
265
    om->type = OPT_MTU;
266
    om->length = 1;
267
    om->reserved = 0;
268
    om->mtu = htonl(ic->link_mtu);
269
    buf += sizeof (*om);
270
  }
271

    
272
  struct ifa *addr;
273
  WALK_LIST(addr, ifa->iface->addrs)
274
  {
275
    struct radv_prefix_config *pc;
276
    pc = radv_prefix_match(ifa, addr);
277

    
278
    if (!pc || pc->skip)
279
      continue;
280

    
281
    if (buf + sizeof(struct radv_opt_prefix) > bufend)
282
    {
283
      log(L_WARN "%s: Too many prefixes on interface %s", ra->p.name, ifa->iface->name);
284
      goto done;
285
    }
286

    
287
    struct radv_opt_prefix *op = (void *) buf;
288
    op->type = OPT_PREFIX;
289
    op->length = 4;
290
    op->pxlen = addr->pxlen;
291
    op->flags = (pc->onlink ? OPT_PX_ONLINK : 0) |
292
      (pc->autonomous ? OPT_PX_AUTONOMOUS : 0);
293
    op->valid_lifetime = (ra->active || !pc->valid_lifetime_sensitive) ?
294
      htonl(pc->valid_lifetime) : 0;
295
    op->preferred_lifetime = (ra->active || !pc->preferred_lifetime_sensitive) ?
296
      htonl(pc->preferred_lifetime) : 0;
297
    op->reserved = 0;
298
    op->prefix = addr->prefix;
299
    ipa_hton(op->prefix);
300
    buf += sizeof(*op);
301
  }
302

    
303
  if (! ic->rdnss_local)
304
    if (radv_prepare_rdnss(ifa, &cf->rdnss_list, &buf, bufend) < 0)
305
      goto done;
306

    
307
  if (radv_prepare_rdnss(ifa, &ic->rdnss_list, &buf, bufend) < 0)
308
    goto done;
309

    
310
  if (! ic->dnssl_local)
311
    if (radv_prepare_dnssl(ifa, &cf->dnssl_list, &buf, bufend) < 0)
312
      goto done;
313

    
314
  if (radv_prepare_dnssl(ifa, &ic->dnssl_list, &buf, bufend) < 0)
315
    goto done;
316

    
317
 done:
318
  ifa->plen = buf - bufstart;
319
}
320

    
321

    
322
void
323
radv_send_ra(struct radv_iface *ifa, int shutdown)
324
{
325
  struct proto_radv *ra = ifa->ra;
326

    
327
  /* We store prepared RA in tbuf */
328
  if (!ifa->plen)
329
    radv_prepare_ra(ifa);
330

    
331
  if (shutdown)
332
  {
333
    /* Modify router lifetime to 0, it is not restored because
334
       we suppose that the iface will be removed */
335
    struct radv_ra_packet *pkt = (void *) ifa->sk->tbuf;
336
    pkt->router_lifetime = 0;
337
  }
338

    
339
  RADV_TRACE(D_PACKETS, "Sending RA via %s", ifa->iface->name);
340
  sk_send_to(ifa->sk, ifa->plen, AllNodes, 0);
341
}
342

    
343

    
344
static int
345
radv_rx_hook(sock *sk, int size)
346
{
347
  struct radv_iface *ifa = sk->data;
348
  struct proto_radv *ra = ifa->ra;
349

    
350
  /* We want just packets from sk->iface */
351
  if (sk->lifindex != sk->iface->index)
352
    return 1;
353

    
354
  if (ipa_equal(sk->faddr, ifa->addr->ip))
355
    return 1;
356

    
357
  if (size < 8)
358
    return 1;
359

    
360
  byte *buf = sk->rbuf;
361

    
362
  if (buf[1] != 0)
363
    return 1;
364

    
365
  /* Validation is a bit sloppy - Hop Limit is not checked and
366
     length of options is ignored for RS and left to later for RA */
367

    
368
  switch (buf[0])
369
  {
370
  case ICMPV6_RS:
371
    RADV_TRACE(D_PACKETS, "Received RS from %I via %s",
372
               sk->faddr, ifa->iface->name);
373
    radv_iface_notify(ifa, RA_EV_RS);
374
    return 1;
375

    
376
  case ICMPV6_RA:
377
    RADV_TRACE(D_PACKETS, "Received RA from %I via %s",
378
               sk->faddr, ifa->iface->name);
379
    /* FIXME - there should be some checking of received RAs, but we just ignore them */
380
    return 1;
381

    
382
  default:
383
    return 1;
384
  }
385
}
386

    
387
static void
388
radv_tx_hook(sock *sk)
389
{
390
  struct radv_iface *ifa = sk->data;
391
  log(L_WARN "%s: TX hook called", ifa->ra->p.name);
392
}
393

    
394
static void
395
radv_err_hook(sock *sk, int err)
396
{
397
  struct radv_iface *ifa = sk->data;
398
  log(L_ERR "%s: Socket error on %s: %M", ifa->ra->p.name, ifa->iface->name, err);
399
}
400

    
401
int
402
radv_sk_open(struct radv_iface *ifa)
403
{
404
  sock *sk = sk_new(ifa->ra->p.pool);
405
  sk->type = SK_IP;
406
  sk->dport = ICMPV6_PROTO;
407
  sk->saddr = ifa->addr->ip;
408

    
409
  sk->ttl = 255; /* Mandatory for Neighbor Discovery packets */
410
  sk->rx_hook = radv_rx_hook;
411
  sk->tx_hook = radv_tx_hook;
412
  sk->err_hook = radv_err_hook;
413
  sk->iface = ifa->iface;
414
  sk->rbsize = 1024; // bufsize(ifa);
415
  sk->tbsize = 1024; // bufsize(ifa);
416
  sk->data = ifa;
417
  sk->flags = SKF_LADDR_RX;
418

    
419
  if (sk_open(sk) < 0)
420
    goto err;
421

    
422
  /* We want listen just to ICMPv6 messages of type RS and RA */
423
  if (sk_set_icmp6_filter(sk, ICMPV6_RS, ICMPV6_RA) < 0)
424
    goto err;
425

    
426
  if (sk_setup_multicast(sk) < 0)
427
    goto err;
428

    
429
  if (sk_join_group(sk, AllRouters) < 0)
430
    goto err;
431

    
432
  ifa->sk = sk;
433
  return 1;
434

    
435
 err:
436
  sk_log_error(sk, ifa->ra->p.name);
437
  rfree(sk);
438
  return 0;
439
}
440