1: /*
2: ** igmpproxy - IGMP proxy based multicast router
3: ** Copyright (C) 2005 Johnny Egeland <johnny@rlo.org>
4: **
5: ** This program is free software; you can redistribute it and/or modify
6: ** it under the terms of the GNU General Public License as published by
7: ** the Free Software Foundation; either version 2 of the License, or
8: ** (at your option) any later version.
9: **
10: ** This program is distributed in the hope that it will be useful,
11: ** but WITHOUT ANY WARRANTY; without even the implied warranty of
12: ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13: ** GNU General Public License for more details.
14: **
15: ** You should have received a copy of the GNU General Public License
16: ** along with this program; if not, write to the Free Software
17: ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18: **
19: **----------------------------------------------------------------------------
20: **
21: ** This software is derived work from the following software. The original
22: ** source code has been modified from it's original state by the author
23: ** of igmpproxy.
24: **
25: ** smcroute 0.92 - Copyright (C) 2001 Carsten Schill <carsten@cschill.de>
26: ** - Licensed under the GNU General Public License, version 2
27: **
28: ** mrouted 3.9-beta3 - COPYRIGHT 1989 by The Board of Trustees of
29: ** Leland Stanford Junior University.
30: ** - Original license can be found in the Stanford.txt file.
31: **
32: */
33: /**
34: * rttable.c
35: *
36: * Updates the routingtable according to
37: * recieved request.
38: */
39:
40: #include "igmpproxy.h"
41:
42: /**
43: * Routing table structure definition. Double linked list...
44: */
45: struct RouteTable {
46: struct RouteTable *nextroute; // Pointer to the next group in line.
47: struct RouteTable *prevroute; // Pointer to the previous group in line.
48: uint32_t group; // The group to route
49: uint32_t originAddr; // The origin adress (only set on activated routes)
50: uint32_t vifBits; // Bits representing recieving VIFs.
51:
52: // Keeps the upstream membership state...
53: short upstrState; // Upstream membership state.
54:
55: // These parameters contain aging details.
56: uint32_t ageVifBits; // Bits representing aging VIFs.
57: int ageValue; // Downcounter for death.
58: int ageActivity; // Records any acitivity that notes there are still listeners.
59: };
60:
61:
62: // Keeper for the routing table...
63: static struct RouteTable *routing_table;
64:
65: // Prototypes
66: void logRouteTable(char *header);
67: int internAgeRoute(struct RouteTable* croute);
68: int internUpdateKernelRoute(struct RouteTable *route, int activate);
69:
70: // Socket for sending join or leave requests.
71: int mcGroupSock = 0;
72:
73:
74: /**
75: * Function for retrieving the Multicast Group socket.
76: */
77: int getMcGroupSock() {
78: if( ! mcGroupSock ) {
79: mcGroupSock = openUdpSocket( INADDR_ANY, 0 );;
80: }
81: return mcGroupSock;
82: }
83:
84: /**
85: * Initializes the routing table.
86: */
87: void initRouteTable() {
88: unsigned Ix;
89: struct IfDesc *Dp;
90:
91: // Clear routing table...
92: routing_table = NULL;
93:
94: // Join the all routers group on downstream vifs...
95: for ( Ix = 0; (Dp = getIfByIx(Ix)); Ix++ ) {
96: // If this is a downstream vif, we should join the All routers group...
97: if( Dp->InAdr.s_addr && ! (Dp->Flags & IFF_LOOPBACK) && Dp->state == IF_STATE_DOWNSTREAM) {
98: my_log(LOG_DEBUG, 0, "Joining all-routers group %s on vif %s",
99: inetFmt(allrouters_group,s1),inetFmt(Dp->InAdr.s_addr,s2));
100:
101: //k_join(allrouters_group, Dp->InAdr.s_addr);
102: joinMcGroup( getMcGroupSock(), Dp, allrouters_group );
103: }
104: }
105: }
106:
107: /**
108: * Internal function to send join or leave requests for
109: * a specified route upstream...
110: */
111: void sendJoinLeaveUpstream(struct RouteTable* route, int join) {
112: struct IfDesc* upstrIf;
113:
114: // Get the upstream VIF...
115: upstrIf = getIfByIx( upStreamVif );
116: if(upstrIf == NULL) {
117: my_log(LOG_ERR, 0 ,"FATAL: Unable to get Upstream IF.");
118: }
119:
120: // Send join or leave request...
121: if(join) {
122:
123: // Only join a group if there are listeners downstream...
124: if(route->vifBits > 0) {
125: my_log(LOG_DEBUG, 0, "Joining group %s upstream on IF address %s",
126: inetFmt(route->group, s1),
127: inetFmt(upstrIf->InAdr.s_addr, s2));
128:
129: //k_join(route->group, upstrIf->InAdr.s_addr);
130: joinMcGroup( getMcGroupSock(), upstrIf, route->group );
131:
132: route->upstrState = ROUTESTATE_JOINED;
133: } else {
134: my_log(LOG_DEBUG, 0, "No downstream listeners for group %s. No join sent.",
135: inetFmt(route->group, s1));
136: }
137:
138: } else {
139: // Only leave if group is not left already...
140: if(route->upstrState != ROUTESTATE_NOTJOINED) {
141: my_log(LOG_DEBUG, 0, "Leaving group %s upstream on IF address %s",
142: inetFmt(route->group, s1),
143: inetFmt(upstrIf->InAdr.s_addr, s2));
144:
145: //k_leave(route->group, upstrIf->InAdr.s_addr);
146: leaveMcGroup( getMcGroupSock(), upstrIf, route->group );
147:
148: route->upstrState = ROUTESTATE_NOTJOINED;
149: }
150: }
151: }
152:
153: /**
154: * Clear all routes from routing table, and alerts Leaves upstream.
155: */
156: void clearAllRoutes() {
157: struct RouteTable *croute, *remainroute;
158:
159: // Loop through all routes...
160: for(croute = routing_table; croute; croute = remainroute) {
161:
162: remainroute = croute->nextroute;
163:
164: // Log the cleanup in debugmode...
165: my_log(LOG_DEBUG, 0, "Removing route entry for %s",
166: inetFmt(croute->group, s1));
167:
168: // Uninstall current route
169: if(!internUpdateKernelRoute(croute, 0)) {
170: my_log(LOG_WARNING, 0, "The removal from Kernel failed.");
171: }
172:
173: // Send Leave message upstream.
174: sendJoinLeaveUpstream(croute, 0);
175:
176: // Clear memory, and set pointer to next route...
177: free(croute);
178: }
179: routing_table = NULL;
180:
181: // Send a notice that the routing table is empty...
182: my_log(LOG_NOTICE, 0, "All routes removed. Routing table is empty.");
183: }
184:
185: /**
186: * Private access function to find a route from a given
187: * Route Descriptor.
188: */
189: struct RouteTable *findRoute(uint32_t group) {
190: struct RouteTable* croute;
191:
192: for(croute = routing_table; croute; croute = croute->nextroute) {
193: if(croute->group == group) {
194: return croute;
195: }
196: }
197:
198: return NULL;
199: }
200:
201: /**
202: * Adds a specified route to the routingtable.
203: * If the route already exists, the existing route
204: * is updated...
205: */
206: int insertRoute(uint32_t group, int ifx) {
207:
208: struct Config *conf = getCommonConfig();
209: struct RouteTable* croute;
210:
211: // Sanitycheck the group adress...
212: if( ! IN_MULTICAST( ntohl(group) )) {
213: my_log(LOG_WARNING, 0, "The group address %s is not a valid Multicast group. Table insert failed.",
214: inetFmt(group, s1));
215: return 0;
216: }
217:
218: // Santiycheck the VIF index...
219: //if(ifx < 0 || ifx >= MAX_MC_VIFS) {
220: if(ifx >= MAX_MC_VIFS) {
221: my_log(LOG_WARNING, 0, "The VIF Ix %d is out of range (0-%d). Table insert failed.",ifx,MAX_MC_VIFS);
222: return 0;
223: }
224:
225: // Try to find an existing route for this group...
226: croute = findRoute(group);
227: if(croute==NULL) {
228: struct RouteTable* newroute;
229:
230: my_log(LOG_DEBUG, 0, "No existing route for %s. Create new.",
231: inetFmt(group, s1));
232:
233:
234: // Create and initialize the new route table entry..
235: newroute = (struct RouteTable*)malloc(sizeof(struct RouteTable));
236: // Insert the route desc and clear all pointers...
237: newroute->group = group;
238: newroute->originAddr = 0;
239: newroute->nextroute = NULL;
240: newroute->prevroute = NULL;
241:
242: // The group is not joined initially.
243: newroute->upstrState = ROUTESTATE_NOTJOINED;
244:
245: // The route is not active yet, so the age is unimportant.
246: newroute->ageValue = conf->robustnessValue;
247: newroute->ageActivity = 0;
248:
249: BIT_ZERO(newroute->ageVifBits); // Initially we assume no listeners.
250:
251: // Set the listener flag...
252: BIT_ZERO(newroute->vifBits); // Initially no listeners...
253: if(ifx >= 0) {
254: BIT_SET(newroute->vifBits, ifx);
255: }
256:
257: // Check if there is a table already....
258: if(routing_table == NULL) {
259: // No location set, so insert in on the table top.
260: routing_table = newroute;
261: my_log(LOG_DEBUG, 0, "No routes in table. Insert at beginning.");
262: } else {
263:
264: my_log(LOG_DEBUG, 0, "Found existing routes. Find insert location.");
265:
266: // Check if the route could be inserted at the beginning...
267: if(routing_table->group > group) {
268: my_log(LOG_DEBUG, 0, "Inserting at beginning, before route %s",inetFmt(routing_table->group,s1));
269:
270: // Insert at beginning...
271: newroute->nextroute = routing_table;
272: newroute->prevroute = NULL;
273: routing_table = newroute;
274:
275: // If the route has a next node, the previous pointer must be updated.
276: if(newroute->nextroute != NULL) {
277: newroute->nextroute->prevroute = newroute;
278: }
279:
280: } else {
281:
282: // Find the location which is closest to the route.
283: for( croute = routing_table; croute->nextroute != NULL; croute = croute->nextroute ) {
284: // Find insert position.
285: if(croute->nextroute->group > group) {
286: break;
287: }
288: }
289:
290: my_log(LOG_DEBUG, 0, "Inserting after route %s",inetFmt(croute->group,s1));
291:
292: // Insert after current...
293: newroute->nextroute = croute->nextroute;
294: newroute->prevroute = croute;
295: if(croute->nextroute != NULL) {
296: croute->nextroute->prevroute = newroute;
297: }
298: croute->nextroute = newroute;
299: }
300: }
301:
302: // Set the new route as the current...
303: croute = newroute;
304:
305: // Log the cleanup in debugmode...
306: my_log(LOG_INFO, 0, "Inserted route table entry for %s on VIF #%d",
307: inetFmt(croute->group, s1),ifx);
308:
309: } else if(ifx >= 0) {
310:
311: // The route exists already, so just update it.
312: BIT_SET(croute->vifBits, ifx);
313:
314: // Register the VIF activity for the aging routine
315: BIT_SET(croute->ageVifBits, ifx);
316:
317: // Log the cleanup in debugmode...
318: my_log(LOG_INFO, 0, "Updated route entry for %s on VIF #%d",
319: inetFmt(croute->group, s1), ifx);
320:
321: // If the route is active, it must be reloaded into the Kernel..
322: if(croute->originAddr != 0) {
323:
324: // Update route in kernel...
325: if(!internUpdateKernelRoute(croute, 1)) {
326: my_log(LOG_WARNING, 0, "The insertion into Kernel failed.");
327: return 0;
328: }
329: }
330: }
331:
332: // Send join message upstream, if the route has no joined flag...
333: if(croute->upstrState != ROUTESTATE_JOINED) {
334: // Send Join request upstream
335: sendJoinLeaveUpstream(croute, 1);
336: }
337:
338: logRouteTable("Insert Route");
339:
340: return 1;
341: }
342:
343: /**
344: * Activates a passive group. If the group is already
345: * activated, it's reinstalled in the kernel. If
346: * the route is activated, no originAddr is needed.
347: */
348: int activateRoute(uint32_t group, uint32_t originAddr) {
349: struct RouteTable* croute;
350: int result = 0;
351:
352: // Find the requested route.
353: croute = findRoute(group);
354: if(croute == NULL) {
355: my_log(LOG_DEBUG, 0,
356: "No table entry for %s [From: %s]. Inserting route.",
357: inetFmt(group, s1),inetFmt(originAddr, s2));
358:
359: // Insert route, but no interfaces have yet requested it downstream.
360: insertRoute(group, -1);
361:
362: // Retrieve the route from table...
363: croute = findRoute(group);
364: }
365:
366: if(croute != NULL) {
367: // If the origin address is set, update the route data.
368: if(originAddr > 0) {
369: if(croute->originAddr > 0 && croute->originAddr!=originAddr) {
370: my_log(LOG_WARNING, 0, "The origin for route %s changed from %s to %s",
371: inetFmt(croute->group, s1),
372: inetFmt(croute->originAddr, s2),
373: inetFmt(originAddr, s3));
374: }
375: croute->originAddr = originAddr;
376: }
377:
378: // Only update kernel table if there are listeners !
379: if(croute->vifBits > 0) {
380: result = internUpdateKernelRoute(croute, 1);
381: }
382: }
383: logRouteTable("Activate Route");
384:
385: return result;
386: }
387:
388:
389: /**
390: * This function loops through all routes, and updates the age
391: * of any active routes.
392: */
393: void ageActiveRoutes() {
394: struct RouteTable *croute, *nroute;
395:
396: my_log(LOG_DEBUG, 0, "Aging routes in table.");
397:
398: // Scan all routes...
399: for( croute = routing_table; croute != NULL; croute = nroute ) {
400:
401: // Keep the next route (since current route may be removed)...
402: nroute = croute->nextroute;
403:
404: // Run the aging round algorithm.
405: if(croute->upstrState != ROUTESTATE_CHECK_LAST_MEMBER) {
406: // Only age routes if Last member probe is not active...
407: internAgeRoute(croute);
408: }
409: }
410: logRouteTable("Age active routes");
411: }
412:
413: /**
414: * Should be called when a leave message is recieved, to
415: * mark a route for the last member probe state.
416: */
417: void setRouteLastMemberMode(uint32_t group) {
418: struct Config *conf = getCommonConfig();
419: struct RouteTable *croute;
420:
421: croute = findRoute(group);
422: if(croute!=NULL) {
423: // Check for fast leave mode...
424: if(croute->upstrState == ROUTESTATE_JOINED && conf->fastUpstreamLeave) {
425: // Send a leave message right away..
426: sendJoinLeaveUpstream(croute, 0);
427: }
428: // Set the routingstate to Last member check...
429: croute->upstrState = ROUTESTATE_CHECK_LAST_MEMBER;
430: // Set the count value for expiring... (-1 since first aging)
431: croute->ageValue = conf->lastMemberQueryCount;
432: }
433: }
434:
435:
436: /**
437: * Ages groups in the last member check state. If the
438: * route is not found, or not in this state, 0 is returned.
439: */
440: int lastMemberGroupAge(uint32_t group) {
441: struct RouteTable *croute;
442:
443: croute = findRoute(group);
444: if(croute!=NULL) {
445: if(croute->upstrState == ROUTESTATE_CHECK_LAST_MEMBER) {
446: return !internAgeRoute(croute);
447: } else {
448: return 0;
449: }
450: }
451: return 0;
452: }
453:
454: /**
455: * Remove a specified route. Returns 1 on success,
456: * and 0 if route was not found.
457: */
458: int removeRoute(struct RouteTable* croute) {
459: struct Config *conf = getCommonConfig();
460: int result = 1;
461:
462: // If croute is null, no routes was found.
463: if(croute==NULL) {
464: return 0;
465: }
466:
467: // Log the cleanup in debugmode...
468: my_log(LOG_DEBUG, 0, "Removed route entry for %s from table.",
469: inetFmt(croute->group, s1));
470:
471: //BIT_ZERO(croute->vifBits);
472:
473: // Uninstall current route from kernel
474: if(!internUpdateKernelRoute(croute, 0)) {
475: my_log(LOG_WARNING, 0, "The removal from Kernel failed.");
476: result = 0;
477: }
478:
479: // Send Leave request upstream if group is joined
480: if(croute->upstrState == ROUTESTATE_JOINED ||
481: (croute->upstrState == ROUTESTATE_CHECK_LAST_MEMBER && !conf->fastUpstreamLeave))
482: {
483: sendJoinLeaveUpstream(croute, 0);
484: }
485:
486: // Update pointers...
487: if(croute->prevroute == NULL) {
488: // Topmost node...
489: if(croute->nextroute != NULL) {
490: croute->nextroute->prevroute = NULL;
491: }
492: routing_table = croute->nextroute;
493:
494: } else {
495: croute->prevroute->nextroute = croute->nextroute;
496: if(croute->nextroute != NULL) {
497: croute->nextroute->prevroute = croute->prevroute;
498: }
499: }
500: // Free the memory, and set the route to NULL...
501: free(croute);
502: croute = NULL;
503:
504: logRouteTable("Remove route");
505:
506: return result;
507: }
508:
509:
510: /**
511: * Ages a specific route
512: */
513: int internAgeRoute(struct RouteTable* croute) {
514: struct Config *conf = getCommonConfig();
515: int result = 0;
516:
517: // Drop age by 1.
518: croute->ageValue--;
519:
520: // Check if there has been any activity...
521: if( croute->ageVifBits > 0 && croute->ageActivity == 0 ) {
522: // There was some activity, check if all registered vifs responded.
523: if(croute->vifBits == croute->ageVifBits) {
524: // Everything is in perfect order, so we just update the route age.
525: croute->ageValue = conf->robustnessValue;
526: //croute->ageActivity = 0;
527: } else {
528: // One or more VIF has not gotten any response.
529: croute->ageActivity++;
530:
531: // Update the actual bits for the route...
532: croute->vifBits = croute->ageVifBits;
533: }
534: }
535: // Check if there have been activity in aging process...
536: else if( croute->ageActivity > 0 ) {
537:
538: // If the bits are different in this round, we must
539: if(croute->vifBits != croute->ageVifBits) {
540: // Or the bits together to insure we don't lose any listeners.
541: croute->vifBits |= croute->ageVifBits;
542:
543: // Register changes in this round as well..
544: croute->ageActivity++;
545: }
546: }
547:
548: // If the aging counter has reached zero, its time for updating...
549: if(croute->ageValue == 0) {
550: // Check for activity in the aging process,
551: if(croute->ageActivity>0) {
552:
553: my_log(LOG_DEBUG, 0, "Updating route after aging : %s",
554: inetFmt(croute->group,s1));
555:
556: // Just update the routing settings in kernel...
557: internUpdateKernelRoute(croute, 1);
558:
559: // We append the activity counter to the age, and continue...
560: croute->ageValue = croute->ageActivity;
561: croute->ageActivity = 0;
562: } else {
563:
564: my_log(LOG_DEBUG, 0, "Removing group %s. Died of old age.",
565: inetFmt(croute->group,s1));
566:
567: // No activity was registered within the timelimit, so remove the route.
568: removeRoute(croute);
569: }
570: // Tell that the route was updated...
571: result = 1;
572: }
573:
574: // The aging vif bits must be reset for each round...
575: BIT_ZERO(croute->ageVifBits);
576:
577: return result;
578: }
579:
580: /**
581: * Updates the Kernel routing table. If activate is 1, the route
582: * is (re-)activated. If activate is false, the route is removed.
583: */
584: int internUpdateKernelRoute(struct RouteTable *route, int activate) {
585: struct MRouteDesc mrDesc;
586: struct IfDesc *Dp;
587: unsigned Ix;
588:
589: if(route->originAddr>0) {
590:
591: // Build route descriptor from table entry...
592: // Set the source address and group address...
593: mrDesc.McAdr.s_addr = route->group;
594: mrDesc.OriginAdr.s_addr = route->originAddr;
595:
596: // clear output interfaces
597: memset( mrDesc.TtlVc, 0, sizeof( mrDesc.TtlVc ) );
598:
599: my_log(LOG_DEBUG, 0, "Vif bits : 0x%08x", route->vifBits);
600:
601: // Set the TTL's for the route descriptor...
602: for ( Ix = 0; (Dp = getIfByIx(Ix)); Ix++ ) {
603: if(Dp->state == IF_STATE_UPSTREAM) {
604: mrDesc.InVif = Dp->index;
605: }
606: else if(BIT_TST(route->vifBits, Dp->index)) {
607: my_log(LOG_DEBUG, 0, "Setting TTL for Vif %d to %d", Dp->index, Dp->threshold);
608: mrDesc.TtlVc[ Dp->index ] = Dp->threshold;
609: }
610: }
611:
612: // Do the actual Kernel route update...
613: if(activate) {
614: // Add route in kernel...
615: addMRoute( &mrDesc );
616:
617: } else {
618: // Delete the route from Kernel...
619: delMRoute( &mrDesc );
620: }
621:
622: } else {
623: my_log(LOG_NOTICE, 0, "Route is not active. No kernel updates done.");
624: }
625:
626: return 1;
627: }
628:
629: /**
630: * Debug function that writes the routing table entries
631: * to the log.
632: */
633: void logRouteTable(char *header) {
634: struct RouteTable* croute = routing_table;
635: unsigned rcount = 0;
636:
637: my_log(LOG_DEBUG, 0, "");
638: my_log(LOG_DEBUG, 0, "Current routing table (%s):", header);
639: my_log(LOG_DEBUG, 0, "-----------------------------------------------------");
640: if(croute==NULL) {
641: my_log(LOG_DEBUG, 0, "No routes in table...");
642: } else {
643: do {
644: /*
645: my_log(LOG_DEBUG, 0, "#%d: Src: %s, Dst: %s, Age:%d, St: %s, Prev: 0x%08x, T: 0x%08x, Next: 0x%08x",
646: rcount, inetFmt(croute->originAddr, s1), inetFmt(croute->group, s2),
647: croute->ageValue,(croute->originAddr>0?"A":"I"),
648: croute->prevroute, croute, croute->nextroute);
649: */
650: my_log(LOG_DEBUG, 0, "#%d: Src: %s, Dst: %s, Age:%d, St: %s, OutVifs: 0x%08x",
651: rcount, inetFmt(croute->originAddr, s1), inetFmt(croute->group, s2),
652: croute->ageValue,(croute->originAddr>0?"A":"I"),
653: croute->vifBits);
654:
655: croute = croute->nextroute;
656:
657: rcount++;
658: } while ( croute != NULL );
659: }
660:
661: my_log(LOG_DEBUG, 0, "-----------------------------------------------------");
662: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rttable.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / igmpproxy / src