← Back to branch summary

~ubuntu-branches/ubuntu/breezy/quagga/breezy-security

« back to all changes in this revision

Viewing changes to zebra/irdp_interface.c

  • Committer: Bazaar Package Importer
  • Author(s): Andreas Mueller
  • Date: 2005-05-20 13:16:12 UTC
  • Revision ID: james.westby@ubuntu.com-20050520131612-pr6paalox60o3x3n
Tags: upstream-0.99.1
Import upstream version 0.99.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
zebra/irdp_interface.c
 
1
/*
 
2
 *
 
3
 * Copyright (C) 2000  Robert Olsson.
 
4
 * Swedish University of Agricultural Sciences
 
5
 *
 
6
 * This file is part of GNU Zebra.
 
7
 *
 
8
 * GNU Zebra is free software; you can redistribute it and/or modify it
 
9
 * under the terms of the GNU General Public License as published by the
 
10
 * Free Software Foundation; either version 2, or (at your option) any
 
11
 * later version.
 
12
 *
 
13
 * GNU Zebra is distributed in the hope that it will be useful, but
 
14
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
16
 * General Public License for more details.
 
17
 *
 
18
 * You should have received a copy of the GNU General Public License
 
19
 * along with GNU Zebra; see the file COPYING.  If not, write to the Free
 
20
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 
21
 * 02111-1307, USA.  
 
22
 */
 
23
 
 
24
/* 
 
25
 * This work includes work with the following copywrite:
 
26
 *
 
27
 * Copyright (C) 1997, 2000 Kunihiro Ishiguro
 
28
 *
 
29
 */
 
30
 
 
31
/* 
 
32
 * Thanks to Jens L��s at Swedish University of Agricultural Sciences
 
33
 * for reviewing and tests.
 
34
 */
 
35
 
 
36
 
 
37
#include <zebra.h>
 
38
 
 
39
#ifdef HAVE_IRDP 
 
40
 
 
41
#include "if.h"
 
42
#include "vty.h"
 
43
#include "sockunion.h"
 
44
#include "prefix.h"
 
45
#include "command.h"
 
46
#include "memory.h"
 
47
#include "stream.h"
 
48
#include "ioctl.h"
 
49
#include "connected.h"
 
50
#include "log.h"
 
51
#include "zclient.h"
 
52
#include "thread.h"
 
53
#include "zebra/interface.h"
 
54
#include "zebra/rtadv.h"
 
55
#include "zebra/rib.h"
 
56
#include "zebra/zserv.h"
 
57
#include "zebra/redistribute.h"
 
58
#include "zebra/irdp.h"
 
59
#include <netinet/ip_icmp.h>
 
60
#include "if.h"
 
61
#include "sockunion.h"
 
62
#include "log.h"
 
63
 
 
64
 
 
65
/* Master of threads. */
 
66
extern struct zebra_t zebrad;
 
67
 
 
68
int in_cksum (void *ptr, int nbytes);
 
69
extern int irdp_sock;
 
70
int irdp_send_thread(struct thread *t_advert);
 
71
char *inet_2a(u_int32_t a, char *b);
 
72
void irdp_advert_off(struct interface *ifp);
 
73
 
 
74
 
 
75
char b1[16], b2[16], b3[16], b4[16];  /* For inet_2a */
 
76
 
 
77
static struct prefix *
 
78
irdp_get_prefix(struct interface *ifp)
 
79
{
 
80
  struct listnode *node;
 
81
  struct connected *ifc;
 
82
  
 
83
  if (ifp->connected)
 
84
    for (ALL_LIST_ELEMENTS_RO (ifp->connected, node, ifc))
 
85
      return ifc->address;
 
86
 
 
87
  return NULL;
 
88
}
 
89
 
 
90
/* Join to the add/leave multicast group. */
 
91
static int
 
92
if_group (struct interface *ifp, 
 
93
          int sock, 
 
94
          u_int32_t group, 
 
95
          int add_leave)
 
