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