Annotation of embedaddon/mrouted/rsrr.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Copyright (c) 1993, 1998-2001.
3: * The University of Southern California/Information Sciences Institute.
4: * All rights reserved.
5: *
6: * Redistribution and use in source and binary forms, with or without
7: * modification, are permitted provided that the following conditions
8: * are met:
9: * 1. Redistributions of source code must retain the above copyright
10: * notice, this list of conditions and the following disclaimer.
11: * 2. Redistributions in binary form must reproduce the above copyright
12: * notice, this list of conditions and the following disclaimer in the
13: * documentation and/or other materials provided with the distribution.
14: * 3. Neither the name of the project nor the names of its contributors
15: * may be used to endorse or promote products derived from this software
16: * without specific prior written permission.
17: *
18: * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
19: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21: * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
22: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28: * SUCH DAMAGE.
29: */
30:
31: /* RSRR code written by Daniel Zappala, USC Information Sciences Institute,
32: * April 1995.
33: */
34:
35: /* May 1995 -- Added support for Route Change Notification */
36:
37: #ifdef RSRR
38:
39: #include "defs.h"
40: #include <sys/param.h>
41: #ifdef HAVE_SA_LEN
42: #include <stddef.h> /* for offsetof */
43: #endif
44:
45: /*
46: * Local RSRR variables.
47: */
48: static int rsrr_socket; /* interface to reservation protocol */
49: static char *rsrr_recv_buf; /* RSRR receive buffer */
50: static char *rsrr_send_buf; /* RSRR send buffer */
51:
52: static struct sockaddr_un client_addr;
53: static socklen_t client_length = sizeof(client_addr);
54:
55: /*
56: * Procedure definitions needed internally.
57: */
58: static void rsrr_accept(size_t recvlen);
59: static void rsrr_accept_iq(void);
60: static int rsrr_accept_rq(struct rsrr_rq *route_query, u_char flags, struct gtable *gt_notify);
61: static void rsrr_read(int, fd_set *);
62: static int rsrr_send(int sendlen);
63: static void rsrr_cache(struct gtable *gt, struct rsrr_rq *route_query);
64:
65: /* Initialize RSRR socket */
66: void rsrr_init(void)
67: {
68: int servlen;
69: struct sockaddr_un serv_addr;
70:
71: rsrr_recv_buf = (char *)malloc(RSRR_MAX_LEN);
72: rsrr_send_buf = (char *)malloc(RSRR_MAX_LEN);
73: if (!rsrr_recv_buf || !rsrr_send_buf)
74: logit(LOG_ERR, 0, "Ran out of memory in rsrr_init()");
75:
76: if ((rsrr_socket = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0)
77: logit(LOG_ERR, errno, "Cannot create RSRR socket");
78:
79: unlink(RSRR_SERV_PATH);
80: memset(&serv_addr, 0, sizeof(serv_addr));
81: serv_addr.sun_family = AF_UNIX;
82: strlcpy(serv_addr.sun_path, RSRR_SERV_PATH, sizeof(serv_addr.sun_path));
83: #ifdef HAVE_SA_LEN
84: servlen = offsetof(struct sockaddr_un, sun_path) + strlen(serv_addr.sun_path);
85: serv_addr.sun_len = servlen;
86: #else
87: servlen = sizeof(serv_addr.sun_family) + strlen(serv_addr.sun_path);
88: #endif
89:
90: if (bind(rsrr_socket, (struct sockaddr *) &serv_addr, servlen) < 0)
91: logit(LOG_ERR, errno, "Cannot bind RSRR socket");
92:
93: if (register_input_handler(rsrr_socket, rsrr_read) < 0)
94: logit(LOG_ERR, 0, "Could not register RSRR as an input handler");
95: }
96:
97: /* Read a message from the RSRR socket */
98: static void rsrr_read(int fd, fd_set UNUSED *rfd)
99: {
100: ssize_t rsrr_recvlen;
101:
102: memset(&client_addr, 0, sizeof(client_addr));
103: rsrr_recvlen = recvfrom(fd, rsrr_recv_buf, sizeof(rsrr_recv_buf),
104: 0, (struct sockaddr *)&client_addr, &client_length);
105: if (rsrr_recvlen < 0) {
106: if (errno != EINTR)
107: logit(LOG_ERR, errno, "RSRR recvfrom");
108: return;
109: }
110: rsrr_accept(rsrr_recvlen);
111: }
112:
113: /* Accept a message from the reservation protocol and take
114: * appropriate action.
115: */
116: static void rsrr_accept(size_t recvlen)
117: {
118: struct rsrr_header *rsrr = (struct rsrr_header *)rsrr_recv_buf;
119: struct rsrr_rq *route_query;
120:
121: if (recvlen < RSRR_HEADER_LEN) {
122: logit(LOG_WARNING, 0, "Received RSRR packet of %d bytes, which is less than MIN size %d.",
123: recvlen, RSRR_HEADER_LEN);
124: return;
125: }
126:
127: if (rsrr->version > RSRR_MAX_VERSION || rsrr->version != 1) {
128: logit(LOG_WARNING, 0, "Received RSRR packet version %d, which I don't understand",
129: rsrr->version);
130: return;
131: }
132:
133: switch (rsrr->type) {
134: case RSRR_INITIAL_QUERY:
135: /* Send Initial Reply to client */
136: IF_DEBUG(DEBUG_RSRR) {
137: logit(LOG_DEBUG, 0, "Received Initial Query\n");
138: }
139: rsrr_accept_iq();
140: break;
141:
142: case RSRR_ROUTE_QUERY:
143: /* Check size */
144: if (recvlen < RSRR_RQ_LEN) {
145: logit(LOG_WARNING, 0, "Received Route Query of %d bytes, which is too small", recvlen);
146: break;
147: }
148: /* Get the query */
149: route_query = (struct rsrr_rq *) (rsrr_recv_buf + RSRR_HEADER_LEN);
150: IF_DEBUG(DEBUG_RSRR) {
151: logit(LOG_DEBUG, 0,
152: "Received Route Query for src %s grp %s notification %d",
153: inet_fmt(route_query->source_addr.s_addr, s1, sizeof(s1)),
154: inet_fmt(route_query->dest_addr.s_addr, s2, sizeof(s2)),
155: BIT_TST(rsrr->flags,RSRR_NOTIFICATION_BIT));
156: }
157: /* Send Route Reply to client */
158: rsrr_accept_rq(route_query, rsrr->flags, NULL);
159: break;
160:
161: default:
162: logit(LOG_WARNING, 0, "Received RSRR packet type %d, which I don't handle", rsrr->type);
163: break;
164: }
165: }
166:
167: /* Send an Initial Reply to the reservation protocol. */
168: static void rsrr_accept_iq(void)
169: {
170: struct rsrr_header *rsrr = (struct rsrr_header *)rsrr_send_buf;
171: struct rsrr_vif *vif_list;
172: struct uvif *v;
173: int vifi, sendlen;
174:
175: /* Check for space. There should be room for plenty of vifs,
176: * but we should check anyway.
177: */
178: if (numvifs > RSRR_MAX_VIFS) {
179: logit(LOG_WARNING, 0,
180: "Cannot send RSRR Route Reply because %d is too many vifs %d",
181: numvifs);
182: return;
183: }
184:
185: /* Set up message */
186: rsrr->version = 1;
187: rsrr->type = RSRR_INITIAL_REPLY;
188: rsrr->flags = 0;
189: rsrr->num = numvifs;
190:
191: vif_list = (struct rsrr_vif *)(rsrr_send_buf + RSRR_HEADER_LEN);
192:
193: /* Include the vif list. */
194: for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) {
195: vif_list[vifi].id = vifi;
196: vif_list[vifi].status = 0;
197: if (v->uv_flags & VIFF_DISABLED)
198: BIT_SET(vif_list[vifi].status,RSRR_DISABLED_BIT);
199: vif_list[vifi].threshold = v->uv_threshold;
200: vif_list[vifi].local_addr.s_addr = v->uv_lcl_addr;
201: }
202:
203: /* Get the size. */
204: sendlen = RSRR_HEADER_LEN + numvifs*RSRR_VIF_LEN;
205:
206: /* Send it. */
207: IF_DEBUG(DEBUG_RSRR) {
208: logit(LOG_DEBUG, 0, "Send RSRR Initial Reply");
209: }
210: rsrr_send(sendlen);
211: }
212:
213: /* Send a Route Reply to the reservation protocol. The Route Query
214: * contains the query to which we are responding. The flags contain
215: * the incoming flags from the query or, for route change
216: * notification, the flags that should be set for the reply. The
217: * kernel table entry contains the routing info to use for a route
218: * change notification.
219: */
220: /* XXX: must modify if your routing table structure/search is different */
221: static int rsrr_accept_rq(struct rsrr_rq *route_query, u_char flags, struct gtable *gt_notify)
222: {
223: struct rsrr_header *rsrr = (struct rsrr_header *)rsrr_send_buf;
224: struct rsrr_rr *route_reply;
225: struct gtable *gt,local_g;
226: struct rtentry *r;
227: int sendlen;
228: u_long mcastgrp;
229:
230: /* Set up message */
231: rsrr->version = 1;
232: rsrr->type = RSRR_ROUTE_REPLY;
233: rsrr->flags = 0;
234: rsrr->num = 0;
235:
236: route_reply = (struct rsrr_rr *) (rsrr_send_buf + RSRR_HEADER_LEN);
237: route_reply->dest_addr.s_addr = route_query->dest_addr.s_addr;
238: route_reply->source_addr.s_addr = route_query->source_addr.s_addr;
239: route_reply->query_id = route_query->query_id;
240:
241: /* Blank routing entry for error. */
242: route_reply->in_vif = 0;
243: route_reply->reserved = 0;
244: route_reply->out_vif_bm = 0;
245:
246: /* Get the size. */
247: sendlen = RSRR_RR_LEN;
248:
249: /* If kernel table entry is defined, then we are sending a Route Reply
250: * due to a Route Change Notification event. Use the kernel table entry
251: * to supply the routing info.
252: */
253: if (gt_notify) {
254: /* Set flags */
255: rsrr->flags = flags;
256: /* Include the routing entry. */
257: route_reply->in_vif = gt_notify->gt_route->rt_parent;
258: if (BIT_TST(flags,RSRR_NOTIFICATION_BIT))
259: route_reply->out_vif_bm = gt_notify->gt_grpmems;
260: else
261: route_reply->out_vif_bm = 0;
262: } else if (find_src_grp(route_query->source_addr.s_addr, 0,
263: route_query->dest_addr.s_addr)) {
264:
265: /* Found kernel entry. Code taken from add_table_entry() */
266: gt = gtp ? gtp->gt_gnext : kernel_table;
267:
268: /* Include the routing entry. */
269: route_reply->in_vif = gt->gt_route->rt_parent;
270: route_reply->out_vif_bm = gt->gt_grpmems;
271:
272: /* Cache reply if using route change notification. */
273: if (BIT_TST(flags, RSRR_NOTIFICATION_BIT)) {
274: /* TODO: XXX: Originally the rsrr_cache() call was first, but
275: * I think this is incorrect, because rsrr_cache() checks the
276: * rsrr_send_buf "flag" first.
277: */
278: BIT_SET(rsrr->flags, RSRR_NOTIFICATION_BIT);
279: rsrr_cache(gt, route_query);
280: }
281: } else {
282: /* No kernel entry; use routing table. */
283: r = determine_route(route_query->source_addr.s_addr);
284:
285: if (r != NULL) {
286: /* We need to mimic what will happen if a data packet
287: * is forwarded by multicast routing -- the kernel will
288: * make an upcall and mrouted will install a route in the kernel.
289: * Our outgoing vif bitmap should reflect what that table
290: * will look like. Grab code from add_table_entry().
291: * This is gross, but it's probably better to be accurate.
292: */
293:
294: gt = &local_g;
295: mcastgrp = route_query->dest_addr.s_addr;
296:
297: gt->gt_mcastgrp = mcastgrp;
298: gt->gt_grpmems = 0;
299: gt->gt_scope = 0;
300: gt->gt_route = r;
301:
302: /* obtain the multicast group membership list */
303: determine_forwvifs(gt);
304:
305: /* Include the routing entry. */
306: route_reply->in_vif = gt->gt_route->rt_parent;
307: route_reply->out_vif_bm = gt->gt_grpmems;
308: } else {
309: /* Set error bit. */
310: BIT_SET(rsrr->flags, RSRR_ERROR_BIT);
311: }
312: }
313:
314: IF_DEBUG(DEBUG_RSRR) {
315: logit(LOG_DEBUG, 0, "%sSend RSRR Route Reply for src %s dst %s in vif %d out vif %d\n",
316: gt_notify ? "Route Change: " : "",
317: inet_fmt(route_reply->source_addr.s_addr, s1, sizeof(s1)),
318: inet_fmt(route_reply->dest_addr.s_addr, s2, sizeof(s2)),
319: route_reply->in_vif,route_reply->out_vif_bm);
320: }
321:
322: /* Send it. */
323: return rsrr_send(sendlen);
324: }
325:
326: /* Send an RSRR message. */
327: static int rsrr_send(int sendlen)
328: {
329: int error;
330:
331: /* Send it. */
332: error = sendto(rsrr_socket, rsrr_send_buf, sendlen, 0,
333: (struct sockaddr *)&client_addr, client_length);
334:
335: /* Check for errors. */
336: if (error < 0) {
337: logit(LOG_WARNING, errno, "Failed send on RSRR socket");
338: } else if (error != sendlen) {
339: logit(LOG_WARNING, 0,
340: "Sent only %d out of %d bytes on RSRR socket\n", error, sendlen);
341: }
342: return error;
343: }
344:
345: /* TODO: need to sort the rsrr_cache entries for faster access */
346: /* Cache a message being sent to a client. Currently only used for
347: * caching Route Reply messages for route change notification.
348: */
349: static void rsrr_cache(struct gtable *gt, struct rsrr_rq *route_query)
350: {
351: struct rsrr_cache *rc, **rcnp;
352: struct rsrr_header *rsrr = (struct rsrr_header *)rsrr_send_buf;
353:
354: rcnp = >->gt_rsrr_cache;
355: while ((rc = *rcnp) != NULL) {
356: if ((rc->route_query.source_addr.s_addr ==
357: route_query->source_addr.s_addr) &&
358: (rc->route_query.dest_addr.s_addr ==
359: route_query->dest_addr.s_addr) &&
360: (!strcmp(rc->client_addr.sun_path,client_addr.sun_path))) {
361: /* Cache entry already exists.
362: * Check if route notification bit has been cleared.
363: */
364: if (!BIT_TST(rsrr->flags, RSRR_NOTIFICATION_BIT)) {
365: /* Delete cache entry. */
366: *rcnp = rc->next;
367: free(rc);
368: } else {
369: /* Update */
370: /* TODO: XXX: No need to update iif, oifs, flags */
371: rc->route_query.query_id = route_query->query_id;
372: IF_DEBUG(DEBUG_RSRR) {
373: logit(LOG_DEBUG, 0,
374: "Update cached query id %ld from client %s\n",
375: rc->route_query.query_id, rc->client_addr.sun_path);
376: }
377: }
378: return;
379: }
380: rcnp = &rc->next;
381: }
382:
383: /* Cache entry doesn't already exist. Create one and insert at
384: * front of list.
385: */
386: rc = (struct rsrr_cache *)malloc(sizeof(struct rsrr_cache));
387: if (rc == NULL)
388: logit(LOG_ERR, 0, "Ran out of memory in rsrr_cache()");
389:
390: rc->route_query.source_addr.s_addr = route_query->source_addr.s_addr;
391: rc->route_query.dest_addr.s_addr = route_query->dest_addr.s_addr;
392: rc->route_query.query_id = route_query->query_id;
393: strlcpy(rc->client_addr.sun_path, client_addr.sun_path, sizeof(rc->client_addr.sun_path));
394: rc->client_length = client_length;
395: rc->next = gt->gt_rsrr_cache;
396: gt->gt_rsrr_cache = rc;
397: IF_DEBUG(DEBUG_RSRR) {
398: logit(LOG_DEBUG, 0, "Cached query id %ld from client %s\n",
399: rc->route_query.query_id, rc->client_addr.sun_path);
400: }
401: }
402:
403: /* Send all the messages in the cache for particular routing entry.
404: * Currently this is used to send all the cached Route Reply messages
405: * for route change notification.
406: */
407: void rsrr_cache_send(struct gtable *gt, int notify)
408: {
409: struct rsrr_cache *rc, **rcnp;
410: u_char flags = 0;
411:
412: if (notify) {
413: BIT_SET(flags, RSRR_NOTIFICATION_BIT);
414: }
415:
416: rcnp = >->gt_rsrr_cache;
417: while ((rc = *rcnp) != NULL) {
418: if (rsrr_accept_rq(&rc->route_query, flags, gt) < 0) {
419: IF_DEBUG(DEBUG_RSRR) {
420: logit(LOG_DEBUG, 0, "Deleting cached query id %ld from client %s\n",
421: rc->route_query.query_id,rc->client_addr.sun_path);
422: }
423: /* Delete cache entry. */
424: *rcnp = rc->next;
425: free(rc);
426: } else {
427: rcnp = &rc->next;
428: }
429: }
430: }
431:
432: /* Clean the cache by deleting all entries. */
433: void rsrr_cache_clean(struct gtable *gt)
434: {
435: struct rsrr_cache *rc, *rc_next;
436:
437: IF_DEBUG(DEBUG_RSRR) {
438: logit(LOG_DEBUG, 0, "cleaning cache for group %s\n",
439: inet_fmt(gt->gt_mcastgrp, s1, sizeof(s1)));
440: }
441: rc = gt->gt_rsrr_cache;
442: while (rc) {
443: rc_next = rc->next;
444: free(rc);
445: rc = rc_next;
446: }
447: gt->gt_rsrr_cache = NULL;
448: }
449:
450: void rsrr_clean(void)
451: {
452: unlink(RSRR_SERV_PATH);
453: }
454:
455: #endif /* RSRR */
456:
457: /**
458: * Local Variables:
459: * version-control: t
460: * indent-tabs-mode: t
461: * c-file-style: "ellemtel"
462: * c-basic-offset: 4
463: * End:
464: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rsrr.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mrouted