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