96
{
 
97
  struct zebra_if *zi;
 
98
  struct ip_mreq m;
 
99
  struct prefix *p;
 
100
  int ret;
 
101
 
 
102
  zi = ifp->info;
 
103
 
 
104
  bzero (&m, sizeof (m));
 
105
  m.imr_multiaddr.s_addr = htonl (group);
 
106
  p = irdp_get_prefix(ifp);
 
107
 
 
108
  if(!p) {
 
109
        zlog_warn ("IRDP: can't get address for %s", ifp->name);
 
110
        return 1;
 
111
  }
 
112
 
 
113
  m.imr_interface = p->u.prefix4;
 
114
 
 
115
  ret = setsockopt (sock, IPPROTO_IP, add_leave,
 
116
                    (char *) &m, sizeof (struct ip_mreq));
 
117
  if (ret < 0)
 
118
    zlog_warn ("IRDP: %s can't setsockopt %s: %s",
 
119
               add_leave == IP_ADD_MEMBERSHIP? "join group":"leave group", 
 
120
               inet_2a(group, b1),
 
121
               safe_strerror (errno));
 
122
 
 
123
  return ret;
 
124
}
 
125
 
 
126
static int
 
127
if_add_group (struct interface *ifp)
 
128
{
 
129
  struct zebra_if *zi= ifp->info;
 
130
  struct irdp_interface *irdp = &zi->irdp;
 
131
  int ret;
 
132
 
 
133
  ret = if_group (ifp, irdp_sock, INADDR_ALLRTRS_GROUP, IP_ADD_MEMBERSHIP);
 
134
  if (ret < 0) {
 
135
    return ret;
 
136
  }
 
137
 
 
138
  if(irdp->flags & IF_DEBUG_MISC )
 
139
    zlog_debug("IRDP: Adding group %s for %s", 
 
140
               inet_2a(htonl(INADDR_ALLRTRS_GROUP), b1),
 
141
               ifp->name);
 
142
  return 0;
 
143
}
 
144
 
 
145
static int
 
146
if_drop_group (struct interface *ifp)
 
147
{
 
148
  struct zebra_if *zi= ifp->info;
 
149
  struct irdp_interface *irdp = &zi->irdp;
 
150
  int ret;
 
151
 
 
152
  ret = if_group (ifp, irdp_sock, INADDR_ALLRTRS_GROUP, IP_DROP_MEMBERSHIP);
 
153
  if (ret < 0)
 
154
    return ret;
 
155
 
 
156
  if(irdp->flags & IF_DEBUG_MISC)
 
157
    zlog_debug("IRDP: Leaving group %s for %s", 
 
158
               inet_2a(htonl(INADDR_ALLRTRS_GROUP), b1),
 
159
               ifp->name);
 
160
  return 0;
 
161
}
 
162
 
 
163
static void
 
164
if_set_defaults(struct interface *ifp)
 
165
{
 
166
  struct zebra_if *zi=ifp->info;
 
167
  struct irdp_interface *irdp=&zi->irdp;
 
168
 
 
169
  irdp->MaxAdvertInterval = IRDP_MAXADVERTINTERVAL;
 
170
  irdp->MinAdvertInterval = IRDP_MINADVERTINTERVAL;
 
171
  irdp->Preference = IRDP_PREFERENCE;
 
172
  irdp->Lifetime = IRDP_LIFETIME;
 
173
}
 
174
 
 
175
 
 
176
struct Adv *Adv_new (void)
 
177
{
 
178
  struct Adv *new;
 
179
  new = XMALLOC (MTYPE_TMP, sizeof (struct Adv));
 
180
  memset (new, 0, sizeof (struct Adv));
 
181
  return new;
 
182
}
 
183
 
 
184
static void
 
185
Adv_free (struct Adv *adv)
 
186
{
 
187
  XFREE (MTYPE_TMP, adv);
 
188
}
 
189
 
 
190
static void
 
191
irdp_if_start(struct interface *ifp, int multicast, int set_defaults)
 
