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 "sockopt.h"
45: #include "prefix.h"
46: #include "command.h"
47: #include "memory.h"
48: #include "stream.h"
49: #include "ioctl.h"
50: #include "connected.h"
51: #include "log.h"
52: #include "zclient.h"
53: #include "thread.h"
54: #include "privs.h"
55: #include "zebra/interface.h"
56: #include "zebra/rtadv.h"
57: #include "zebra/rib.h"
58: #include "zebra/zserv.h"
59: #include "zebra/redistribute.h"
60: #include "zebra/irdp.h"
61: #include <netinet/ip_icmp.h>
62:
63: #include "checksum.h"
64: #include "if.h"
65: #include "sockunion.h"
66: #include "log.h"
67:
68: /* GLOBAL VARS */
69:
70: extern struct zebra_privs_t zserv_privs;
71:
72: /* Master of threads. */
73: extern struct zebra_t zebrad;
74: struct thread *t_irdp_raw;
75:
76: /* Timer interval of irdp. */
77: int irdp_timer_interval = IRDP_DEFAULT_INTERVAL;
78:
79: int
80: irdp_sock_init (void)
81: {
82: int ret, i;
83: int save_errno;
84: int sock;
85:
86: if ( zserv_privs.change (ZPRIVS_RAISE) )
87: zlog_err ("irdp_sock_init: could not raise privs, %s",
88: safe_strerror (errno) );
89:
90: sock = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP);
91: save_errno = errno;
92:
93: if ( zserv_privs.change (ZPRIVS_LOWER) )
94: zlog_err ("irdp_sock_init: could not lower privs, %s",
95: safe_strerror (errno) );
96:
97: if (sock < 0) {
98: zlog_warn ("IRDP: can't create irdp socket %s", safe_strerror(save_errno));
99: return sock;
100: };
101:
102: i = 1;
103: ret = setsockopt (sock, IPPROTO_IP, IP_TTL,
104: (void *) &i, sizeof (i));
105: if (ret < 0) {
106: zlog_warn ("IRDP: can't do irdp sockopt %s", safe_strerror(errno));
107: close(sock);
108: return ret;
109: };
110:
111: ret = setsockopt_ifindex (AF_INET, sock, 1);
112: if (ret < 0) {
113: zlog_warn ("IRDP: can't do irdp sockopt %s", safe_strerror(errno));
114: close(sock);
115: return ret;
116: };
117:
118: t_irdp_raw = thread_add_read (zebrad.master, irdp_read_raw, NULL, sock);
119:
120: return sock;
121: }
122:
123:
124: static int
125: get_pref(struct irdp_interface *irdp, struct prefix *p)
126: {
127: struct listnode *node;
128: struct Adv *adv;
129:
130: /* Use default preference or use the override pref */
131:
132: if( irdp->AdvPrefList == NULL )
133: return irdp->Preference;
134:
135: for (ALL_LIST_ELEMENTS_RO (irdp->AdvPrefList, node, adv))
136: if( p->u.prefix4.s_addr == adv->ip.s_addr )
137: return adv->pref;
138:
139: return irdp->Preference;
140: }
141:
142: /* Make ICMP Router Advertisement Message. */
143: static int
144: make_advertisement_packet (struct interface *ifp,
145: struct prefix *p,
146: struct stream *s)
147: {
148: struct zebra_if *zi=ifp->info;
149: struct irdp_interface *irdp=&zi->irdp;
150: int size;
151: int pref;
152: u_int16_t checksum;
153:
154: pref = get_pref(irdp, p);
155:
156: stream_putc (s, ICMP_ROUTERADVERT); /* Type. */
157: stream_putc (s, 0); /* Code. */
158: stream_putw (s, 0); /* Checksum. */
159: stream_putc (s, 1); /* Num address. */
160: stream_putc (s, 2); /* Address Entry Size. */
161:
162: if(irdp->flags & IF_SHUTDOWN)
163: stream_putw (s, 0);
164: else
165: stream_putw (s, irdp->Lifetime);
166:
167: stream_putl (s, htonl(p->u.prefix4.s_addr)); /* Router address. */
168: stream_putl (s, pref);
169:
170: /* in_cksum return network byte order value */
171: size = 16;
172: checksum = in_cksum (s->data, size);
173: stream_putw_at (s, 2, htons(checksum));
174:
175: return size;
176: }
177:
178: static void
179: irdp_send(struct interface *ifp, struct prefix *p, struct stream *s)
180: {
181: struct zebra_if *zi=ifp->info;
182: struct irdp_interface *irdp=&zi->irdp;
183: u_int32_t dst;
184: u_int32_t ttl=1;
185:
186: if (! (ifp->flags & IFF_UP)) return;
187:
188: if (irdp->flags & IF_BROADCAST)
189: dst =INADDR_BROADCAST ;
190: else
191: dst = htonl(INADDR_ALLHOSTS_GROUP);
192:
193: if(irdp->flags & IF_DEBUG_MESSAGES)
194: zlog_debug("IRDP: TX Advert on %s %s/%d Holdtime=%d Preference=%d",
195: ifp->name,
196: inet_ntoa(p->u.prefix4),
197: p->prefixlen,
198: irdp->flags & IF_SHUTDOWN? 0 : irdp->Lifetime,
199: get_pref(irdp, p));
200:
201: send_packet (ifp, s, dst, p, ttl);
202: }
203:
204: static void irdp_advertisement (struct interface *ifp, struct prefix *p)
205: {
206: struct stream *s;
207: s = stream_new (128);
208: make_advertisement_packet (ifp, p, s);
209: irdp_send(ifp, p, s);
210: stream_free (s);
211: }
212:
213: int irdp_send_thread(struct thread *t_advert)
214: {
215: u_int32_t timer, tmp;
216: struct interface *ifp = THREAD_ARG (t_advert);
217: struct zebra_if *zi=ifp->info;
218: struct irdp_interface *irdp=&zi->irdp;
219: struct prefix *p;
220: struct listnode *node, *nnode;
221: struct connected *ifc;
222:
223: irdp->flags &= ~IF_SOLICIT;
224:
225: if(ifp->connected)
226: for (ALL_LIST_ELEMENTS (ifp->connected, node, nnode, ifc))
227: {
228: p = ifc->address;
229:
230: if (p->family != AF_INET)
231: continue;
232:
233: irdp_advertisement(ifp, p);
234: irdp->irdp_sent++;
235: }
236:
237: tmp = irdp->MaxAdvertInterval-irdp->MinAdvertInterval;
238: timer = (random () % tmp ) + 1;
239: timer = irdp->MinAdvertInterval + timer;
240:
241: if(irdp->irdp_sent < MAX_INITIAL_ADVERTISEMENTS &&
242: timer > MAX_INITIAL_ADVERT_INTERVAL )
243: timer= MAX_INITIAL_ADVERT_INTERVAL;
244:
245: if(irdp->flags & IF_DEBUG_MISC)
246: zlog_debug("IRDP: New timer for %s set to %u\n", ifp->name, timer);
247:
248: irdp->t_advertise = thread_add_timer(zebrad.master, irdp_send_thread, ifp, timer);
249: return 0;
250: }
251:
252: void irdp_advert_off(struct interface *ifp)
253: {
254: struct zebra_if *zi=ifp->info;
255: struct irdp_interface *irdp=&zi->irdp;
256: struct listnode *node, *nnode;
257: int i;
258: struct connected *ifc;
259: struct prefix *p;
260:
261: if(irdp->t_advertise) thread_cancel(irdp->t_advertise);
262: irdp->t_advertise = NULL;
263:
264: if(ifp->connected)
265: for (ALL_LIST_ELEMENTS (ifp->connected, node, nnode, ifc))
266: {
267: p = ifc->address;
268:
269: /* Output some packets with Lifetime 0
270: we should add a wait...
271: */
272:
273: for(i=0; i< IRDP_LAST_ADVERT_MESSAGES; i++)
274: {
275: irdp->irdp_sent++;
276: irdp_advertisement(ifp, p);
277: }
278: }
279: }
280:
281:
282: void process_solicit (struct interface *ifp)
283: {
284: struct zebra_if *zi=ifp->info;
285: struct irdp_interface *irdp=&zi->irdp;
286: u_int32_t timer;
287:
288: /* When SOLICIT is active we reject further incoming solicits
289: this keeps down the answering rate so we don't have think
290: about DoS attacks here. */
291:
292: if( irdp->flags & IF_SOLICIT) return;
293:
294: irdp->flags |= IF_SOLICIT;
295: if(irdp->t_advertise) thread_cancel(irdp->t_advertise);
296: irdp->t_advertise = NULL;
297:
298: timer = (random () % MAX_RESPONSE_DELAY) + 1;
299:
300: irdp->t_advertise = thread_add_timer(zebrad.master,
301: irdp_send_thread,
302: ifp,
303: timer);
304: }
305:
306: void irdp_finish()
307: {
308:
309: struct listnode *node, *nnode;
310: struct interface *ifp;
311: struct zebra_if *zi;
312: struct irdp_interface *irdp;
313:
314: zlog_info("IRDP: Received shutdown notification.");
315:
316: for (ALL_LIST_ELEMENTS (iflist, node, nnode, ifp))
317: {
318: zi = ifp->info;
319:
320: if (!zi)
321: continue;
322: irdp = &zi->irdp;
323: if (!irdp)
324: continue;
325:
326: if (irdp->flags & IF_ACTIVE )
327: {
328: irdp->flags |= IF_SHUTDOWN;
329: irdp_advert_off(ifp);
330: }
331: }
332: }
333:
334: #endif /* HAVE_IRDP */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to irdp_main.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / zebra