This source file includes following definitions.
- atalk_remove_socket
- atalk_insert_socket
- atalk_search_socket
- atalk_find_socket
- atalk_destroy_timer
- atalk_destroy_socket
- atalk_get_info
- atif_drop_device
- atif_add_device
- atif_probe_device
- atalk_find_dev_addr
- atalk_find_primary
- atalk_find_dev
- atalk_find_anynet
- atalk_find_interface
- atrtr_find
- atrtr_get_dev
- atrtr_set_default
- atrtr_create
- atrtr_delete
- atrtr_device_down
- ddp_device_event
- atif_ioctl
- atrtr_ioctl
- atalk_if_get_info
- atalk_rt_get_info
- atalk_checksum
- atalk_fcntl
- atalk_setsockopt
- atalk_getsockopt
- atalk_listen
- def_callback1
- def_callback2
- atalk_create
- atalk_dup
- atalk_release
- atalk_pick_port
- atalk_autobind
- atalk_bind
- atalk_connect
- atalk_socketpair
- atalk_accept
- atalk_getname
- atalk_rcv
- ltalk_rcv
- atalk_sendmsg
- atalk_recvmsg
- atalk_shutdown
- atalk_select
- atalk_ioctl
- atalk_proto_init
- init_module
- free_route_list
- free_interface_list
- cleanup_module
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36 #include <linux/config.h>
37 #include <linux/module.h>
38 #include <asm/segment.h>
39 #include <asm/system.h>
40 #include <asm/bitops.h>
41 #include <linux/types.h>
42 #include <linux/kernel.h>
43 #include <linux/sched.h>
44 #include <linux/string.h>
45 #include <linux/mm.h>
46 #include <linux/socket.h>
47 #include <linux/sockios.h>
48 #include <linux/in.h>
49 #include <linux/errno.h>
50 #include <linux/interrupt.h>
51 #include <linux/if_ether.h>
52 #include <linux/route.h>
53 #include <linux/inet.h>
54 #include <linux/notifier.h>
55 #include <linux/netdevice.h>
56 #include <linux/etherdevice.h>
57 #include <linux/if_arp.h>
58 #include <linux/skbuff.h>
59 #include <linux/termios.h>
60 #include <net/datalink.h>
61 #include <net/p8022.h>
62 #include <net/psnap.h>
63 #include <net/sock.h>
64 #include <linux/atalk.h>
65 #include <linux/proc_fs.h>
66 #include <linux/stat.h>
67 #include <linux/firewall.h>
68
69
70 #undef APPLETALK_DEBUG
71
72
73 #ifdef APPLETALK_DEBUG
74 #define DPRINT(x) print(x)
75 #else
76 #define DPRINT(x)
77 #endif
78
79 struct datalink_proto *ddp_dl, *aarp_dl;
80
81 #define min(a,b) (((a)<(b))?(a):(b))
82
83
84
85
86
87
88
89 static atalk_socket *volatile atalk_socket_list=NULL;
90
91
92
93
94
95
96
97 static void atalk_remove_socket(atalk_socket *sk)
98 {
99 unsigned long flags;
100 atalk_socket *s;
101
102 save_flags(flags);
103 cli();
104
105 s=atalk_socket_list;
106 if(s==sk)
107 {
108 atalk_socket_list=s->next;
109 restore_flags(flags);
110 return;
111 }
112 while(s && s->next)
113 {
114 if(s->next==sk)
115 {
116 s->next=sk->next;
117 restore_flags(flags);
118 return;
119 }
120 s=s->next;
121 }
122 restore_flags(flags);
123 }
124
125 static void atalk_insert_socket(atalk_socket *sk)
126 {
127 unsigned long flags;
128 save_flags(flags);
129 cli();
130 sk->next=atalk_socket_list;
131 atalk_socket_list=sk;
132 restore_flags(flags);
133 }
134
135 static atalk_socket *atalk_search_socket(struct sockaddr_at *to, struct atalk_iface *atif)
136 {
137 atalk_socket *s;
138
139 for( s = atalk_socket_list; s != NULL; s = s->next )
140 {
141 if ( to->sat_port != s->protinfo.af_at.src_port )
142 {
143 continue;
144 }
145
146 if ( to->sat_addr.s_net == 0 &&
147 to->sat_addr.s_node == ATADDR_BCAST &&
148 s->protinfo.af_at.src_net == atif->address.s_net )
149 {
150 break;
151 }
152
153 if ( to->sat_addr.s_net == s->protinfo.af_at.src_net &&
154 (to->sat_addr.s_node == s->protinfo.af_at.src_node
155 ||to->sat_addr.s_node == ATADDR_BCAST ))
156 {
157 break;
158 }
159
160
161 }
162 return( s );
163 }
164
165
166
167
168
169 static atalk_socket *atalk_find_socket(struct sockaddr_at *sat)
170 {
171 atalk_socket *s;
172
173 for ( s = atalk_socket_list; s != NULL; s = s->next )
174 {
175 if ( s->protinfo.af_at.src_net != sat->sat_addr.s_net )
176 {
177 continue;
178 }
179 if ( s->protinfo.af_at.src_node != sat->sat_addr.s_node )
180 {
181 continue;
182 }
183 if ( s->protinfo.af_at.src_port != sat->sat_port )
184 {
185 continue;
186 }
187 break;
188 }
189 return( s );
190 }
191
192
193
194
195
196
197
198
199 static void atalk_destroy_socket(atalk_socket *sk);
200
201
202
203
204
205 static void atalk_destroy_timer(unsigned long data)
206 {
207 atalk_destroy_socket((atalk_socket *)data);
208 }
209
210 static void atalk_destroy_socket(atalk_socket *sk)
211 {
212 struct sk_buff *skb;
213 atalk_remove_socket(sk);
214
215 while((skb=skb_dequeue(&sk->receive_queue))!=NULL)
216 {
217 kfree_skb(skb,FREE_READ);
218 }
219
220 if(sk->wmem_alloc == 0 && sk->rmem_alloc == 0 && sk->dead)
221 {
222 sk_free(sk);
223 MOD_DEC_USE_COUNT;
224 }
225 else
226 {
227
228
229
230 init_timer(&sk->timer);
231 sk->timer.expires=jiffies+10*HZ;
232 sk->timer.function=atalk_destroy_timer;
233 sk->timer.data = (unsigned long)sk;
234 add_timer(&sk->timer);
235 }
236 }
237
238
239
240
241
242
243 int atalk_get_info(char *buffer, char **start, off_t offset, int length, int dummy)
244 {
245 atalk_socket *s;
246 int len=0;
247 off_t pos=0;
248 off_t begin=0;
249
250
251
252
253
254 len += sprintf (buffer,"Type local_addr remote_addr tx_queue rx_queue st uid\n");
255 for (s = atalk_socket_list; s != NULL; s = s->next)
256 {
257 len += sprintf (buffer+len,"%02X ", s->type);
258 len += sprintf (buffer+len,"%04X:%02X:%02X ",
259 ntohs(s->protinfo.af_at.src_net),
260 s->protinfo.af_at.src_node,
261 s->protinfo.af_at.src_port);
262 len += sprintf (buffer+len,"%04X:%02X:%02X ",
263 ntohs(s->protinfo.af_at.dest_net),
264 s->protinfo.af_at.dest_node,
265 s->protinfo.af_at.dest_port);
266 len += sprintf (buffer+len,"%08X:%08X ", s->wmem_alloc, s->rmem_alloc);
267 len += sprintf (buffer+len,"%02X %d\n", s->state, SOCK_INODE(s->socket)->i_uid);
268
269
270 pos=begin+len;
271
272 if(pos<offset)
273 {
274 len=0;
275 begin=pos;
276 }
277 if(pos>offset+length)
278 break;
279 }
280
281
282 *start=buffer+(offset-begin);
283 len-=(offset-begin);
284 if(len>length)
285 len=length;
286
287 return len;
288 }
289
290
291
292
293
294
295
296
297 static struct atalk_route *atalk_router_list=NULL;
298 static struct atalk_route atrtr_default;
299 static struct atalk_iface *atalk_iface_list=NULL;
300
301
302
303
304
305
306
307
308
309
310
311 static void atif_drop_device(struct device *dev)
312 {
313 struct atalk_iface **iface = &atalk_iface_list;
314 struct atalk_iface *tmp;
315
316 while ((tmp = *iface) != NULL)
317 {
318 if (tmp->dev == dev)
319 {
320 *iface = tmp->next;
321 kfree_s(tmp, sizeof(struct atalk_iface));
322 }
323 else
324 iface = &tmp->next;
325 }
326 }
327
328 static struct atalk_iface *atif_add_device(struct device *dev, struct at_addr *sa)
329 {
330 struct atalk_iface *iface=(struct atalk_iface *)
331 kmalloc(sizeof(*iface), GFP_KERNEL);
332 unsigned long flags;
333 if(iface==NULL)
334 return NULL;
335 iface->dev=dev;
336 iface->address= *sa;
337 iface->status=0;
338 save_flags(flags);
339 cli();
340 iface->next=atalk_iface_list;
341 atalk_iface_list=iface;
342 restore_flags(flags);
343 return iface;
344 }
345
346
347
348
349
350 static int atif_probe_device(struct atalk_iface *atif)
351 {
352 int ct;
353 int netrange=ntohs(atif->nets.nr_lastnet)-ntohs(atif->nets.nr_firstnet)+1;
354 int probe_net=ntohs(atif->address.s_net);
355 int probe_node=atif->address.s_node;
356 int netct;
357 int nodect;
358
359 struct ifreq atreq;
360 struct sockaddr_at *sa;
361 int err;
362
363
364
365
366
367
368
369 if((atif->dev->type == ARPHRD_LOCALTLK || atif->dev->type == ARPHRD_PPP)
370 && atif->dev->do_ioctl)
371 {
372
373 sa = (struct sockaddr_at*)&atreq.ifr_addr;
374 sa->sat_addr.s_node = probe_node;
375 sa->sat_addr.s_net = probe_net;
376 if (!(err=atif->dev->do_ioctl(atif->dev,&atreq,SIOCSIFADDR)))
377 {
378 (void)atif->dev->do_ioctl(atif->dev,&atreq,SIOCGIFADDR);
379 atif->address.s_net=htons(sa->sat_addr.s_net);
380 atif->address.s_node=sa->sat_addr.s_node;
381 return 0;
382 }
383
384
385
386
387
388
389 return err;
390 }
391
392
393
394
395 if(probe_net==ATADDR_ANYNET)
396 {
397 if(!netrange)
398 probe_net=ntohs(atif->nets.nr_firstnet);
399 else
400 probe_net=ntohs(atif->nets.nr_firstnet) + (jiffies%netrange);
401 }
402
403 if(probe_node == ATADDR_ANYNODE)
404 probe_node = jiffies&0xFF;
405
406
407
408
409
410
411 for(netct=0;netct<=netrange;netct++)
412 {
413
414
415
416
417 atif->address.s_net=htons(probe_net);
418 for(nodect=0;nodect<256;nodect++)
419 {
420 atif->address.s_node=((nodect+probe_node)&0xFF);
421 if(atif->address.s_node>0&&atif->address.s_node<254)
422 {
423
424
425
426 for(ct=0;ct<AARP_RETRANSMIT_LIMIT;ct++)
427 {
428 aarp_send_probe(atif->dev, &atif->address);
429
430
431
432 current->timeout = jiffies + (HZ/10);
433 current->state = TASK_INTERRUPTIBLE;
434 schedule();
435 if(atif->status&ATIF_PROBE_FAIL)
436 break;
437 }
438 if(!(atif->status&ATIF_PROBE_FAIL))
439 return 0;
440 }
441 atif->status&=~ATIF_PROBE_FAIL;
442 }
443 probe_net++;
444 if(probe_net>ntohs(atif->nets.nr_lastnet))
445 probe_net=ntohs(atif->nets.nr_firstnet);
446 }
447 return -EADDRINUSE;
448 }
449
450 struct at_addr *atalk_find_dev_addr(struct device *dev)
451 {
452 struct atalk_iface *iface;
453 for(iface=atalk_iface_list;iface!=NULL;iface=iface->next)
454 if(iface->dev==dev)
455 return &iface->address;
456 return NULL;
457 }
458
459 static struct at_addr *atalk_find_primary(void)
460 {
461 struct atalk_iface *iface;
462 for(iface=atalk_iface_list;iface!=NULL;iface=iface->next)
463 if(!(iface->dev->flags&IFF_LOOPBACK))
464 return &iface->address;
465 if ( atalk_iface_list != NULL ) {
466 return &atalk_iface_list->address;
467 } else {
468 return NULL;
469 }
470 }
471
472
473
474
475
476 struct atalk_iface *atalk_find_dev(struct device *dev)
477 {
478 struct atalk_iface *iface;
479 for(iface=atalk_iface_list;iface!=NULL;iface=iface->next)
480 if(iface->dev==dev)
481 return iface;
482 return NULL;
483 }
484
485
486
487
488
489
490 static struct atalk_iface *atalk_find_anynet(int node, struct device *dev)
491 {
492 struct atalk_iface *iface;
493 for(iface=atalk_iface_list;iface!=NULL;iface=iface->next)
494 {
495 if ( iface->dev != dev || ( iface->status & ATIF_PROBE ))
496 continue;
497 if ( node == ATADDR_BCAST || iface->address.s_node == node )
498 return iface;
499 }
500 return NULL;
501 }
502
503
504
505
506
507 static struct atalk_iface *atalk_find_interface(int net, int node)
508 {
509 struct atalk_iface *iface;
510 for(iface=atalk_iface_list;iface!=NULL;iface=iface->next)
511 {
512 if((node==ATADDR_BCAST || iface->address.s_node==node)
513 && iface->address.s_net==net && !(iface->status&ATIF_PROBE))
514 return iface;
515 }
516 return NULL;
517 }
518
519
520
521
522
523
524
525
526 static struct atalk_route *atrtr_find(struct at_addr *target)
527 {
528 struct atalk_route *r;
529 for(r=atalk_router_list;r!=NULL;r=r->next)
530 {
531 if(!(r->flags&RTF_UP))
532 continue;
533 if(r->target.s_net==target->s_net)
534 {
535 if(!(r->flags&RTF_HOST) || r->target.s_node==target->s_node)
536 return r;
537 }
538 }
539 if(atrtr_default.dev)
540 return &atrtr_default;
541 return NULL;
542 }
543
544
545
546
547
548
549
550 static struct device *atrtr_get_dev(struct at_addr *sa)
551 {
552 struct atalk_route *atr=atrtr_find(sa);
553 if(atr==NULL)
554 return NULL;
555 else
556 return atr->dev;
557 }
558
559
560
561
562
563 static void atrtr_set_default(struct device *dev)
564 {
565 atrtr_default.dev=dev;
566 atrtr_default.flags= RTF_UP;
567 atrtr_default.gateway.s_net=htons(0);
568 atrtr_default.gateway.s_node=0;
569 }
570
571
572
573
574
575
576
577 static int atrtr_create(struct rtentry *r, struct device *devhint)
578 {
579 struct sockaddr_at *ta=(struct sockaddr_at *)&r->rt_dst;
580 struct sockaddr_at *ga=(struct sockaddr_at *)&r->rt_gateway;
581 struct atalk_route *rt;
582 struct atalk_iface *iface, *riface;
583 unsigned long flags;
584
585 save_flags(flags);
586
587
588
589
590
591
592
593
594
595 if(ta->sat_family!=AF_APPLETALK)
596 return -EINVAL;
597 if(devhint == NULL && ga->sat_family != AF_APPLETALK)
598 return -EINVAL;
599
600
601
602
603
604 for(rt=atalk_router_list;rt!=NULL;rt=rt->next)
605 {
606 if(r->rt_flags != rt->flags)
607 continue;
608
609 if(ta->sat_addr.s_net == rt->target.s_net)
610 {
611 if(!(rt->flags&RTF_HOST))
612 break;
613 if(ta->sat_addr.s_node == rt->target.s_node)
614 break;
615 }
616 }
617
618 if ( devhint == NULL )
619 {
620 for ( riface = NULL, iface = atalk_iface_list; iface; iface = iface->next )
621 {
622 if ( riface == NULL && ntohs( ga->sat_addr.s_net ) >= ntohs( iface->nets.nr_firstnet ) &&
623 ntohs( ga->sat_addr.s_net ) <= ntohs( iface->nets.nr_lastnet ))
624 {
625 riface = iface;
626 }
627 if ( ga->sat_addr.s_net == iface->address.s_net && ga->sat_addr.s_node == iface->address.s_node )
628 riface = iface;
629 }
630 if ( riface == NULL )
631 return -ENETUNREACH;
632 devhint = riface->dev;
633 }
634
635 if(rt==NULL)
636 {
637 rt=(struct atalk_route *)kmalloc(sizeof(struct atalk_route), GFP_KERNEL);
638 if(rt==NULL)
639 return -ENOBUFS;
640 cli();
641 rt->next=atalk_router_list;
642 atalk_router_list=rt;
643 }
644
645
646
647
648 rt->target=ta->sat_addr;
649 rt->dev=devhint;
650 rt->flags=r->rt_flags;
651 rt->gateway=ga->sat_addr;
652
653 restore_flags(flags);
654 return 0;
655 }
656
657
658
659
660
661
662 static int atrtr_delete( struct at_addr *addr )
663 {
664 struct atalk_route **r = &atalk_router_list;
665 struct atalk_route *tmp;
666
667 while ((tmp = *r) != NULL)
668 {
669 if (tmp->target.s_net == addr->s_net &&
670 (!(tmp->flags&RTF_GATEWAY) ||
671 tmp->target.s_node == addr->s_node ))
672 {
673 *r = tmp->next;
674 kfree_s(tmp, sizeof(struct atalk_route));
675 return 0;
676 }
677 r = &tmp->next;
678 }
679 return -ENOENT;
680 }
681
682
683
684
685
686
687 void atrtr_device_down(struct device *dev)
688 {
689 struct atalk_route **r = &atalk_router_list;
690 struct atalk_route *tmp;
691
692 while ((tmp = *r) != NULL)
693 {
694 if (tmp->dev == dev)
695 {
696 *r = tmp->next;
697 kfree_s(tmp, sizeof(struct atalk_route));
698 }
699 else
700 r = &tmp->next;
701 }
702 if(atrtr_default.dev==dev)
703 atrtr_set_default(NULL);
704 }
705
706
707
708
709
710
711 static int ddp_device_event(struct notifier_block *this, unsigned long event, void *ptr)
712 {
713 if(event==NETDEV_DOWN)
714 {
715
716 atrtr_device_down((struct device *)ptr);
717 atif_drop_device((struct device *)ptr);
718 }
719 return NOTIFY_DONE;
720 }
721
722
723
724
725
726
727
728
729
730 int atif_ioctl(int cmd, void *arg)
731 {
732 struct ifreq atreq;
733 static char aarp_mcast[6]={0x09,0x00,0x00,0xFF,0xFF,0xFF};
734 struct netrange *nr;
735 struct sockaddr_at *sa;
736 struct device *dev;
737 struct atalk_iface *atif;
738 int ro=(cmd==SIOCSIFADDR);
739 int err=verify_area(ro?VERIFY_READ:VERIFY_WRITE, arg,sizeof(atreq));
740 int ct;
741 int limit;
742 struct rtentry rtdef;
743
744 if(err)
745 return err;
746
747 memcpy_fromfs(&atreq,arg,sizeof(atreq));
748
749 if((dev=dev_get(atreq.ifr_name))==NULL)
750 return -ENODEV;
751
752 sa=(struct sockaddr_at*)&atreq.ifr_addr;
753 atif=atalk_find_dev(dev);
754
755 switch(cmd)
756 {
757 case SIOCSIFADDR:
758 if(!suser())
759 return -EPERM;
760 if(sa->sat_family!=AF_APPLETALK)
761 return -EINVAL;
762 if(dev->type!=ARPHRD_ETHER&&dev->type!=ARPHRD_LOOPBACK
763 &&dev->type!=ARPHRD_LOCALTLK && dev->type!=ARPHRD_PPP)
764 return -EPROTONOSUPPORT;
765 nr=(struct netrange *)&sa->sat_zero[0];
766
767
768
769
770
771 if(dev->type==ARPHRD_ETHER && nr->nr_phase!=2)
772 return -EPROTONOSUPPORT;
773 if(sa->sat_addr.s_node==ATADDR_BCAST || sa->sat_addr.s_node == 254)
774 return -EINVAL;
775 if(atif)
776 {
777
778
779
780 if(atif->status&ATIF_PROBE)
781 return -EBUSY;
782
783 atif->address.s_net=sa->sat_addr.s_net;
784 atif->address.s_node=sa->sat_addr.s_node;
785 atrtr_device_down(dev);
786 }
787 else
788 {
789 atif=atif_add_device(dev, &sa->sat_addr);
790 }
791 atif->nets= *nr;
792
793
794
795
796
797
798 if(!(dev->flags&IFF_LOOPBACK) && atif_probe_device(atif)<0)
799 {
800 atif_drop_device(dev);
801 return -EADDRINUSE;
802 }
803
804
805
806
807
808
809 sa=(struct sockaddr_at *)&rtdef.rt_gateway;
810 sa->sat_family=AF_APPLETALK;
811 sa->sat_addr.s_net=atif->address.s_net;
812 sa->sat_addr.s_node=atif->address.s_node;
813 sa=(struct sockaddr_at *)&rtdef.rt_dst;
814 rtdef.rt_flags=RTF_UP;
815 sa->sat_family=AF_APPLETALK;
816 sa->sat_addr.s_node=ATADDR_ANYNODE;
817 if(dev->flags&IFF_LOOPBACK)
818 rtdef.rt_flags|=RTF_HOST;
819
820
821
822 if(nr->nr_firstnet==htons(0) && nr->nr_lastnet==htons(0xFFFE))
823 {
824 sa->sat_addr.s_net=atif->address.s_net;
825 atrtr_create(&rtdef, dev);
826 atrtr_set_default(dev);
827 }
828 else
829 {
830 limit=ntohs(nr->nr_lastnet);
831 if(limit-ntohs(nr->nr_firstnet) > 256)
832 {
833 printk("Too many routes/iface.\n");
834 return -EINVAL;
835 }
836 for(ct=ntohs(nr->nr_firstnet);ct<=limit;ct++)
837 {
838 sa->sat_addr.s_net=htons(ct);
839 atrtr_create(&rtdef, dev);
840 }
841 }
842 dev_mc_add(dev, aarp_mcast, 6, 1);
843 return 0;
844 case SIOCGIFADDR:
845 if(atif==NULL)
846 return -EADDRNOTAVAIL;
847 ((struct sockaddr_at *)(&atreq.ifr_addr))->sat_family=AF_APPLETALK;
848 ((struct sockaddr_at *)(&atreq.ifr_addr))->sat_addr=atif->address;
849 break;
850 case SIOCGIFBRDADDR:
851 if(atif==NULL)
852 return -EADDRNOTAVAIL;
853 ((struct sockaddr_at *)(&atreq.ifr_addr))->sat_family=AF_APPLETALK;
854 ((struct sockaddr_at *)(&atreq.ifr_addr))->sat_addr.s_net=atif->address.s_net;
855 ((struct sockaddr_at *)(&atreq.ifr_addr))->sat_addr.s_node=ATADDR_BCAST;
856 break;
857 }
858 memcpy_tofs(arg,&atreq,sizeof(atreq));
859 return 0;
860 }
861
862
863
864
865
866 static int atrtr_ioctl(unsigned int cmd, void *arg)
867 {
868 int err;
869 struct rtentry rt;
870
871 err=verify_area(VERIFY_READ, arg, sizeof(rt));
872 if(err)
873 return err;
874 memcpy_fromfs(&rt,arg,sizeof(rt));
875
876 switch(cmd)
877 {
878 case SIOCDELRT:
879 if(rt.rt_dst.sa_family!=AF_APPLETALK)
880 return -EINVAL;
881 return atrtr_delete(&((struct sockaddr_at *)&rt.rt_dst)->sat_addr);
882 case SIOCADDRT:
883 return atrtr_create(&rt, NULL);
884 default:
885 return -EINVAL;
886 }
887 }
888
889
890
891 int atalk_if_get_info(char *buffer, char **start, off_t offset, int length, int dummy)
892 {
893 struct atalk_iface *iface;
894 int len=0;
895 off_t pos=0;
896 off_t begin=0;
897
898 len += sprintf (buffer,"Interface Address Networks Status\n");
899 for (iface = atalk_iface_list; iface != NULL; iface = iface->next)
900 {
901 len += sprintf (buffer+len,"%-16s %04X:%02X %04X-%04X %d\n",
902 iface->dev->name,
903 ntohs(iface->address.s_net),iface->address.s_node,
904 ntohs(iface->nets.nr_firstnet),ntohs(iface->nets.nr_lastnet),
905 iface->status);
906 pos=begin+len;
907 if(pos<offset)
908 {
909 len=0;
910 begin=pos;
911 }
912 if(pos>offset+length)
913 break;
914 }
915 *start=buffer+(offset-begin);
916 len-=(offset-begin);
917 if(len>length)
918 len=length;
919 return len;
920 }
921
922
923
924 int atalk_rt_get_info(char *buffer, char **start, off_t offset, int length, int dummy)
925 {
926 struct atalk_route *rt;
927 int len=0;
928 off_t pos=0;
929 off_t begin=0;
930
931 len += sprintf (buffer,"Target Router Flags Dev\n");
932 if(atrtr_default.dev)
933 {
934 rt=&atrtr_default;
935 len += sprintf (buffer+len,"Default %04X:%02X %-4d %s\n",
936 ntohs(rt->gateway.s_net), rt->gateway.s_node, rt->flags,
937 rt->dev->name);
938 }
939 for (rt = atalk_router_list; rt != NULL; rt = rt->next)
940 {
941 len += sprintf (buffer+len,"%04X:%02X %04X:%02X %-4d %s\n",
942 ntohs(rt->target.s_net),rt->target.s_node,
943 ntohs(rt->gateway.s_net), rt->gateway.s_node, rt->flags,
944 rt->dev->name);
945 pos=begin+len;
946 if(pos<offset)
947 {
948 len=0;
949 begin=pos;
950 }
951 if(pos>offset+length)
952 break;
953 }
954 *start=buffer+(offset-begin);
955 len-=(offset-begin);
956 if(len>length)
957 len=length;
958 return len;
959 }
960
961
962
963
964
965
966
967
968
969
970
971
972 unsigned short atalk_checksum(struct ddpehdr *ddp, int len)
973 {
974 unsigned long sum=0;
975 unsigned char *data=(unsigned char *)ddp;
976
977 len-=4;
978 data+=4;
979
980
981 while(len--)
982 {
983 sum+=*data;
984 sum<<=1;
985 if(sum&0x10000)
986 {
987 sum++;
988 sum&=0xFFFF;
989 }
990 data++;
991 }
992 if(sum)
993 return htons((unsigned short)sum);
994 return 0xFFFF;
995 }
996
997
998
999
1000
1001
1002 static int atalk_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
1003 {
1004
1005 switch(cmd)
1006 {
1007 default:
1008 return(-EINVAL);
1009 }
1010 }
1011
1012
1013
1014
1015
1016
1017 static int atalk_setsockopt(struct socket *sock, int level, int optname, char *optval, int optlen)
1018 {
1019 atalk_socket *sk;
1020 int err,opt;
1021
1022 sk=(atalk_socket *)sock->data;
1023
1024 if(optval==NULL)
1025 return(-EINVAL);
1026
1027 err=verify_area(VERIFY_READ,optval,sizeof(int));
1028 if(err)
1029 return err;
1030 opt=get_fs_long((unsigned long *)optval);
1031
1032 switch(level)
1033 {
1034 case SOL_ATALK:
1035 switch(optname)
1036 {
1037 default:
1038 return -EOPNOTSUPP;
1039 }
1040 break;
1041
1042 case SOL_SOCKET:
1043 return sock_setsockopt(sk,level,optname,optval,optlen);
1044
1045 default:
1046 return -EOPNOTSUPP;
1047 }
1048 }
1049
1050
1051
1052
1053
1054
1055 static int atalk_getsockopt(struct socket *sock, int level, int optname,
1056 char *optval, int *optlen)
1057 {
1058 atalk_socket *sk;
1059 int val=0;
1060 int err;
1061
1062 sk=(atalk_socket *)sock->data;
1063
1064 switch(level)
1065 {
1066
1067 case SOL_ATALK:
1068 switch(optname)
1069 {
1070 default:
1071 return -ENOPROTOOPT;
1072 }
1073 break;
1074
1075 case SOL_SOCKET:
1076 return sock_getsockopt(sk,level,optname,optval,optlen);
1077
1078 default:
1079 return -EOPNOTSUPP;
1080 }
1081 err=verify_area(VERIFY_WRITE,optlen,sizeof(int));
1082 if(err)
1083 return err;
1084 put_user(sizeof(int),optlen);
1085 err=verify_area(VERIFY_WRITE,optval,sizeof(int));
1086 if (err)
1087 return err;
1088 put_user(val,optval);
1089 return(0);
1090 }
1091
1092
1093
1094
1095
1096 static int atalk_listen(struct socket *sock, int backlog)
1097 {
1098 return -EOPNOTSUPP;
1099 }
1100
1101
1102
1103
1104
1105 static void def_callback1(struct sock *sk)
1106 {
1107 if(!sk->dead)
1108 wake_up_interruptible(sk->sleep);
1109 }
1110
1111 static void def_callback2(struct sock *sk, int len)
1112 {
1113 if(!sk->dead)
1114 {
1115 wake_up_interruptible(sk->sleep);
1116 sock_wake_async(sk->socket,0);
1117 }
1118 }
1119
1120
1121
1122
1123
1124
1125 static int atalk_create(struct socket *sock, int protocol)
1126 {
1127 atalk_socket *sk;
1128 sk=(atalk_socket *)sk_alloc(GFP_KERNEL);
1129 if(sk==NULL)
1130 return(-ENOMEM);
1131 switch(sock->type)
1132 {
1133
1134
1135 case SOCK_RAW:
1136
1137 case SOCK_DGRAM:
1138 break;
1139 default:
1140 sk_free((void *)sk);
1141 return(-ESOCKTNOSUPPORT);
1142 }
1143
1144 MOD_INC_USE_COUNT;
1145
1146 sk->dead=0;
1147 sk->next=NULL;
1148 sk->broadcast=0;
1149 sk->no_check=0;
1150 sk->allocation=GFP_KERNEL;
1151 sk->rcvbuf=SK_RMEM_MAX;
1152 sk->sndbuf=SK_WMEM_MAX;
1153 sk->pair=NULL;
1154 sk->wmem_alloc=0;
1155 sk->rmem_alloc=0;
1156 sk->users=0;
1157 sk->proc=0;
1158 sk->priority=1;
1159 sk->shutdown=0;
1160 sk->prot=NULL;
1161 sk->broadcast=0;
1162 sk->err=0;
1163 skb_queue_head_init(&sk->receive_queue);
1164 skb_queue_head_init(&sk->write_queue);
1165 sk->send_head=NULL;
1166 skb_queue_head_init(&sk->back_log);
1167 sk->state=TCP_CLOSE;
1168 sk->socket=sock;
1169 sk->type=sock->type;
1170 sk->debug=0;
1171
1172 sk->protinfo.af_at.src_net=0;
1173 sk->protinfo.af_at.src_node=0;
1174 sk->protinfo.af_at.src_port=0;
1175
1176 sk->protinfo.af_at.dest_net=0;
1177 sk->protinfo.af_at.dest_node=0;
1178 sk->protinfo.af_at.dest_port=0;
1179
1180 sk->mtu=DDP_MAXSZ;
1181
1182 if(sock!=NULL)
1183 {
1184 sock->data=(void *)sk;
1185 sk->sleep=sock->wait;
1186 }
1187
1188 sk->state_change=def_callback1;
1189 sk->data_ready=def_callback2;
1190 sk->write_space=def_callback1;
1191 sk->error_report=def_callback1;
1192
1193 sk->zapped=1;
1194 return(0);
1195 }
1196
1197
1198
1199
1200
1201 static int atalk_dup(struct socket *newsock,struct socket *oldsock)
1202 {
1203 return(atalk_create(newsock,SOCK_DGRAM));
1204 }
1205
1206
1207
1208
1209
1210 static int atalk_release(struct socket *sock, struct socket *peer)
1211 {
1212 atalk_socket *sk=(atalk_socket *)sock->data;
1213 if(sk==NULL)
1214 return(0);
1215 if(!sk->dead)
1216 sk->state_change(sk);
1217 sk->dead=1;
1218 sock->data=NULL;
1219 atalk_destroy_socket(sk);
1220 return(0);
1221 }
1222
1223
1224
1225
1226
1227
1228 static int atalk_pick_port(struct sockaddr_at *sat)
1229 {
1230 for ( sat->sat_port = ATPORT_RESERVED; sat->sat_port < ATPORT_LAST; sat->sat_port++ )
1231 {
1232 if ( atalk_find_socket( sat ) == NULL )
1233 return sat->sat_port;
1234 }
1235 return -EBUSY;
1236 }
1237
1238 static int atalk_autobind(atalk_socket *sk)
1239 {
1240 struct at_addr *ap = atalk_find_primary();
1241 struct sockaddr_at sat;
1242 int n;
1243
1244 if ( ap == NULL || ap->s_net == htons( ATADDR_ANYNET ))
1245 return -EADDRNOTAVAIL;
1246 sk->protinfo.af_at.src_net = sat.sat_addr.s_net = ap->s_net;
1247 sk->protinfo.af_at.src_node = sat.sat_addr.s_node = ap->s_node;
1248
1249 if (( n = atalk_pick_port( &sat )) < 0 )
1250 return( n );
1251 sk->protinfo.af_at.src_port=n;
1252 atalk_insert_socket(sk);
1253 sk->zapped=0;
1254 return 0;
1255 }
1256
1257
1258
1259
1260
1261 static int atalk_bind(struct socket *sock, struct sockaddr *uaddr,int addr_len)
1262 {
1263 atalk_socket *sk;
1264 struct sockaddr_at *addr=(struct sockaddr_at *)uaddr;
1265
1266 sk=(atalk_socket *)sock->data;
1267
1268 if(sk->zapped==0)
1269 return(-EIO);
1270
1271 if(addr_len!=sizeof(struct sockaddr_at))
1272 return -EINVAL;
1273
1274 if(addr->sat_family!=AF_APPLETALK)
1275 return -EAFNOSUPPORT;
1276
1277 if(addr->sat_addr.s_net==htons(ATADDR_ANYNET))
1278 {
1279 struct at_addr *ap=atalk_find_primary();
1280 if(ap==NULL)
1281 return -EADDRNOTAVAIL;
1282 sk->protinfo.af_at.src_net=addr->sat_addr.s_net=ap->s_net;
1283 sk->protinfo.af_at.src_node=addr->sat_addr.s_node=ap->s_node;
1284 }
1285 else
1286 {
1287 if ( atalk_find_interface( addr->sat_addr.s_net, addr->sat_addr.s_node ) == NULL )
1288 return -EADDRNOTAVAIL;
1289 sk->protinfo.af_at.src_net=addr->sat_addr.s_net;
1290 sk->protinfo.af_at.src_node=addr->sat_addr.s_node;
1291 }
1292
1293 if(addr->sat_port == ATADDR_ANYPORT)
1294 {
1295 int n = atalk_pick_port(addr);
1296 if(n < 0)
1297 return n;
1298 sk->protinfo.af_at.src_port=addr->sat_port=n;
1299 }
1300 else
1301 sk->protinfo.af_at.src_port=addr->sat_port;
1302
1303 if(atalk_find_socket(addr)!=NULL)
1304 return -EADDRINUSE;
1305
1306 atalk_insert_socket(sk);
1307 sk->zapped=0;
1308 return(0);
1309 }
1310
1311
1312
1313
1314
1315 static int atalk_connect(struct socket *sock, struct sockaddr *uaddr,
1316 int addr_len, int flags)
1317 {
1318 atalk_socket *sk=(atalk_socket *)sock->data;
1319 struct sockaddr_at *addr;
1320
1321 sk->state = TCP_CLOSE;
1322 sock->state = SS_UNCONNECTED;
1323
1324 if(addr_len!=sizeof(*addr))
1325 return(-EINVAL);
1326 addr=(struct sockaddr_at *)uaddr;
1327
1328 if(addr->sat_family!=AF_APPLETALK)
1329 return -EAFNOSUPPORT;
1330 #if 0
1331 if(addr->sat_addr.s_node==ATADDR_BCAST && !sk->broadcast)
1332 return -EPERM;
1333 #endif
1334 if(sk->zapped)
1335 {
1336 if(atalk_autobind(sk)<0)
1337 return -EBUSY;
1338 }
1339
1340 if(atrtr_get_dev(&addr->sat_addr)==NULL)
1341 return -ENETUNREACH;
1342
1343 sk->protinfo.af_at.dest_port=addr->sat_port;
1344 sk->protinfo.af_at.dest_net=addr->sat_addr.s_net;
1345 sk->protinfo.af_at.dest_node=addr->sat_addr.s_node;
1346 sock->state = SS_CONNECTED;
1347 sk->state=TCP_ESTABLISHED;
1348 return(0);
1349 }
1350
1351
1352
1353
1354
1355 static int atalk_socketpair(struct socket *sock1, struct socket *sock2)
1356 {
1357 return(-EOPNOTSUPP);
1358 }
1359
1360
1361
1362
1363
1364 static int atalk_accept(struct socket *sock, struct socket *newsock, int flags)
1365 {
1366 if(newsock->data)
1367 sk_free(newsock->data);
1368 return -EOPNOTSUPP;
1369 }
1370
1371
1372
1373
1374
1375
1376 static int atalk_getname(struct socket *sock, struct sockaddr *uaddr,
1377 int *uaddr_len, int peer)
1378 {
1379 struct sockaddr_at sat;
1380 atalk_socket *sk;
1381
1382 sk=(atalk_socket *)sock->data;
1383 if(sk->zapped)
1384 {
1385 if(atalk_autobind(sk)<0)
1386 return -EBUSY;
1387 }
1388
1389 *uaddr_len = sizeof(struct sockaddr_at);
1390
1391 if(peer)
1392 {
1393 if(sk->state!=TCP_ESTABLISHED)
1394 return -ENOTCONN;
1395 sat.sat_addr.s_net=sk->protinfo.af_at.dest_net;
1396 sat.sat_addr.s_node=sk->protinfo.af_at.dest_node;
1397 sat.sat_port=sk->protinfo.af_at.dest_port;
1398 }
1399 else
1400 {
1401 sat.sat_addr.s_net=sk->protinfo.af_at.src_net;
1402 sat.sat_addr.s_node=sk->protinfo.af_at.src_node;
1403 sat.sat_port=sk->protinfo.af_at.src_port;
1404 }
1405 sat.sat_family = AF_APPLETALK;
1406 memcpy(uaddr,&sat,sizeof(sat));
1407 return(0);
1408 }
1409
1410
1411
1412
1413
1414
1415
1416
1417 static int atalk_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
1418 {
1419 atalk_socket *sock;
1420 struct ddpehdr *ddp=(void *)skb->h.raw;
1421 struct atalk_iface *atif;
1422 struct sockaddr_at tosat;
1423 int origlen;
1424
1425
1426 if(skb->len<sizeof(*ddp))
1427 {
1428 kfree_skb(skb,FREE_READ);
1429 return(0);
1430 }
1431
1432
1433
1434
1435
1436
1437
1438
1439 *((__u16 *)ddp)=ntohs(*((__u16 *)ddp));
1440
1441
1442
1443
1444
1445 origlen = skb->len;
1446
1447 skb_trim(skb,min(skb->len,ddp->deh_len));
1448
1449
1450
1451
1452
1453
1454
1455 if(skb->len<sizeof(*ddp))
1456 {
1457 kfree_skb(skb,FREE_READ);
1458 return(0);
1459 }
1460
1461
1462
1463
1464
1465
1466 if(ddp->deh_sum && atalk_checksum(ddp, ddp->deh_len)!= ddp->deh_sum)
1467 {
1468
1469 kfree_skb(skb,FREE_READ);
1470 return(0);
1471 }
1472
1473 #ifdef CONFIG_FIREWALL
1474
1475 if(call_in_firewall(AF_APPLETALK, skb, ddp)!=FW_ACCEPT)
1476 {
1477 kfree_skb(skb, FREE_READ);
1478 return 0;
1479 }
1480
1481 #endif
1482
1483
1484
1485 if(ddp->deh_dnet == 0)
1486 atif=atalk_find_anynet(ddp->deh_dnode, dev);
1487 else
1488 atif=atalk_find_interface(ddp->deh_dnet,ddp->deh_dnode);
1489
1490
1491 if(atif==NULL)
1492 {
1493 struct atalk_route *rt;
1494 struct at_addr ta;
1495
1496
1497
1498 if (skb->pkt_type != PACKET_HOST || ddp->deh_dnet == 0)
1499 {
1500 kfree_skb(skb, FREE_READ);
1501 return(0);
1502 }
1503
1504 #ifdef CONFIG_FIREWALL
1505
1506
1507
1508
1509 if(call_fw_firewall(AF_APPLETALK, skb, ddp)!=FW_ACCEPT)
1510 {
1511 kfree_skb(skb, FREE_READ);
1512 return(0);
1513 }
1514 #endif
1515 ta.s_net=ddp->deh_dnet;
1516 ta.s_node=ddp->deh_dnode;
1517
1518
1519 rt=atrtr_find(&ta);
1520 if(rt==NULL || ddp->deh_hops==15)
1521 {
1522 kfree_skb(skb, FREE_READ);
1523 return(0);
1524 }
1525 ddp->deh_hops++;
1526
1527
1528
1529
1530
1531
1532 if(rt->flags&RTF_GATEWAY)
1533 {
1534 ta.s_net = rt->gateway.s_net;
1535 ta.s_node = rt->gateway.s_node;
1536 }
1537
1538
1539 skb_trim(skb,min(origlen, rt->dev->hard_header_len +
1540 ddp_dl->header_length + ddp->deh_len));
1541
1542 *((__u16 *)ddp)=ntohs(*((__u16 *)ddp));
1543
1544
1545
1546
1547 skb->arp = 1;
1548
1549 if(aarp_send_ddp(rt->dev, skb, &ta, NULL)==-1)
1550 kfree_skb(skb, FREE_READ);
1551 return 0;
1552 }
1553
1554
1555
1556 tosat.sat_addr.s_net = ddp->deh_dnet;
1557 tosat.sat_addr.s_node = ddp->deh_dnode;
1558 tosat.sat_port = ddp->deh_dport;
1559
1560 sock=atalk_search_socket( &tosat, atif );
1561
1562 if(sock==NULL)
1563 {
1564 kfree_skb(skb,FREE_READ);
1565 return(0);
1566 }
1567
1568
1569
1570
1571
1572
1573 skb->sk = sock;
1574
1575 if(sock_queue_rcv_skb(sock,skb)<0)
1576 {
1577 skb->sk=NULL;
1578 kfree_skb(skb, FREE_WRITE);
1579 }
1580 return(0);
1581 }
1582
1583
1584
1585
1586
1587
1588
1589
1590 static int ltalk_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
1591 {
1592 struct ddpehdr *ddp;
1593 struct at_addr *ap;
1594
1595
1596
1597
1598 if(skb->mac.raw[2]==1)
1599 {
1600
1601
1602
1603
1604 ap=atalk_find_dev_addr(dev);
1605 if(ap==NULL || skb->len<sizeof(struct ddpshdr))
1606 {
1607 kfree_skb(skb, FREE_READ);
1608 return 0;
1609 }
1610
1611
1612
1613
1614
1615
1616 skb_push(skb, sizeof(*ddp)-4);
1617 ddp=(struct ddpehdr *)skb->data;
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629 ddp->deh_dnode=skb->mac.raw[0];
1630 ddp->deh_snode=skb->mac.raw[1];
1631
1632 ddp->deh_dnet=ap->s_net;
1633 ddp->deh_snet=ap->s_net;
1634 ddp->deh_sum=0;
1635
1636
1637
1638 ddp->deh_len=skb->len;
1639 ddp->deh_hops=15;
1640
1641 *((__u16 *)ddp)=htons(*((__u16 *)ddp));
1642 }
1643 skb->h.raw = skb->data;
1644 return atalk_rcv(skb,dev,pt);
1645 }
1646
1647 static int atalk_sendmsg(struct socket *sock, struct msghdr *msg, int len, int nonblock, int flags)
1648 {
1649 atalk_socket *sk=(atalk_socket *)sock->data;
1650 struct sockaddr_at *usat=(struct sockaddr_at *)msg->msg_name;
1651 struct sockaddr_at local_satalk, gsat;
1652 struct sk_buff *skb;
1653 struct device *dev;
1654 struct ddpehdr *ddp;
1655 int size;
1656 struct atalk_route *rt;
1657 int loopback=0;
1658 int err;
1659
1660 if(flags)
1661 return -EINVAL;
1662
1663 if(len>587)
1664 return -EMSGSIZE;
1665
1666 if(usat)
1667 {
1668 if(sk->zapped)
1669
1670 {
1671 if(atalk_autobind(sk)<0)
1672 return -EBUSY;
1673 }
1674
1675 if(msg->msg_namelen <sizeof(*usat))
1676 return(-EINVAL);
1677 if(usat->sat_family != AF_APPLETALK)
1678 return -EINVAL;
1679 #if 0
1680 if(usat->sat_addr.s_node==ATADDR_BCAST && !sk->broadcast)
1681 return -EPERM;
1682 #endif
1683 }
1684 else
1685 {
1686 if(sk->state!=TCP_ESTABLISHED)
1687 return -ENOTCONN;
1688 usat=&local_satalk;
1689 usat->sat_family=AF_APPLETALK;
1690 usat->sat_port=sk->protinfo.af_at.dest_port;
1691 usat->sat_addr.s_node=sk->protinfo.af_at.dest_node;
1692 usat->sat_addr.s_net=sk->protinfo.af_at.dest_net;
1693 }
1694
1695
1696
1697 if(sk->debug)
1698 printk("SK %p: Got address.\n",sk);
1699
1700 size=sizeof(struct ddpehdr)+len+ddp_dl->header_length;
1701
1702 if(usat->sat_addr.s_net!=0 || usat->sat_addr.s_node == ATADDR_ANYNODE)
1703 {
1704 rt=atrtr_find(&usat->sat_addr);
1705 if(rt==NULL)
1706 return -ENETUNREACH;
1707 dev=rt->dev;
1708 }
1709 else
1710 {
1711 struct at_addr at_hint;
1712 at_hint.s_node=0;
1713 at_hint.s_net=sk->protinfo.af_at.src_net;
1714 rt=atrtr_find(&at_hint);
1715 if(rt==NULL)
1716 return -ENETUNREACH;
1717 dev=rt->dev;
1718 }
1719
1720 if(sk->debug)
1721 printk("SK %p: Size needed %d, device %s\n", sk, size, dev->name);
1722
1723 size += dev->hard_header_len;
1724
1725 skb = sock_alloc_send_skb(sk, size, 0, 0 , &err);
1726 if(skb==NULL)
1727 return err;
1728
1729 skb->sk=sk;
1730 skb->free=1;
1731 skb->arp=1;
1732 skb_reserve(skb,ddp_dl->header_length);
1733 skb_reserve(skb,dev->hard_header_len);
1734
1735 skb->dev=dev;
1736
1737 if(sk->debug)
1738 printk("SK %p: Begin build.\n", sk);
1739
1740 ddp=(struct ddpehdr *)skb_put(skb,sizeof(struct ddpehdr));
1741 ddp->deh_pad=0;
1742 ddp->deh_hops=0;
1743 ddp->deh_len=len+sizeof(*ddp);
1744
1745
1746
1747
1748
1749 *((__u16 *)ddp)=ntohs(*((__u16 *)ddp));
1750
1751 ddp->deh_dnet=usat->sat_addr.s_net;
1752 ddp->deh_snet=sk->protinfo.af_at.src_net;
1753 ddp->deh_dnode=usat->sat_addr.s_node;
1754 ddp->deh_snode=sk->protinfo.af_at.src_node;
1755 ddp->deh_dport=usat->sat_port;
1756 ddp->deh_sport=sk->protinfo.af_at.src_port;
1757
1758 if(sk->debug)
1759 printk("SK %p: Copy user data (%d bytes).\n", sk, len);
1760
1761 memcpy_fromiovec(skb_put(skb,len),msg->msg_iov,len);
1762
1763 if(sk->no_check==1)
1764 ddp->deh_sum=0;
1765 else
1766 ddp->deh_sum=atalk_checksum(ddp, len+sizeof(*ddp));
1767
1768 #ifdef CONFIG_FIREWALL
1769
1770 if(call_out_firewall(AF_APPLETALK, skb, ddp)!=FW_ACCEPT)
1771 {
1772 kfree_skb(skb, FREE_WRITE);
1773 return -EPERM;
1774 }
1775
1776 #endif
1777
1778
1779
1780
1781
1782
1783 if(ddp->deh_dnode==ATADDR_BCAST)
1784 {
1785 if((!(rt->flags&RTF_GATEWAY))&&(!(dev->flags&IFF_LOOPBACK)))
1786 {
1787 struct sk_buff *skb2=skb_clone(skb, GFP_KERNEL);
1788 if(skb2)
1789 {
1790 loopback=1;
1791 if(sk->debug)
1792 printk("SK %p: send out(copy).\n", sk);
1793 if(aarp_send_ddp(dev,skb2,&usat->sat_addr, NULL)==-1)
1794 kfree_skb(skb2, FREE_WRITE);
1795
1796 }
1797 }
1798 }
1799
1800 if((dev->flags&IFF_LOOPBACK) || loopback)
1801 {
1802 if(sk->debug)
1803 printk("SK %p: Loop back.\n", sk);
1804
1805 atomic_sub(skb->truesize, &sk->wmem_alloc);
1806 ddp_dl->datalink_header(ddp_dl, skb, dev->dev_addr);
1807 skb->sk = NULL;
1808 skb->mac.raw=skb->data;
1809 skb->h.raw = skb->data + ddp_dl->header_length + dev->hard_header_len;
1810 skb_pull(skb,dev->hard_header_len);
1811 skb_pull(skb,ddp_dl->header_length);
1812 atalk_rcv(skb,dev,NULL);
1813 }
1814 else
1815 {
1816 if(sk->debug)
1817 printk("SK %p: send out.\n", sk);
1818
1819 if ( rt->flags & RTF_GATEWAY ) {
1820 gsat.sat_addr = rt->gateway;
1821 usat = &gsat;
1822 }
1823
1824 if(aarp_send_ddp(dev,skb,&usat->sat_addr, NULL)==-1)
1825 kfree_skb(skb, FREE_WRITE);
1826
1827 }
1828 if(sk->debug)
1829 printk("SK %p: Done write (%d).\n", sk, len);
1830 return len;
1831 }
1832
1833
1834 static int atalk_recvmsg(struct socket *sock, struct msghdr *msg, int size, int noblock, int flags, int *addr_len)
1835 {
1836 atalk_socket *sk=(atalk_socket *)sock->data;
1837 struct sockaddr_at *sat=(struct sockaddr_at *)msg->msg_name;
1838 struct ddpehdr *ddp = NULL;
1839 int copied = 0;
1840 struct sk_buff *skb;
1841 int er;
1842
1843 if(sk->err)
1844 return sock_error(sk);
1845
1846 if(addr_len)
1847 *addr_len=sizeof(*sat);
1848
1849 skb=skb_recv_datagram(sk,flags,noblock,&er);
1850 if(skb==NULL)
1851 return er;
1852
1853 ddp = (struct ddpehdr *)(skb->h.raw);
1854 if(sk->type==SOCK_RAW)
1855 {
1856 copied=ddp->deh_len;
1857 if(copied > size)
1858 copied=size;
1859 skb_copy_datagram_iovec(skb,0,msg->msg_iov,copied);
1860 }
1861 else
1862 {
1863 copied=ddp->deh_len - sizeof(*ddp);
1864 if (copied > size)
1865 copied = size;
1866 skb_copy_datagram_iovec(skb,sizeof(*ddp),msg->msg_iov,copied);
1867 }
1868 if(sat)
1869 {
1870 sat->sat_family=AF_APPLETALK;
1871 sat->sat_port=ddp->deh_sport;
1872 sat->sat_addr.s_node=ddp->deh_snode;
1873 sat->sat_addr.s_net=ddp->deh_snet;
1874 }
1875 skb_free_datagram(sk, skb);
1876 return(copied);
1877 }
1878
1879
1880 static int atalk_shutdown(struct socket *sk,int how)
1881 {
1882 return -EOPNOTSUPP;
1883 }
1884
1885 static int atalk_select(struct socket *sock , int sel_type, select_table *wait)
1886 {
1887 atalk_socket *sk=(atalk_socket *)sock->data;
1888
1889 return datagram_select(sk,sel_type,wait);
1890 }
1891
1892
1893
1894
1895
1896 static int atalk_ioctl(struct socket *sock,unsigned int cmd, unsigned long arg)
1897 {
1898 int err;
1899 long amount=0;
1900 atalk_socket *sk=(atalk_socket *)sock->data;
1901
1902 switch(cmd)
1903 {
1904
1905
1906
1907 case TIOCOUTQ:
1908 amount=sk->sndbuf-sk->wmem_alloc;
1909 if(amount<0)
1910 amount=0;
1911 break;
1912 case TIOCINQ:
1913 {
1914 struct sk_buff *skb;
1915
1916 if((skb=skb_peek(&sk->receive_queue))!=NULL)
1917 amount=skb->len-sizeof(struct ddpehdr);
1918 break;
1919 }
1920 case SIOCGSTAMP:
1921 if (sk)
1922 {
1923 if(sk->stamp.tv_sec==0)
1924 return -ENOENT;
1925 err=verify_area(VERIFY_WRITE,(void *)arg,sizeof(struct timeval));
1926 if(err)
1927 return err;
1928 memcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval));
1929 return 0;
1930 }
1931 return -EINVAL;
1932
1933
1934
1935 case SIOCADDRT:
1936 case SIOCDELRT:
1937 if(!suser())
1938 return -EPERM;
1939 return(atrtr_ioctl(cmd,(void *)arg));
1940
1941
1942
1943 case SIOCGIFADDR:
1944 case SIOCSIFADDR:
1945 case SIOCGIFBRDADDR:
1946 return atif_ioctl(cmd,(void *)arg);
1947
1948
1949
1950 case SIOCSIFLINK:
1951 case SIOCGIFHWADDR:
1952 case SIOCSIFHWADDR:
1953 case SIOCGIFFLAGS:
1954 case SIOCSIFFLAGS:
1955 case SIOCGIFMTU:
1956 case SIOCGIFCONF:
1957 case SIOCADDMULTI:
1958 case SIOCDELMULTI:
1959
1960 return(dev_ioctl(cmd,(void *) arg));
1961
1962 case SIOCSIFMETRIC:
1963 case SIOCSIFBRDADDR:
1964 case SIOCGIFNETMASK:
1965 case SIOCSIFNETMASK:
1966 case SIOCGIFMEM:
1967 case SIOCSIFMEM:
1968 case SIOCGIFDSTADDR:
1969 case SIOCSIFDSTADDR:
1970 return -EINVAL;
1971
1972 default:
1973 return -EINVAL;
1974 }
1975 err=verify_area(VERIFY_WRITE,(void *)arg,sizeof(unsigned long));
1976 if(err)
1977 return err;
1978 put_fs_long(amount,(unsigned long *)arg);
1979 return(0);
1980 }
1981
1982 static struct proto_ops atalk_proto_ops = {
1983 AF_APPLETALK,
1984
1985 atalk_create,
1986 atalk_dup,
1987 atalk_release,
1988 atalk_bind,
1989 atalk_connect,
1990 atalk_socketpair,
1991 atalk_accept,
1992 atalk_getname,
1993 atalk_select,
1994 atalk_ioctl,
1995 atalk_listen,
1996 atalk_shutdown,
1997 atalk_setsockopt,
1998 atalk_getsockopt,
1999 atalk_fcntl,
2000 atalk_sendmsg,
2001 atalk_recvmsg
2002 };
2003
2004 static struct notifier_block ddp_notifier={
2005 ddp_device_event,
2006 NULL,
2007 0
2008 };
2009
2010 struct packet_type ltalk_packet_type=
2011 {
2012 0,
2013 NULL,
2014 ltalk_rcv,
2015 NULL,
2016 NULL
2017 };
2018
2019 struct packet_type ppptalk_packet_type=
2020 {
2021 0,
2022 NULL,
2023 atalk_rcv,
2024 NULL,
2025 NULL
2026 };
2027
2028 static char ddp_snap_id[]={0x08,0x00,0x07,0x80,0x9B};
2029
2030
2031
2032
2033 void atalk_proto_init(struct net_proto *pro)
2034 {
2035 (void) sock_register(atalk_proto_ops.family, &atalk_proto_ops);
2036 if ((ddp_dl = register_snap_client(ddp_snap_id, atalk_rcv)) == NULL)
2037 printk("Unable to register DDP with SNAP.\n");
2038
2039 ltalk_packet_type.type=htons(ETH_P_LOCALTALK);
2040 dev_add_pack(<alk_packet_type);
2041
2042 ppptalk_packet_type.type=htons(ETH_P_PPPTALK);
2043 dev_add_pack(&ppptalk_packet_type);
2044
2045 register_netdevice_notifier(&ddp_notifier);
2046 aarp_proto_init();
2047
2048 proc_net_register(&(struct proc_dir_entry) {
2049 PROC_NET_ATALK, 9, "appletalk",
2050 S_IFREG | S_IRUGO, 1, 0, 0,
2051 0, &proc_net_inode_operations,
2052 atalk_get_info
2053 });
2054 proc_net_register(&(struct proc_dir_entry) {
2055 PROC_NET_AT_ROUTE, 11,"atalk_route",
2056 S_IFREG | S_IRUGO, 1, 0, 0,
2057 0, &proc_net_inode_operations,
2058 atalk_rt_get_info
2059 });
2060 proc_net_register(&(struct proc_dir_entry) {
2061 PROC_NET_ATIF, 11,"atalk_iface",
2062 S_IFREG | S_IRUGO, 1, 0, 0,
2063 0, &proc_net_inode_operations,
2064 atalk_if_get_info
2065 });
2066
2067 printk(KERN_INFO "Appletalk 0.17 for Linux NET3.034\n");
2068 }
2069
2070 #ifdef MODULE
2071
2072 int init_module(void)
2073 {
2074 atalk_proto_init(NULL);
2075 register_symtab(0);
2076 return 0;
2077 }
2078
2079
2080
2081
2082
2083
2084
2085 extern inline void free_route_list(void)
2086 {
2087 struct atalk_route *list = atalk_router_list, *tmp;
2088
2089 while (list != NULL)
2090 {
2091 tmp = list->next;
2092 kfree_s(list, sizeof(struct atalk_route));
2093 list = tmp;
2094 }
2095 }
2096
2097
2098 extern inline void free_interface_list(void)
2099 {
2100 struct atalk_iface *list = atalk_iface_list, *tmp;
2101
2102 while (list != NULL)
2103 {
2104 tmp = list->next;
2105 kfree_s(list, sizeof(struct atalk_iface));
2106 list = tmp;
2107 }
2108 }
2109
2110 void cleanup_module(void)
2111 {
2112 unsigned long flags;
2113
2114 save_flags(flags);
2115 cli();
2116
2117 aarp_cleanup_module();
2118
2119 proc_net_unregister(PROC_NET_ATALK);
2120 proc_net_unregister(PROC_NET_AT_ROUTE);
2121 proc_net_unregister(PROC_NET_ATIF);
2122 unregister_netdevice_notifier(&ddp_notifier);
2123 dev_remove_pack(<alk_packet_type);
2124 dev_remove_pack(&ppptalk_packet_type);
2125 unregister_snap_client(ddp_snap_id);
2126 sock_unregister(atalk_proto_ops.family);
2127
2128 free_route_list();
2129 free_interface_list();
2130
2131 restore_flags(flags);
2132 }
2133
2134 #endif