192
{
 
193
  struct zebra_if *zi= ifp->info;
 
194
  struct irdp_interface *irdp = &zi->irdp;
 
195
  struct listnode *node;
 
196
  struct connected *ifc;
 
197
  u_int32_t timer, seed;
 
198
 
 
199
  if (irdp->flags & IF_ACTIVE ) {
 
200
    zlog_warn("IRDP: Interface is already active %s", ifp->name);
 
201
    return;
 
202
  }
 
203
  if ((irdp_sock < 0) && ((irdp_sock = irdp_sock_init()) < 0)) {
 
204
    zlog_warn("IRDP: Cannot activate interface %s (cannot create "
 
205
              "IRDP socket)", ifp->name);
 
206
    return;
 
207
  }
 
208
  irdp->flags |= IF_ACTIVE;
 
209
 
 
210
  if(!multicast) 
 
211
    irdp->flags |= IF_BROADCAST;
 
212
 
 
213
  if_add_update(ifp);
 
214
 
 
215
  if (! (ifp->flags & IFF_UP)) {
 
216
    zlog_warn("IRDP: Interface is down %s", ifp->name);
 
217
  }
 
218
 
 
219
  /* Shall we cancel if_start if if_add_group fails? */
 
220
 
 
221
  if( multicast) {
 
222
    if_add_group(ifp);
 
223
    
 
224
    if (! (ifp->flags & (IFF_MULTICAST|IFF_ALLMULTI))) {
 
225
      zlog_warn("IRDP: Interface not multicast enabled %s", ifp->name);
 
226
    }
 
227
  }
 
228
 
 
229
  if(set_defaults) 
 
230
    if_set_defaults(ifp);
 
231
 
 
232
  irdp->irdp_sent = 0;
 
233
 
 
234
  /* The spec suggests this for randomness */
 
235
 
 
236
  seed = 0;
 
237
  if( ifp->connected)
 
238
    for (ALL_LIST_ELEMENTS_RO (ifp->connected, node, ifc))
 
239
      {
 
240
        seed = ifc->address->u.prefix4.s_addr;
 
241
        break;
 
242
      }
 
243
  
 
244
  srandom(seed);
 
245
  timer =  (random () % IRDP_DEFAULT_INTERVAL) + 1; 
 
246
 
 
247
  irdp->AdvPrefList = list_new();
 
248
  irdp->AdvPrefList->del =  (void (*)(void *)) Adv_free; /* Destructor */
 
249
 
 
250
 
 
251
  /* And this for startup. Speed limit from 1991 :-). But it's OK*/
 
252
 
 
253
  if(irdp->irdp_sent < MAX_INITIAL_ADVERTISEMENTS &&
 
254
     timer > MAX_INITIAL_ADVERT_INTERVAL ) 
 
255
          timer= MAX_INITIAL_ADVERT_INTERVAL;
 
256
 
 
257
  
 
258
  if(irdp->flags & IF_DEBUG_MISC)
 
259
    zlog_debug("IRDP: Init timer for %s set to %u", 
 
260
               ifp->name, 
 
261
               timer);
 
262
 
 
263
  irdp->t_advertise = thread_add_timer(zebrad.master, 
 
264
                                       irdp_send_thread, 
 
265
                                       ifp, 
 
266
                                       timer);
 
267
}
 
268
 
 
269
static void
 
270
irdp_if_stop(struct interface *ifp)
 
271
{
 
272
  struct zebra_if *zi=ifp->info;
 
273
  struct irdp_interface *irdp=&zi->irdp;
 
274
  
 
275
  if (irdp == NULL) {
 
276
    zlog_warn ("Interface %s structure is NULL", ifp->name);
 
277
    return;
 
278
  }
 
279
 
 
280
  if (! (irdp->flags & IF_ACTIVE )) {
 
281
    zlog_warn("Interface is not active %s", ifp->name);
 
282
    return;
 
283
  }
 
284
 
 
285
  if(! (irdp->flags & IF_BROADCAST)) 
 
286
    if_drop_group(ifp);
 
287
 
 
288
  irdp_advert_off(ifp);
 
289
 
 
290
  list_delete(irdp->AdvPrefList);
 
291
  irdp->AdvPrefList=NULL;
 
292
 
 
293
  irdp->flags = 0;
 
294
}
 
