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