![[first]](../icons/first.png){kind=icon}
![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[last]](../icons/last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
1 /*
2 * IP multicast routing support for mrouted 3.6
3 *
4 * (c) 1995 Alan Cox, <alan@cymru.net>
5 * Linux Consultancy and Custom Driver Development
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 *
13 * Fixes:
14 * Michael Chastain : Incorrect size of copying.
15 * Alan Cox : Added the cache manager code
16 *
17 * Status:
18 * Cache manager under test. Forwarding in vague test mode
19 * Todo:
20 * Flow control
21 * Finish Tunnels
22 * Debug cache ttl handling properly
23 * Resolve IFF_ALLMULTI for rest of cards
24 */
25
26 #include <asm/system.h>
27 #include <asm/segment.h>
28 #include <linux/types.h>
29 #include <linux/sched.h>
30 #include <linux/errno.h>
31 #include <linux/timer.h>
32 #include <linux/mm.h>
33 #include <linux/kernel.h>
34 #include <linux/fcntl.h>
35 #include <linux/stat.h>
36 #include <linux/socket.h>
37 #include <linux/in.h>
38 #include <linux/inet.h>
39 #include <linux/netdevice.h>
40 #include <linux/proc_fs.h>
41 #include <linux/mroute.h>
42 #include <net/ip.h>
43 #include <net/protocol.h>
44 #include <linux/skbuff.h>
45 #include <net/sock.h>
46 #include <net/icmp.h>
47 #include <net/udp.h>
48 #include <linux/notifier.h>
49 #include <net/checksum.h>
50
51 /*
52 * Multicast router conrol variables
53 */
54
55 static struct vif_device vif_table[MAXVIFS]; /* Devices */
56 static unsigned long vifc_map; /* Active device map */
57 int mroute_do_pim = 0; /* Set in PIM assert */
58 static struct mfc_cache *mfc_cache_array[MFC_LINES]; /* Forwarding cache */
59 static struct mfc_cache *cache_resolve_queue; /* Unresolved cache */
60 int cache_resolve_queue_len = 0; /* Size of unresolved */
61
62 /*
63 * Delete a VIF entry
64 */
65
66 static void vif_delete(struct vif_device *v)
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
67 {
68 if(!(v->flags&VIFF_TUNNEL))
69 {
70 v->dev->flags&=~IFF_ALLMULTI;
71 dev_mc_upload(v->dev);
72 }
73 v->dev=NULL;
74 }
75
76 /*
77 * Find a vif
78 */
79
80 static int ipmr_vifi_find(struct device *dev)
/* ![[previous]](../icons/left.png)
*/
81 {
82 struct vif_device *v=&vif_table[0];
83 int ct;
84 for(ct=0;ct<MAXVIFS;ct++,v++)
85 {
86 if(v->dev==dev)
87 return ct;
88 }
89 return -1;
90 }
91
92 /*
93 * Delete a multicast route cache entry
94 */
95
96 static void ipmr_cache_delete(struct mfc_cache *cache)
/* */
97 {
98 struct sk_buff *skb;
99 int line;
100 struct mfc_cache **cp;
101
102 /*
103 * Find the right cache line
104 */
105
106 if(cache->mfc_flags&MFC_QUEUED)
107 {
108 cp=&cache_resolve_queue;
109 del_timer(&cache->mfc_timer);
110 }
111 else
112 {
113 line=MFC_HASH(cache->mfc_mcastgrp,cache->mfc_origin);
114 cp=&(mfc_cache_array[line]);
115 }
116
117 /*
118 * Unlink the buffer
119 */
120
121 while(*cp!=NULL)
122 {
123 if(*cp==cache)
124 {
125 *cp=cache->next;
126 break;
127 }
128 cp=&((*cp)->next);
129 }
130
131 /*
132 * Free the buffer. If it is a pending resolution
133 * clean up the other resources.
134 */
135
136 if(cache->mfc_flags&MFC_QUEUED)
137 {
138 cache_resolve_queue_len--;
139 while((skb=skb_dequeue(&cache->mfc_unresolved)))
140 kfree_skb(skb, FREE_WRITE);
141 }
142 kfree_s(cache,sizeof(cache));
143 }
144
145 /*
146 * Cache expiry timer
147 */
148
149 static void ipmr_cache_timer(unsigned long data)
/* */
150 {
151 struct mfc_cache *cache=(struct mfc_cache *)data;
152 ipmr_cache_delete(cache);
153 }
154
155 /*
156 * Insert a multicast cache entry
157 */
158
159 static void ipmr_cache_insert(struct mfc_cache *c)
/* */
160 {
161 int line=MFC_HASH(c->mfc_mcastgrp,c->mfc_origin);
162 c->next=mfc_cache_array[line];
163 mfc_cache_array[line]=c;
164 }
165
166 /*
167 * Find a multicast cache entry
168 */
169
170 struct mfc_cache *ipmr_cache_find(__u32 origin, __u32 mcastgrp)
/* */
171 {
172 int line=MFC_HASH(mcastgrp,origin);
173 struct mfc_cache *cache;
174 cache=mfc_cache_array[line];
175 while(cache!=NULL)
176 {
177 if(cache->mfc_origin==origin && cache->mfc_mcastgrp==mcastgrp)
178 return cache;
179 cache=cache->next;
180 }
181 cache=cache_resolve_queue;
182 while(cache!=NULL)
183 {
184 if(cache->mfc_origin==origin && cache->mfc_mcastgrp==mcastgrp)
185 return cache;
186 cache=cache->next;
187 }
188 return NULL;
189 }
190
191 /*
192 * Allocate a multicast cache entry
193 */
194
195 static struct mfc_cache *ipmr_cache_alloc(int priority)
/* */
196 {
197 struct mfc_cache *c=(struct mfc_cache *)kmalloc(sizeof(struct mfc_cache), priority);
198 if(c==NULL)
199 return NULL;
200 c->mfc_queuelen=0;
201 skb_queue_head_init(&c->mfc_unresolved);
202 init_timer(&c->mfc_timer);
203 c->mfc_timer.data=(long)c;
204 c->mfc_timer.function=ipmr_cache_timer;
205 return c;
206 }
207
208 /*
209 * A cache entry has gone into a resolved state from queued
210 */
211
212 static void ipmr_cache_resolve(struct mfc_cache *cache)
/* */
213 {
214 struct mfc_cache **p;
215 struct sk_buff *skb;
216 /*
217 * Kill the queue entry timer.
218 */
219 del_timer(&cache->mfc_timer);
220 cache->mfc_flags&=~MFC_QUEUED;
221 /*
222 * Remove from the resolve queue
223 */
224 p=&cache_resolve_queue;
225 while((*p)!=NULL)
226 {
227 if((*p)==cache)
228 {
229 *p=cache->next;
230 break;
231 }
232 p=&((*p)->next);
233 }
234 cache_resolve_queue_len--;
235 sti();
236 /*
237 * Insert into the main cache
238 */
239 ipmr_cache_insert(cache);
240 /*
241 * Play the pending entries through our router
242 */
243 while((skb=skb_dequeue(&cache->mfc_unresolved)))
244 ipmr_forward(skb, skb->protocol);
245 }
246
247 /*
248 * Bounce a cache query up to mrouted. We could use netlink for this but mrouted
249 * expects the following bizarre scheme..
250 */
251
252 static void ipmr_cache_report(struct sk_buff *pkt)
/* */
253 {
254 struct sk_buff *skb=alloc_skb(128, GFP_ATOMIC);
255 int ihl=pkt->ip_hdr->ihl<<2;
256 struct igmphdr *igmp;
257 if(!skb)
258 return;
259
260 skb->free=1;
261
262 /*
263 * Copy the IP header
264 */
265
266 skb->ip_hdr=(struct iphdr *)skb_put(skb,ihl);
267 skb->h.iph=skb->ip_hdr;
268 memcpy(skb->data,pkt->data,ihl);
269 skb->ip_hdr->protocol = 0; /* Flag to the kernel this is a route add */
270
271 /*
272 * Add our header
273 */
274
275 igmp=(struct igmphdr *)skb_put(skb,sizeof(struct igmphdr));
276 igmp->type = IGMPMSG_NOCACHE; /* non IGMP dummy message */
277 igmp->code = 0;
278 skb->ip_hdr->tot_len=htons(skb->len); /* Fix the length */
279
280 /*
281 * Deliver to mrouted
282 */
283 if(sock_queue_rcv_skb(mroute_socket,skb)<0)
284 {
285 skb->sk=NULL;
286 kfree_skb(skb, FREE_READ);
287 }
288 }
289
290
291 /*
292 * Queue a packet for resolution
293 */
294
295 static void ipmr_cache_unresolved(struct mfc_cache *cache, vifi_t vifi, struct sk_buff *skb, int is_frag)
/* */
296 {
297 if(cache==NULL)
298 {
299 /*
300 * Create a new entry if allowable
301 */
302 if(cache_resolve_queue_len>=10 || (cache=ipmr_cache_alloc(GFP_ATOMIC))==NULL)
303 {
304 kfree_skb(skb, FREE_WRITE);
305 return;
306 }
307 /*
308 * Fill in the new cache entry
309 */
310 cache->mfc_parent=vifi;
311 cache->mfc_origin=skb->ip_hdr->saddr;
312 cache->mfc_mcastgrp=skb->ip_hdr->daddr;
313 cache->mfc_flags=MFC_QUEUED;
314 /*
315 * Link to the unresolved list
316 */
317 cache->next=cache_resolve_queue;
318 cache_resolve_queue=cache;
319 cache_resolve_queue_len++;
320 /*
321 * Fire off the expiry timer
322 */
323 cache->mfc_timer.expires=jiffies+10*HZ;
324 add_timer(&cache->mfc_timer);
325 /*
326 * Reflect first query at mrouted.
327 */
328 if(mroute_socket)
329 ipmr_cache_report(skb);
330 }
331 /*
332 * See if we can append the packet
333 */
334 if(cache->mfc_queuelen>3)
335 {
336 kfree_skb(skb, FREE_WRITE);
337 return;
338 }
339 /*
340 * Add to our 'pending' list. Cache the is_frag data
341 * in skb->protocol now it is spare.
342 */
343 cache->mfc_queuelen++;
344 skb->protocol=is_frag;
345 skb_queue_tail(&cache->mfc_unresolved,skb);
346 }
347
348 /*
349 * MFC cache manipulation by user space mroute daemon
350 */
351
352 int ipmr_mfc_modify(int action, struct mfcctl *mfc)
/* */
353 {
354 struct mfc_cache *cache;
355 if(!MULTICAST(mfc->mfcc_mcastgrp.s_addr))
356 return -EINVAL;
357 /*
358 * Find the cache line
359 */
360
361 cli();
362 cache=ipmr_cache_find(mfc->mfcc_origin.s_addr,mfc->mfcc_mcastgrp.s_addr);
363
364 /*
365 * Delete an entry
366 */
367 if(action==MRT_DEL_MFC)
368 {
369 if(cache)
370 {
371 ipmr_cache_delete(cache);
372 sti();
373 return 0;
374 }
375 sti();
376 return -ENOENT;
377 }
378 if(cache)
379 {
380 /*
381 * Update the cache, see if it frees a pending queue
382 */
383
384 cache->mfc_flags|=MFC_RESOLVED;
385 memcpy(cache->mfc_ttls, mfc->mfcc_ttls,sizeof(cache->mfc_ttls));
386
387 /*
388 * Check to see if we resolved a queued list. If so we
389 * need to send on the frames and tidy up.
390 */
391
392 if(cache->mfc_flags&MFC_QUEUED)
393 ipmr_cache_resolve(cache); /* Unhook & send the frames */
394 sti();
395 return 0;
396 }
397 /*
398 * Unsolicited update - thats ok add anyway.
399 */
400
401
402 cache=ipmr_cache_alloc(GFP_ATOMIC);
403 if(cache==NULL)
404 {
405 sti();
406 return -ENOMEM;
407 }
408 cache->mfc_flags=MFC_RESOLVED;
409 cache->mfc_origin=mfc->mfcc_origin.s_addr;
410 cache->mfc_mcastgrp=mfc->mfcc_mcastgrp.s_addr;
411 cache->mfc_parent=mfc->mfcc_parent;
412 memcpy(cache->mfc_ttls, mfc->mfcc_ttls,sizeof(cache->mfc_ttls));
413 ipmr_cache_insert(cache);
414 sti();
415 return 0;
416 }
417
418 /*
419 * Socket options and virtual interface manipulation. The whole
420 * virtual interface system is a complete heap, but unfortunately
421 * thats how BSD mrouted happens to think. Maybe one day with a proper
422 * MOSPF/PIM router set up we can clean this up.
423 */
424
425 int ip_mroute_setsockopt(struct sock *sk,int optname,char *optval,int optlen)
/* */
426 {
427 int err;
428 struct vifctl vif;
429 struct mfcctl mfc;
430
431 if(optname!=MRT_INIT)
432 {
433 if(sk!=mroute_socket)
434 return -EACCES;
435 }
436
437 switch(optname)
438 {
439 case MRT_INIT:
440 if(sk->type!=SOCK_RAW || sk->num!=IPPROTO_IGMP)
441 return -EOPNOTSUPP;
442 if(optlen!=sizeof(int))
443 return -ENOPROTOOPT;
444 if((err=verify_area(VERIFY_READ,optval,sizeof(int)))<0)
445 return err;
446 if(get_user((int *)optval)!=1)
447 return -ENOPROTOOPT;
448 if(mroute_socket)
449 return -EADDRINUSE;
450 mroute_socket=sk;
451 /* Initialise state */
452 return 0;
453 case MRT_DONE:
454 mroute_close(sk);
455 mroute_socket=NULL;
456 return 0;
457 case MRT_ADD_VIF:
458 case MRT_DEL_VIF:
459 if(optlen!=sizeof(vif))
460 return -EINVAL;
461 if((err=verify_area(VERIFY_READ, optval, sizeof(vif)))<0)
462 return err;
463 memcpy_fromfs(&vif,optval,sizeof(vif));
464 if(vif.vifc_vifi > MAXVIFS)
465 return -ENFILE;
466 if(optname==MRT_ADD_VIF)
467 {
468 struct vif_device *v=&vif_table[vif.vifc_vifi];
469 struct device *dev;
470 /* Empty vif ? */
471 if(vifc_map&(1<<vif.vifc_vifi))
472 return -EADDRINUSE;
473 /* Find the interface */
474 dev=ip_dev_find(vif.vifc_lcl_addr.s_addr);
475 if(!dev)
476 return -EADDRNOTAVAIL;
477 /* Must be tunnelled or multicastable */
478 if(vif.vifc_flags&VIFF_TUNNEL)
479 {
480 if(vif.vifc_flags&VIFF_SRCRT)
481 return -EOPNOTSUPP;
482 /* IPIP will do all the work */
483 }
484 else
485 {
486 if(dev->flags&IFF_MULTICAST)
487 {
488 /* Most ethernet cards dont know
489 how to do this yet.. */
490 dev->flags|=IFF_ALLMULTI;
491 dev_mc_upload(dev);
492 }
493 else
494 {
495 /* We are stuck.. */
496 return -EOPNOTSUPP;
497 }
498 }
499 /*
500 * Fill in the VIF structures
501 */
502 cli();
503 v->rate_limit=vif.vifc_rate_limit;
504 v->local=vif.vifc_lcl_addr.s_addr;
505 v->remote=vif.vifc_rmt_addr.s_addr;
506 v->flags=vif.vifc_flags;
507 v->threshold=vif.vifc_threshold;
508 v->dev=dev;
509 v->bytes_in = 0;
510 v->bytes_out = 0;
511 v->pkt_in = 0;
512 v->pkt_out = 0;
513 vifc_map|=(1<<vif.vifc_vifi);
514 sti();
515 return 0;
516 }
517 else
518 /*
519 * VIF deletion
520 */
521 {
522 struct vif_device *v=&vif_table[vif.vifc_vifi];
523 if(vifc_map&(1<<vif.vifc_vifi))
524 {
525 vif_delete(v);
526 vifc_map&=~(1<<vif.vifc_vifi);
527 return 0;
528 }
529 else
530 return -EADDRNOTAVAIL;
531 }
532 /*
533 * Manipulate the forwarding caches. These live
534 * in a sort of kernel/user symbiosis.
535 */
536 case MRT_ADD_MFC:
537 case MRT_DEL_MFC:
538 err=verify_area(VERIFY_READ, optval, sizeof(mfc));
539 if(err)
540 return err;
541 memcpy_fromfs(&mfc,optval, sizeof(mfc));
542 return ipmr_mfc_modify(optname, &mfc);
543 /*
544 * Control PIM assert.
545 */
546 case MRT_ASSERT:
547 if(optlen!=sizeof(int))
548 return -EINVAL;
549 if((err=verify_area(VERIFY_READ, optval,sizeof(int)))<0)
550 return err;
551 mroute_do_pim= (optval)?1:0;
552 return 0;
553 /*
554 * Spurious command, or MRT_VERSION which you cannot
555 * set.
556 */
557 default:
558 return -EOPNOTSUPP;
559 }
560 }
561
562 /*
563 * Getsock opt support for the multicast routing system.
564 */
565
566 int ip_mroute_getsockopt(struct sock *sk,int optname,char *optval,int *optlen)
/* */
567 {
568 int olr;
569 int err;
570
571 if(sk!=mroute_socket)
572 return -EACCES;
573 if(optname!=MRT_VERSION && optname!=MRT_ASSERT)
574 return -EOPNOTSUPP;
575
576 olr=get_user(optlen);
577 if(olr!=sizeof(int))
578 return -EINVAL;
579 err=verify_area(VERIFY_WRITE, optval,sizeof(int));
580 if(err)
581 return err;
582 put_user(sizeof(int),optlen);
583 if(optname==MRT_VERSION)
584 put_user(0x0305,(int *)optval);
585 else
586 put_user(mroute_do_pim,(int *)optval);
587 return 0;
588 }
589
590 /*
591 * The IP multicast ioctl support routines.
592 */
593
594 int ipmr_ioctl(struct sock *sk, int cmd, unsigned long arg)
/* */
595 {
596 int err;
597 struct sioc_sg_req sr;
598 struct sioc_vif_req vr;
599 struct vif_device *vif;
600
601 switch(cmd)
602 {
603 case SIOCGETVIFCNT:
604 err=verify_area(VERIFY_WRITE, (void *)arg, sizeof(vr));
605 if(err)
606 return err;
607 memcpy_fromfs(&vr,(void *)arg,sizeof(vr));
608 if(vr.vifi>=MAXVIFS)
609 return -EINVAL;
610 vif=&vif_table[vr.vifi];
611 if(vifc_map&(1<<vr.vifi))
612 {
613 vr.icount=vif->pkt_in;
614 vr.ocount=vif->pkt_out;
615 vr.ibytes=vif->bytes_in;
616 vr.obytes=vif->bytes_out;
617 memcpy_tofs((void *)arg,&vr,sizeof(vr));
618 return 0;
619 }
620 return -EADDRNOTAVAIL;
621 case SIOCGETSGCNT:
622 err=verify_area(VERIFY_WRITE, (void *)arg, sizeof(sr));
623 if(err)
624 return err;
625 memcpy_fromfs(&sr,(void *)arg,sizeof(sr));
626 memcpy_tofs((void *)arg,&sr,sizeof(sr));
627 return 0;
628 default:
629 return -EINVAL;
630 }
631 }
632
633 /*
634 * Close the multicast socket, and clear the vif tables etc
635 */
636
637 void mroute_close(struct sock *sk)
/* */
638 {
639 int i;
640 struct vif_device *v=&vif_table[0];
641
642 /*
643 * Shut down all active vif entries
644 */
645
646 for(i=0;i<MAXVIFS;i++)
647 {
648 if(vifc_map&(1<<i))
649 {
650 if(!(v->flags&VIFF_TUNNEL))
651 {
652 v->dev->flags&=~IFF_ALLMULTI;
653 dev_mc_upload(v->dev);
654 }
655 }
656 v++;
657 }
658 vifc_map=0;
659 /*
660 * Wipe the cache
661 */
662 for(i=0;i<MFC_LINES;i++)
663 {
664 while(mfc_cache_array[i]!=NULL)
665 ipmr_cache_delete(mfc_cache_array[i]);
666 }
667 /* The timer will clear any 'pending' stuff */
668 }
669
670 static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
/* */
671 {
672 struct vif_device *v;
673 int ct;
674 if(event!=NETDEV_DOWN)
675 return NOTIFY_DONE;
676 v=&vif_table[0];
677 for(ct=0;ct<MAXVIFS;ct++)
678 {
679 if((vifc_map&(1<<ct)) && v->dev==ptr)
680 {
681 vif_delete(v);
682 vifc_map&=~(1<<ct);
683 }
684 v++;
685 }
686 return NOTIFY_DONE;
687 }
688
689
690 static struct notifier_block ip_mr_notifier={
691 ipmr_device_event,
692 NULL,
693 0
694 };
695
696 /*
697 * Processing handlers for ipmr_forward
698 */
699
700 static void ipmr_queue_xmit(struct sk_buff *skb, struct vif_device *vif, struct device *in_dev, int frag)
/* */
701 {
702 int tunnel=0;
703 __u32 raddr=skb->raddr;
704 if(vif->flags&VIFF_TUNNEL)
705 {
706 tunnel=16;
707 raddr=vif->remote;
708 }
709 vif->pkt_out++;
710 vif->bytes_out+=skb->len;
711 skb->dev=vif->dev;
712 skb->raddr=skb->h.iph->daddr;
713 if(ip_forward(skb, in_dev, frag|8|tunnel, raddr)==-1)
714 kfree_skb(skb, FREE_WRITE);
715 }
716
717 /*
718 * Multicast packets for forwarding arrive here
719 */
720
721 void ipmr_forward(struct sk_buff *skb, int is_frag)
/* */
722 {
723 struct mfc_cache *cache;
724 struct sk_buff *skb2;
725 int psend = -1;
726 int vif=ipmr_vifi_find(skb->dev);
727 if(vif==-1)
728 {
729 kfree_skb(skb, FREE_WRITE);
730 return;
731 }
732
733 vif_table[vif].pkt_in++;
734 vif_table[vif].bytes_in+=skb->len;
735
736 cache=ipmr_cache_find(skb->ip_hdr->saddr,skb->ip_hdr->daddr);
737
738 /*
739 * No usable cache entry
740 */
741
742 if(cache==NULL || (cache->mfc_flags&MFC_QUEUED))
743 ipmr_cache_unresolved(cache,vif,skb, is_frag);
744 else
745 {
746 /*
747 * Forward the frame
748 */
749 int ct=0;
750 while(ct<MAXVIFS)
751 {
752 /*
753 * 0 means don't do it. Silly idea, 255 as don't do it would be cleaner!
754 */
755 if(skb->ip_hdr->ttl > cache->mfc_ttls[ct] && cache->mfc_ttls[ct]>0)
756 {
757 if(psend!=-1)
758 {
759 skb2=skb_clone(skb, GFP_ATOMIC);
760 if(skb2)
761 {
762 skb2->free=1;
763 ipmr_queue_xmit(skb2, &vif_table[psend], skb->dev, is_frag);
764 }
765 }
766 psend=ct;
767 }
768 ct++;
769 }
770 if(psend==-1)
771 kfree_skb(skb, FREE_WRITE);
772 else
773 {
774 ipmr_queue_xmit(skb, &vif_table[psend], skb->dev, is_frag);
775 }
776 /*
777 * Adjust the stats
778 */
779 }
780 }
781
782 /*
783 * The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
784 */
785
786 int ipmr_vif_info(char *buffer, char **start, off_t offset, int length, int dummy)
/* */
787 {
788 struct vif_device *vif;
789 int len=0;
790 off_t pos=0;
791 off_t begin=0;
792 int size;
793 int ct;
794
795 len += sprintf(buffer,
796 "Interface Bytes In Pkts In Bytes Out Pkts Out Flags Local Remote\n");
797 pos=len;
798
799 for (ct=0;ct<MAXVIFS;ct++)
800 {
801 vif=&vif_table[ct];
802 if(!(vifc_map&(1<<ct)))
803 continue;
804 if(vif->dev==NULL)
805 continue;
806 size = sprintf(buffer+len, "%-10s %8ld %7ld %8ld %7ld %05X %08lX %08lX\n",
807 vif->dev->name,vif->bytes_in, vif->pkt_in, vif->bytes_out,vif->pkt_out,
808 vif->flags, vif->local, vif->remote);
809 len+=size;
810 pos+=size;
811 if(pos<offset)
812 {
813 len=0;
814 begin=pos;
815 }
816 if(pos>offset+length)
817 break;
818 }
819
820 *start=buffer+(offset-begin);
821 len-=(offset-begin);
822 if(len>length)
823 len=length;
824 return len;
825 }
826
827 int ipmr_mfc_info(char *buffer, char **start, off_t offset, int length, int dummy)
/* */
828 {
829 struct mfc_cache *mfc;
830 int len=0;
831 off_t pos=0;
832 off_t begin=0;
833 int size;
834 int ct;
835
836 len += sprintf(buffer,
837 "Group Origin SrcIface \n");
838 pos=len;
839
840 for (ct=0;ct<MFC_LINES;ct++)
841 {
842 cli();
843 mfc=mfc_cache_array[ct];
844 while(mfc!=NULL)
845 {
846 char *name="none";
847 char vifmap[MAXVIFS+1];
848 int n;
849 /*
850 * Device name
851 */
852 if(vifc_map&(1<<mfc->mfc_parent))
853 name=vif_table[mfc->mfc_parent].dev->name;
854 /*
855 * Interface forwarding map
856 */
857 for(n=0;n<MAXVIFS;n++)
858 if(vifc_map&(1<<n) && mfc->mfc_ttls[ct])
859 vifmap[n]='X';
860 else
861 vifmap[n]='-';
862 vifmap[n]=0;
863 /*
864 * Now print it out
865 */
866 size = sprintf(buffer+len, "%08lX %08lX %-8s %s\n",
867 (unsigned long)mfc->mfc_mcastgrp,
868 (unsigned long)mfc->mfc_origin,
869 name,
870 vifmap);
871 len+=size;
872 pos+=size;
873 if(pos<offset)
874 {
875 len=0;
876 begin=pos;
877 }
878 if(pos>offset+length)
879 {
880 sti();
881 goto done;
882 }
883 mfc=mfc->next;
884 }
885 sti();
886 }
887 done:
888 *start=buffer+(offset-begin);
889 len-=(offset-begin);
890 if(len>length)
891 len=length;
892 return len;
893 }
894
895 /*
896 * Setup for IP multicast routing
897 */
898
899 void ip_mr_init(void)
/* ![[last]](../icons/n_last.png)
*/
900 {
901 printk("Linux IP multicast router 0.04-might-work 8)\n");
902 register_netdevice_notifier(&ip_mr_notifier);
903 proc_net_register(&(struct proc_dir_entry) {
904 PROC_NET_IPMR_VIF, 9 ,"ip_mr_vif",
905 S_IFREG | S_IRUGO, 1, 0, 0,
906 0, &proc_net_inode_operations,
907 ipmr_vif_info
908 });
909 proc_net_register(&(struct proc_dir_entry) {
910 PROC_NET_IPMR_MFC, 11 ,"ip_mr_cache",
911 S_IFREG | S_IRUGO, 1, 0, 0,
912 0, &proc_net_inode_operations,
913 ipmr_mfc_info
914 });
915 }
![[bottom]](../icons/n_bottom.png){kind=icon}
*/