295
 
 
296
 
 
297
static void
 
298
irdp_if_shutdown(struct interface *ifp)
 
299
{
 
300
  struct zebra_if *zi= ifp->info;
 
301
  struct irdp_interface *irdp = &zi->irdp;
 
302
 
 
303
  if (irdp->flags & IF_SHUTDOWN ) {
 
304
    zlog_warn("IRDP: Interface is already shutdown %s", ifp->name);
 
305
    return;
 
306
  }
 
307
 
 
308
  irdp->flags |= IF_SHUTDOWN;
 
309
  irdp->flags &= ~IF_ACTIVE;
 
310
 
 
311
  if(! (irdp->flags & IF_BROADCAST)) 
 
312
    if_drop_group(ifp);
 
313
  
 
314
  /* Tell the hosts we are out of service */
 
315
  irdp_advert_off(ifp);
 
316
}
 
317
 
 
318
static void
 
319
irdp_if_no_shutdown(struct interface *ifp)
 
320
{
 
321
  struct zebra_if *zi= ifp->info;
 
322
  struct irdp_interface *irdp = &zi->irdp;
 
323
 
 
324
  if (! (irdp->flags & IF_SHUTDOWN )) {
 
325
    zlog_warn("IRDP: Interface is not shutdown %s", ifp->name);
 
326
    return;
 
327
  }
 
328
 
 
329
  irdp->flags &= ~IF_SHUTDOWN;
 
330
 
 
331
  irdp_if_start(ifp, irdp->flags & IF_BROADCAST? FALSE : TRUE, FALSE); 
 
332
 
 
333
}
 
334
 
 
335
 
 
336
/* Write configuration to user */
 
337
 
 
338
void irdp_config_write (struct vty *vty, struct interface *ifp)
 
339
{
 
340
  struct zebra_if *zi=ifp->info;
 
341
  struct irdp_interface *irdp=&zi->irdp;
 
342
  struct Adv *adv;
 
343
  struct listnode *node;
 
344
 
 
345
  if(irdp->flags & IF_ACTIVE || irdp->flags & IF_SHUTDOWN) {
 
346
 
 
347
    if( irdp->flags & IF_SHUTDOWN) 
 
348
      vty_out (vty, " ip irdp shutdown %s",  VTY_NEWLINE);
 
349
 
 
350
    if( irdp->flags & IF_BROADCAST) 
 
351
      vty_out (vty, " ip irdp broadcast%s",  VTY_NEWLINE);
 
352
    else 
 
353
      vty_out (vty, " ip irdp multicast%s",  VTY_NEWLINE);
 
354
 
 
355
    vty_out (vty, " ip irdp preference %ld%s",  
 
356
             irdp->Preference, VTY_NEWLINE);
 
357
 
 
358
    for (ALL_LIST_ELEMENTS_RO (irdp->AdvPrefList, node, adv))
 
359
      vty_out (vty, " ip irdp address %s preference %d%s",
 
360
                    inet_2a(adv->ip.s_addr, b1),
 
361
                    adv->pref, 
 
362
                    VTY_NEWLINE);
 
363
 
 
364
    vty_out (vty, " ip irdp holdtime %d%s",  
 
365
             irdp->Lifetime, VTY_NEWLINE);
 
366
 
 
367
    vty_out (vty, " ip irdp minadvertinterval %ld%s",  
 
368
             irdp->MinAdvertInterval, VTY_NEWLINE);
 
369
 
 
370
    vty_out (vty, " ip irdp maxadvertinterval %ld%s",  
 
371
             irdp->MaxAdvertInterval, VTY_NEWLINE);
 
372
 
 
373
  }
 
374
}
 
375
 
 
376
 
 
377
DEFUN (ip_irdp_multicast,
 
378
       ip_irdp_multicast_cmd,
 
379
       "ip irdp multicast",
 
380
       IP_STR
 
381
       "ICMP Router discovery on this interface using multicast\n")
 
