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