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