382
{
 
383
  struct interface *ifp;
 
384
 
 
385
  ifp = (struct interface *) vty->index;
 
386
  if(!ifp) {
 
387
          return CMD_WARNING;
 
388
  }
 
389
 
 
390
  irdp_if_start(ifp, TRUE, TRUE);
 
391
  return CMD_SUCCESS;
 
392
}
 
393
 
 
394
DEFUN (ip_irdp_broadcast,
 
395
       ip_irdp_broadcast_cmd,
 
396
       "ip irdp broadcast",
 
397
       IP_STR
 
398
       "ICMP Router discovery on this interface using broadcast\n")
 
399
{
 
400
  struct interface *ifp;
 
401
 
 
402
  ifp = (struct interface *) vty->index;
 
403
  if(!ifp) {
 
404
          return CMD_WARNING;
 
405
  }
 
406
 
 
407
  irdp_if_start(ifp, FALSE, TRUE);
 
408
  return CMD_SUCCESS;
 
409
}
 
410
 
 
411
DEFUN (no_ip_irdp,
 
412
       no_ip_irdp_cmd,
 
413
       "no ip irdp",
 
414
       NO_STR
 
415
       IP_STR
 
416
       "Disable ICMP Router discovery on this interface\n")
 
417
{
 
418
  struct interface *ifp;
 
419
 
 
420
  ifp = (struct interface *) vty->index;
 
421
  if(!ifp) {
 
422
          return CMD_WARNING;
 
423
  }
 
424
 
 
425
  irdp_if_stop(ifp);
 
426
  return CMD_SUCCESS;
 
427
}
 
428
 
 
429
DEFUN (ip_irdp_shutdown,
 
430
       ip_irdp_shutdown_cmd,
 
431
       "ip irdp shutdown",
 
432
       IP_STR
 
433
       "ICMP Router discovery shutdown on this interface\n")
 
434
{
 
435
  struct interface *ifp;
 
436
 
 
437
  ifp = (struct interface *) vty->index;
 
438
  if(!ifp) {
 
439
          return CMD_WARNING;
 
440
  }
 
441
 
 
442
  irdp_if_shutdown(ifp);
 
443
  return CMD_SUCCESS;
 
444
}
 
445
 
 
446
DEFUN (no_ip_irdp_shutdown,
 
447
       no_ip_irdp_shutdown_cmd,
 
448
       "no ip irdp shutdown",
 
449
       NO_STR
 
450
       IP_STR
 
451
       "ICMP Router discovery no shutdown on this interface\n")
 
452
{
 
453
  struct interface *ifp;
 
454
 
 
455
  ifp = (struct interface *) vty->index;
 
456
  if(!ifp) {
 
457
          return CMD_WARNING;
 
458
  }
 
459
 
 
460
  irdp_if_no_shutdown(ifp);
 
461
  return CMD_SUCCESS;
 
462
}
 
463
 
 
464
DEFUN (ip_irdp_holdtime,
 
465
       ip_irdp_holdtime_cmd,
 
466
       "ip irdp holdtime <0-9000>",
 
467
       IP_STR
 
468
       "ICMP Router discovery on this interface\n"
 
469
       "Set holdtime value\n"
 
470
       "Holdtime value in seconds. Default is 1800 seconds\n")
 
471
{
 
472
  struct interface *ifp;
 
473
  struct zebra_if *zi;
 
474
  struct irdp_interface *irdp;
 
475
  ifp = (struct interface *) vty->index;
 
476
  if(!ifp) {
 
477
          return CMD_WARNING;
 
478
  }
 
479
 
 
480
  zi=ifp->info;
 
481
  irdp=&zi->irdp;
 
482
 
 
483
  irdp->Lifetime = atoi(argv[0]);
 
484
  return CMD_SUCCESS;
 
485
}
 
486
 
 
487
DEFUN (ip_irdp_minadvertinterval,
 
488
       ip_irdp_minadvertinterval_cmd,
 
489
       "ip irdp minadvertinterval <3-1800>",
 
490
       IP_STR
 
491
       "ICMP Router discovery on this interface\n"
 
492
       "Set minimum time between advertisement\n"
 
493
       "Minimum advertisement interval in seconds\n")
 
494
{
 
495
  struct interface *ifp;
 
496
  struct zebra_if *zi;
 
497
  struct irdp_interface *irdp;
 
498
  ifp = (struct interface *) vty->index;
 
499
  if(!ifp) {
 
500
          return CMD_WARNING;
 
501
  }
 
502
 
 
503
  zi=ifp->info;
 
504
  irdp=&zi->irdp;
 
505
 
 
506
  if( (unsigned) atoi(argv[0]) <= irdp->MaxAdvertInterval) {
 
507
      irdp->MinAdvertInterval = atoi(argv[0]);
 
508
 
 
509
      return CMD_SUCCESS;
 
510
  }
 
511
 
 
512
  vty_out (vty, "ICMP warning maxadvertinterval is greater or equal than minadvertinterval%s", 
 
513
             VTY_NEWLINE);
 
514
 
 
515
  vty_out (vty, "Please correct!%s", 
 
516
             VTY_NEWLINE);
 
517
  return CMD_WARNING;
 
518
}
 
519
 
 
520
DEFUN (ip_irdp_maxadvertinterval,
 
521
       ip_irdp_maxadvertinterval_cmd,
 
522
       "ip irdp maxadvertinterval <4-1800>",
 
523
       IP_STR
 
524
       "ICMP Router discovery on this interface\n"
 
525
       "Set maximum time between advertisement\n"
 
526
       "Maximum advertisement interval in seconds\n")
 
527
{
 
528
  struct interface *ifp;
 
529
  struct zebra_if *zi;
 
530
  struct irdp_interface *irdp;
 
531
  ifp = (struct interface *) vty->index;
 
532
  if(!ifp) {
 
533
          return CMD_WARNING;
 
534
  }
 
535
 
 
536
  zi=ifp->info;
 
537
  irdp=&zi->irdp;
 
538
 
 
539
 
 
540
  if( irdp->MinAdvertInterval <= (unsigned) atoi(argv[0]) ) {
 
541
    irdp->MaxAdvertInterval = atoi(argv[0]);
 
542
 
 
543
      return CMD_SUCCESS;
 
544
  }
 
545
 
 
546
  vty_out (vty, "ICMP warning maxadvertinterval is greater or equal than minadvertinterval%s", 
 
547
             VTY_NEWLINE);
 
548
 
 
549
  vty_out (vty, "Please correct!%s", 
 
550
             VTY_NEWLINE);
 
551
  return CMD_WARNING;
 
552
}
 
553
 
 
554
/* DEFUN needs to be fixed for negative ranages...
 
555
 * "ip irdp preference <-2147483648-2147483647>",
 
556
 * Be positive for now. :-)
 
557
 */
 
558
 
 
559
DEFUN (ip_irdp_preference,
 
560
       ip_irdp_preference_cmd,
 
561
       "ip irdp preference <0-2147483647>",
 
562
       IP_STR
 
563
       "ICMP Router discovery on this interface\n"
 
564
       "Set default preference level for this interface\n"
 
565
       "Preference level\n")
 
566
{
 
567
  struct interface *ifp;
 
568
  struct zebra_if *zi;
 
569
  struct irdp_interface *irdp;
 
570
  ifp = (struct interface *) vty->index;
 
571
  if(!ifp) {
 
572
          return CMD_WARNING;
 
573
  }
 
574
 
 
575
  zi=ifp->info;
 
576
  irdp=&zi->irdp;
 
577
 
 
578
  irdp->Preference = atoi(argv[0]);
 
579
  return CMD_SUCCESS;
 
580
}
 
581
 
 
582
DEFUN (ip_irdp_address_preference,
 
583
       ip_irdp_address_preference_cmd,
 
584
       "ip irdp address A.B.C.D preference <0-2147483647>",
 
585
       IP_STR
 
586
       "Alter ICMP Router discovery preference this interface\n"
 
587
       "Specify IRDP non-default preference to advertise\n"
 
588
       "Set IRDP address for advertise\n"
 
589
       "Preference level\n")
 
590
{
 
591
  struct listnode *node;
 
592
  struct in_addr ip; 
 
593
  int pref;
 
594
  int ret;
 
595
  struct interface *ifp;
 
596
  struct zebra_if *zi;
 
597
  struct irdp_interface *irdp;
 
598
  struct Adv *adv;
 
599
 
 
600
  ifp = (struct interface *) vty->index;
 
601
  if(!ifp) {
 
602
          return CMD_WARNING;
 
603
  }
 
604
 
 
605
  zi=ifp->info;
 
606
  irdp=&zi->irdp;
 
607
 
 
608
  ret = inet_aton(argv[0], &ip);
 
609
  if(!ret) return CMD_WARNING;
 
610
 
 
611
  pref = atoi(argv[1]);
 
612
 
 
613
  for (ALL_LIST_ELEMENTS_RO (irdp->AdvPrefList, node, adv))
 
614
    if(adv->ip.s_addr == ip.s_addr) 
 
615
      return CMD_SUCCESS;
 
616
 
 
617
  adv = Adv_new();
 
618
  adv->ip = ip;
 
619
  adv->pref = pref;
 
620
  listnode_add(irdp->AdvPrefList, adv);
 
621
 
 
622
  return CMD_SUCCESS;
 
623
 
 
624
}
 
625
 
 
626
DEFUN (no_ip_irdp_address_preference,
 
627
       no_ip_irdp_address_preference_cmd,
 
628
       "no ip irdp address A.B.C.D preference <0-2147483647>",
 
629
       NO_STR
 
630
       IP_STR
 
631
       "Alter ICMP Router discovery preference this interface\n"
 
632
       "Removes IRDP non-default preference\n"
 
633
       "Select IRDP address\n"
 
634
       "Old preference level\n")
 
635
{
 
636
  struct listnode *node, *nnode;
 
637
  struct in_addr ip; 
 
638
  int pref;
 
639
  int ret;
 
640
  struct interface *ifp;
 
641
  struct zebra_if *zi;
 
642
  struct irdp_interface *irdp;
 
643
  struct Adv *adv;
 
644
 
 
645
  ifp = (struct interface *) vty->index;
 
646
  if(!ifp) {
 
647
          return CMD_WARNING;
 
648
  }
 
649
 
 
650
  zi=ifp->info;
 
651
  irdp=&zi->irdp;
 
652
 
 
653
  ret = inet_aton(argv[0], &ip);
 
654
  if (!ret) 
 
655
    return CMD_WARNING;
 
656
 
 
657
  pref = atoi(argv[1]);
 
658
 
 
659
  for (ALL_LIST_ELEMENTS (irdp->AdvPrefList, node, nnode, adv))
 
660
    {
 
661
      if(adv->ip.s_addr == ip.s_addr )
 
662
        {
 
663
          listnode_delete(irdp->AdvPrefList, adv);
 
664
          break;
 
665
        }
 
666
    }
 
667
  
 
668
  return CMD_SUCCESS;
 
669
}
 
670
 
 
671
DEFUN (ip_irdp_debug_messages,
 
672
       ip_irdp_debug_messages_cmd,
 
673
       "ip irdp debug messages",
 
674
       IP_STR
 
675
       "ICMP Router discovery debug Averts. and Solicits (short)\n")
 
676
{
 
677
  struct interface *ifp;
 
678
  struct zebra_if *zi;
 
679
  struct irdp_interface *irdp;
 
680
  ifp = (struct interface *) vty->index;
 
681
  if(!ifp) {
 
682
          return CMD_WARNING;
 
683
  }
 
684
 
 
685
  zi=ifp->info;
 
686
  irdp=&zi->irdp;
 
687
 
 
688
  irdp->flags |= IF_DEBUG_MESSAGES;
 
689
 
 
690
  return CMD_SUCCESS;
 
691
}
 
692
 
 
693
DEFUN (ip_irdp_debug_misc,
 
694
       ip_irdp_debug_misc_cmd,
 
695
       "ip irdp debug misc",
 
696
       IP_STR
 
697
       "ICMP Router discovery debug Averts. and Solicits (short)\n")
 
698
{
 
699
  struct interface *ifp;
 
700
  struct zebra_if *zi;
 
701
  struct irdp_interface *irdp;
 
702
  ifp = (struct interface *) vty->index;
 
703
  if(!ifp) {
 
704
          return CMD_WARNING;
 
705
  }
 
706
 
 
707
  zi=ifp->info;
 
708
  irdp=&zi->irdp;
 
709
 
 
710
  irdp->flags |= IF_DEBUG_MISC;
 
711
 
 
712
  return CMD_SUCCESS;
 
713
}
 
714
 
 
715
DEFUN (ip_irdp_debug_packet,
 
716
       ip_irdp_debug_packet_cmd,
 
717
       "ip irdp debug packet",
 
718
       IP_STR
 
719
       "ICMP Router discovery debug Averts. and Solicits (short)\n")
 
720
{
 
721
  struct interface *ifp;
 
722
  struct zebra_if *zi;
 
723
  struct irdp_interface *irdp;
 
724
  ifp = (struct interface *) vty->index;
 
725
  if(!ifp) {
 
726
          return CMD_WARNING;
 
727
  }
 
728
 
 
729
  zi=ifp->info;
 
730
  irdp=&zi->irdp;
 
731
 
 
732
  irdp->flags |= IF_DEBUG_PACKET;
 
733
 
 
734
  return CMD_SUCCESS;
 
735
}
 
736
 
 
737
 
 
738
DEFUN (ip_irdp_debug_disable,
 
739
       ip_irdp_debug_disable_cmd,
 
740
       "ip irdp debug disable",
 
741
       IP_STR
 
742
       "ICMP Router discovery debug Averts. and Solicits (short)\n")
 
743
{
 
744
  struct interface *ifp;
 
745
  struct zebra_if *zi;
 
746
  struct irdp_interface *irdp;
 
747
  ifp = (struct interface *) vty->index;
 
748
  if(!ifp) {
 
749
          return CMD_WARNING;
 
750
  }
 
751
 
 
752
  zi=ifp->info;
 
753
  irdp=&zi->irdp;
 
754
 
 
755
  irdp->flags &= ~IF_DEBUG_PACKET;
 
756
  irdp->flags &= ~IF_DEBUG_MESSAGES;
 
757
  irdp->flags &= ~IF_DEBUG_MISC;
 
758
 
 
759
  return CMD_SUCCESS;
 
760
}
 
761
 
 
762
void
 
763
irdp_init ()
 
764
{
 
765
  install_element (INTERFACE_NODE, &ip_irdp_broadcast_cmd);
 
766
  install_element (INTERFACE_NODE, &ip_irdp_multicast_cmd);
 
767
  install_element (INTERFACE_NODE, &no_ip_irdp_cmd);
 
768
  install_element (INTERFACE_NODE, &ip_irdp_shutdown_cmd);
 
769
  install_element (INTERFACE_NODE, &no_ip_irdp_shutdown_cmd);
 
770
  install_element (INTERFACE_NODE, &ip_irdp_holdtime_cmd);
 
771
  install_element (INTERFACE_NODE, &ip_irdp_maxadvertinterval_cmd);
 
772
  install_element (INTERFACE_NODE, &ip_irdp_minadvertinterval_cmd);
 
773
  install_element (INTERFACE_NODE, &ip_irdp_preference_cmd);
 
774
  install_element (INTERFACE_NODE, &ip_irdp_address_preference_cmd);
 
775
  install_element (INTERFACE_NODE, &no_ip_irdp_address_preference_cmd);
 
776
 
 
777
  install_element (INTERFACE_NODE, &ip_irdp_debug_messages_cmd);
 
778
  install_element (INTERFACE_NODE, &ip_irdp_debug_misc_cmd);
 
779
  install_element (INTERFACE_NODE, &ip_irdp_debug_packet_cmd);
 
780
  install_element (INTERFACE_NODE, &ip_irdp_debug_disable_cmd);
 
781
}
 
782
 
 
783
#endif /* HAVE_IRDP */