This source file includes following definitions.
- ipxcfg_set_auto_create
- ipxcfg_set_auto_select
- ipxcfg_get_config_data
- ipx_remove_socket
- ipx_destroy_socket
- ipxitf_clear_primary_net
- ipxitf_find_using_phys
- ipxitf_find_using_net
- ipxitf_insert_socket
- ipxitf_find_socket
- ipxitf_find_internal_socket
- ipxitf_down
- ipxitf_device_event
- ipxitf_def_skb_handler
- ipxitf_demux_socket
- ipxitf_demux_socket
- ipxitf_adjust_skbuff
- ipxitf_send
- ipxitf_add_local_route
- ipxitf_rcv
- ipxitf_insert
- ipxitf_create_internal
- ipx_map_frame_type
- ipxitf_create
- ipxitf_delete
- ipxitf_auto_create
- ipxitf_ioctl
- ipxrtr_lookup
- ipxrtr_add_route
- ipxrtr_del_routes
- ipxrtr_create
- ipxrtr_delete
- ipxrtr_route_packet
- ipxrtr_route_skb
- ipxrtr_ioctl
- ipx_frame_name
- ipx_device_name
- ipx_interface_get_info
- ipx_get_info
- ipx_rt_get_info
- ipx_fcntl
- ipx_setsockopt
- ipx_getsockopt
- ipx_listen
- def_callback1
- def_callback2
- ipx_create
- ipx_release
- ipx_dup
- ipx_first_free_socketnum
- ipx_bind
- ipx_connect
- ipx_socketpair
- ipx_accept
- ipx_getname
- dump_data
- dump_addr
- dump_hdr
- dump_pkt
- ipx_rcv
- ipx_sendmsg
- ipx_recvmsg
- ipx_shutdown
- ipx_select
- ipx_ioctl
- ipx_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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49 #include <linux/config.h>
50 #include <linux/errno.h>
51 #include <linux/types.h>
52 #include <linux/socket.h>
53 #include <linux/in.h>
54 #include <linux/kernel.h>
55 #include <linux/sched.h>
56 #include <linux/timer.h>
57 #include <linux/string.h>
58 #include <linux/sockios.h>
59 #include <linux/net.h>
60 #include <linux/ipx.h>
61 #include <linux/inet.h>
62 #include <linux/netdevice.h>
63 #include <linux/route.h>
64 #include <linux/skbuff.h>
65 #include <net/sock.h>
66 #include <asm/segment.h>
67 #include <asm/system.h>
68 #include <linux/fcntl.h>
69 #include <linux/mm.h>
70 #include <linux/termios.h>
71 #include <linux/interrupt.h>
72 #include <net/p8022.h>
73 #include <net/psnap.h>
74 #include <linux/proc_fs.h>
75 #include <linux/stat.h>
76 #include <linux/firewall.h>
77
78 #ifdef CONFIG_IPX
79
80 static unsigned char ipxcfg_max_hops = 16;
81 static char ipxcfg_auto_select_primary = 0;
82 static char ipxcfg_auto_create_interfaces = 0;
83
84
85 static struct datalink_proto *p8022_datalink = NULL;
86 static struct datalink_proto *pEII_datalink = NULL;
87 static struct datalink_proto *p8023_datalink = NULL;
88 static struct datalink_proto *pSNAP_datalink = NULL;
89
90 static ipx_interface *ipx_interfaces = NULL;
91 static ipx_route *ipx_routes = NULL;
92 static ipx_interface *ipx_internal_net = NULL;
93 static ipx_interface *ipx_primary_net = NULL;
94
95 static int
96 ipxcfg_set_auto_create(char val)
97 {
98 ipxcfg_auto_create_interfaces = val;
99 return 0;
100 }
101
102 static int
103 ipxcfg_set_auto_select(char val)
104 {
105 ipxcfg_auto_select_primary = val;
106 if (val && (ipx_primary_net == NULL))
107 ipx_primary_net = ipx_interfaces;
108 return 0;
109 }
110
111 static int
112 ipxcfg_get_config_data(ipx_config_data *arg)
113 {
114 ipx_config_data vals;
115
116 vals.ipxcfg_auto_create_interfaces = ipxcfg_auto_create_interfaces;
117 vals.ipxcfg_auto_select_primary = ipxcfg_auto_select_primary;
118 memcpy_tofs(arg, &vals, sizeof(vals));
119 return 0;
120 }
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135 static void
136 ipx_remove_socket(ipx_socket *sk)
137 {
138 ipx_socket *s;
139 ipx_interface *intrfc;
140 unsigned long flags;
141
142 save_flags(flags);
143 cli();
144
145
146 intrfc = sk->ipx_intrfc;
147 if (intrfc == NULL) {
148 restore_flags(flags);
149 return;
150 }
151
152 s=intrfc->if_sklist;
153 if(s==sk) {
154 intrfc->if_sklist=s->next;
155 restore_flags(flags);
156 return;
157 }
158
159 while(s && s->next) {
160 if(s->next==sk) {
161 s->next=sk->next;
162 restore_flags(flags);
163 return;
164 }
165 s=s->next;
166 }
167 restore_flags(flags);
168 }
169
170
171
172
173
174
175
176
177 static void
178 ipx_destroy_socket(ipx_socket *sk)
179 {
180 struct sk_buff *skb;
181
182 ipx_remove_socket(sk);
183 while((skb=skb_dequeue(&sk->receive_queue))!=NULL) {
184 kfree_skb(skb,FREE_READ);
185 }
186
187 kfree_s(sk,sizeof(*sk));
188 }
189
190
191
192
193
194 static ipx_route * ipxrtr_lookup(unsigned long);
195
196 static void
197 ipxitf_clear_primary_net(void)
198 {
199 if (ipxcfg_auto_select_primary && (ipx_interfaces != NULL))
200 ipx_primary_net = ipx_interfaces;
201 else
202 ipx_primary_net = NULL;
203 }
204
205 static ipx_interface *
206 ipxitf_find_using_phys(struct device *dev, unsigned short datalink)
207 {
208 ipx_interface *i;
209
210 for (i=ipx_interfaces;
211 i && ((i->if_dev!=dev) || (i->if_dlink_type!=datalink));
212 i=i->if_next)
213 ;
214 return i;
215 }
216
217 static ipx_interface *
218 ipxitf_find_using_net(unsigned long net)
219 {
220 ipx_interface *i;
221
222 if (net == 0L)
223 return ipx_primary_net;
224
225 for (i=ipx_interfaces; i && (i->if_netnum!=net); i=i->if_next)
226 ;
227
228 return i;
229 }
230
231
232 static void
233 ipxitf_insert_socket(ipx_interface *intrfc, ipx_socket *sk)
234 {
235 ipx_socket *s;
236
237 sk->ipx_intrfc = intrfc;
238 sk->next = NULL;
239 if (intrfc->if_sklist == NULL) {
240 intrfc->if_sklist = sk;
241 } else {
242 for (s = intrfc->if_sklist; s->next != NULL; s = s->next)
243 ;
244 s->next = sk;
245 }
246 }
247
248 static ipx_socket *
249 ipxitf_find_socket(ipx_interface *intrfc, unsigned short port)
250 {
251 ipx_socket *s;
252
253 for (s=intrfc->if_sklist;
254 (s != NULL) && (s->ipx_port != port);
255 s=s->next)
256 ;
257
258 return s;
259 }
260
261 #ifdef CONFIG_IPX_INTERN
262
263 static ipx_socket *
264 ipxitf_find_internal_socket(ipx_interface *intrfc,
265 unsigned char *node, unsigned short port)
266 {
267 ipx_socket *s = intrfc->if_sklist;
268
269 while (s != NULL)
270 {
271 if ( (s->ipx_port == port)
272 && (memcmp(node, s->ipx_node, IPX_NODE_LEN) == 0))
273 {
274 break;
275 }
276 s = s->next;
277 }
278 return s;
279 }
280 #endif
281
282 static void ipxrtr_del_routes(ipx_interface *);
283
284 static void
285 ipxitf_down(ipx_interface *intrfc)
286 {
287 ipx_interface *i;
288 ipx_socket *s, *t;
289
290
291 ipxrtr_del_routes(intrfc);
292
293
294 for (s = intrfc->if_sklist; s != NULL; ) {
295 s->err = ENOLINK;
296 s->error_report(s);
297 s->ipx_intrfc = NULL;
298 s->ipx_port = 0;
299 s->zapped=1;
300 t = s;
301 s = s->next;
302 t->next = NULL;
303 }
304 intrfc->if_sklist = NULL;
305
306
307 if (intrfc == ipx_interfaces) {
308 ipx_interfaces = intrfc->if_next;
309 } else {
310 for (i = ipx_interfaces;
311 (i != NULL) && (i->if_next != intrfc);
312 i = i->if_next)
313 ;
314 if ((i != NULL) && (i->if_next == intrfc))
315 i->if_next = intrfc->if_next;
316 }
317
318
319 if (intrfc == ipx_primary_net)
320 ipxitf_clear_primary_net();
321 if (intrfc == ipx_internal_net)
322 ipx_internal_net = NULL;
323
324 kfree_s(intrfc, sizeof(*intrfc));
325 }
326
327 static int
328 ipxitf_device_event(struct notifier_block *notifier, unsigned long event, void *ptr)
329 {
330 struct device *dev = ptr;
331 ipx_interface *i, *tmp;
332
333 if(event!=NETDEV_DOWN)
334 return NOTIFY_DONE;
335
336 for (i = ipx_interfaces; i != NULL; ) {
337
338 tmp = i->if_next;
339 if (i->if_dev == dev)
340 ipxitf_down(i);
341 i = tmp;
342
343 }
344
345 return NOTIFY_DONE;
346 }
347
348 static int ipxitf_def_skb_handler(struct sock *sock, struct sk_buff *skb)
349 {
350 int retval;
351
352 if((retval = sock_queue_rcv_skb(sock, skb))<0)
353 {
354
355
356
357
358 kfree_skb(skb,FREE_WRITE);
359 }
360 return retval;
361 }
362
363
364
365
366
367 #ifdef CONFIG_IPX_INTERN
368 static int
369 ipxitf_demux_socket(ipx_interface *intrfc, struct sk_buff *skb, int copy)
370 {
371 ipx_packet *ipx = (ipx_packet *)(skb->h.raw);
372 ipx_socket *s;
373
374 int is_broadcast = (memcmp(ipx->ipx_dest.node, ipx_broadcast_node,
375 IPX_NODE_LEN) == 0);
376
377 s = intrfc->if_sklist;
378
379 while (s != NULL)
380 {
381 if ( (s->ipx_port == ipx->ipx_dest.sock)
382 && ( is_broadcast
383 || (memcmp(ipx->ipx_dest.node, s->ipx_node,
384 IPX_NODE_LEN) == 0)))
385 {
386
387 struct sk_buff *skb1;
388
389 if (copy != 0)
390 {
391 skb1 = skb_clone(skb, GFP_ATOMIC);
392 if (skb1 != NULL)
393 {
394 skb1->arp = skb1->free = 1;
395 }
396 else
397 {
398 return -ENOMEM;
399 }
400 }
401 else
402 {
403 skb1 = skb;
404 copy = 1;
405 }
406 ipxitf_def_skb_handler(s, skb1);
407
408 if (intrfc != ipx_internal_net)
409 {
410
411
412
413 break;
414 }
415 }
416 s = s->next;
417 }
418
419 if (copy == 0)
420 {
421
422
423
424
425 kfree_skb(skb, FREE_WRITE);
426 }
427 return 0;
428 }
429
430 #else
431
432 static int
433 ipxitf_demux_socket(ipx_interface *intrfc, struct sk_buff *skb, int copy)
434 {
435 ipx_packet *ipx = (ipx_packet *)(skb->h.raw);
436 ipx_socket *sock1 = NULL, *sock2 = NULL;
437 struct sk_buff *skb1 = NULL, *skb2 = NULL;
438
439 sock1 = ipxitf_find_socket(intrfc, ipx->ipx_dest.sock);
440
441
442
443
444
445
446
447
448
449 if (ipx_primary_net && (intrfc != ipx_primary_net))
450 {
451 switch (ntohs(ipx->ipx_dest.sock))
452 {
453 case 0x452:
454 case 0x453:
455 case 0x456:
456
457
458
459
460
461
462 sock2 = ipxitf_find_socket(ipx_primary_net,
463 ipx->ipx_dest.sock);
464 break;
465 default:
466 break;
467 }
468 }
469
470
471
472
473
474
475 if (sock1 == NULL && sock2 == NULL)
476 {
477 if (!copy)
478 kfree_skb(skb,FREE_WRITE);
479 return 0;
480 }
481
482
483
484
485
486
487
488
489
490 if (copy)
491 {
492 skb1 = skb_clone(skb, GFP_ATOMIC);
493 if (skb1 != NULL)
494 skb1->arp = skb1->free = 1;
495 }
496 else
497 {
498 skb1 = skb;
499 }
500
501 if (skb1 == NULL)
502 return -ENOMEM;
503
504
505
506
507
508 if (sock1 && sock2)
509 {
510 skb2 = skb_clone(skb1, GFP_ATOMIC);
511 if (skb2 != NULL)
512 skb2->arp = skb2->free = 1;
513 }
514 else
515 skb2 = skb1;
516
517 if (sock1)
518 (void) ipxitf_def_skb_handler(sock1, skb1);
519
520 if (skb2 == NULL)
521 return -ENOMEM;
522
523 if (sock2)
524 (void) ipxitf_def_skb_handler(sock2, skb2);
525
526 return 0;
527 }
528 #endif
529
530 static struct sk_buff *
531 ipxitf_adjust_skbuff(ipx_interface *intrfc, struct sk_buff *skb)
532 {
533 struct sk_buff *skb2;
534 int in_offset = skb->h.raw - skb->head;
535 int out_offset = intrfc->if_ipx_offset;
536 int len;
537
538
539 if (in_offset >= out_offset) {
540 skb->arp = skb->free = 1;
541 return skb;
542 }
543
544
545 len = skb->len + out_offset;
546 skb2 = alloc_skb(len, GFP_ATOMIC);
547 if (skb2 != NULL) {
548 skb_reserve(skb2,out_offset);
549 skb2->h.raw=skb_put(skb2,skb->len);
550 skb2->free=1;
551 skb2->arp=1;
552 memcpy(skb2->h.raw, skb->h.raw, skb->len);
553 }
554 kfree_skb(skb, FREE_WRITE);
555 return skb2;
556 }
557
558 static int ipxitf_send(ipx_interface *intrfc, struct sk_buff *skb, char *node)
559 {
560 ipx_packet *ipx = (ipx_packet *)(skb->h.raw);
561 struct device *dev = intrfc->if_dev;
562 struct datalink_proto *dl = intrfc->if_dlink;
563 char dest_node[IPX_NODE_LEN];
564 int send_to_wire = 1;
565 int addr_len;
566
567
568
569
570
571
572 if ((dl == NULL) || (dev == NULL) || (dev->flags & IFF_LOOPBACK))
573 send_to_wire = 0;
574
575
576
577
578
579
580
581
582 if (ipx->ipx_dest.net == intrfc->if_netnum)
583 {
584
585
586
587 if (memcmp(intrfc->if_node, node, IPX_NODE_LEN) == 0)
588 {
589
590
591
592 if(skb->sk)
593 {
594 skb->sk->wmem_alloc-=skb->truesize;
595 skb->sk=NULL;
596 }
597
598
599
600 return ipxitf_demux_socket(intrfc, skb, 0);
601 }
602
603
604
605 if (memcmp(ipx_broadcast_node, node, IPX_NODE_LEN) == 0)
606 {
607 if (!send_to_wire && skb->sk)
608 {
609 skb->sk->wmem_alloc-=skb->truesize;
610 skb->sk=NULL;
611 }
612 ipxitf_demux_socket(intrfc, skb, send_to_wire);
613 if (!send_to_wire)
614 return 0;
615 }
616 }
617
618
619
620
621
622
623
624 if (ipx->ipx_source.net != intrfc->if_netnum)
625 {
626 if (++(ipx->ipx_tctrl) > ipxcfg_max_hops)
627 send_to_wire = 0;
628 }
629
630 if (!send_to_wire)
631 {
632
633
634
635
636
637
638
639
640 kfree_skb(skb,FREE_WRITE);
641 return 0;
642 }
643
644
645
646
647
648 addr_len = dev->addr_len;
649 if (memcmp(ipx_broadcast_node, node, IPX_NODE_LEN) == 0)
650 memcpy(dest_node, dev->broadcast, addr_len);
651 else
652 memcpy(dest_node, &(node[IPX_NODE_LEN-addr_len]), addr_len);
653
654
655
656
657
658 skb = ipxitf_adjust_skbuff(intrfc, skb);
659 if (skb == NULL)
660 return 0;
661
662
663 skb->dev = dev;
664 skb->protocol = htons(ETH_P_IPX);
665 dl->datalink_header(dl, skb, dest_node);
666 #if 0
667
668
669
670
671 dump_pkt("IPX snd:", (ipx_packet *)skb->h.raw);
672 dump_data("ETH hdr:", skb->data, skb->h.raw - skb->data);
673 #endif
674
675
676
677
678
679 dev_queue_xmit(skb, dev, SOPRI_NORMAL);
680 return 0;
681 }
682
683 static int ipxrtr_add_route(unsigned long, ipx_interface *, unsigned char *);
684
685 static int ipxitf_add_local_route(ipx_interface *intrfc)
686 {
687 return ipxrtr_add_route(intrfc->if_netnum, intrfc, NULL);
688 }
689
690 static const char * ipx_frame_name(unsigned short);
691 static const char * ipx_device_name(ipx_interface *);
692 static int ipxrtr_route_skb(struct sk_buff *);
693
694 static int ipxitf_rcv(ipx_interface *intrfc, struct sk_buff *skb)
695 {
696 ipx_packet *ipx = (ipx_packet *) (skb->h.raw);
697 ipx_interface *i;
698
699 #ifdef CONFIG_FIREWALL
700
701
702
703
704 if (call_in_firewall(PF_IPX, skb, ipx)!=FW_ACCEPT)
705 {
706 kfree_skb(skb, FREE_READ);
707 return 0;
708 }
709
710 #endif
711
712
713 if ((intrfc->if_netnum == 0L) &&
714 (ipx->ipx_source.net == ipx->ipx_dest.net) &&
715 (ipx->ipx_source.net != 0L))
716 {
717
718
719
720
721 if ((i=ipxitf_find_using_net(ipx->ipx_source.net))==NULL)
722 {
723 intrfc->if_netnum = ipx->ipx_source.net;
724 (void) ipxitf_add_local_route(intrfc);
725 }
726 else
727 {
728 printk("IPX: Network number collision %lx\n\t%s %s and %s %s\n",
729 htonl(ipx->ipx_source.net),
730 ipx_device_name(i),
731 ipx_frame_name(i->if_dlink_type),
732 ipx_device_name(intrfc),
733 ipx_frame_name(intrfc->if_dlink_type));
734 }
735 }
736
737 if (ipx->ipx_dest.net == 0L)
738 ipx->ipx_dest.net = intrfc->if_netnum;
739 if (ipx->ipx_source.net == 0L)
740 ipx->ipx_source.net = intrfc->if_netnum;
741
742 if (intrfc->if_netnum != ipx->ipx_dest.net)
743 {
744 #ifdef CONFIG_FIREWALL
745
746
747
748 if (call_fw_firewall(PF_IPX, skb, ipx)!=FW_ACCEPT)
749 {
750 kfree_skb(skb, FREE_READ);
751 return 0;
752 }
753 #endif
754
755 if ((skb->pkt_type != PACKET_BROADCAST) &&
756 (skb->pkt_type != PACKET_MULTICAST))
757 return ipxrtr_route_skb(skb);
758
759 kfree_skb(skb,FREE_READ);
760 return 0;
761 }
762
763
764 if ((memcmp(ipx_broadcast_node, ipx->ipx_dest.node, IPX_NODE_LEN) == 0)
765 || (memcmp(intrfc->if_node, ipx->ipx_dest.node, IPX_NODE_LEN) == 0))
766 {
767 return ipxitf_demux_socket(intrfc, skb, 0);
768 }
769
770
771 kfree_skb(skb,FREE_READ);
772 return 0;
773 }
774
775 static void
776 ipxitf_insert(ipx_interface *intrfc)
777 {
778 ipx_interface *i;
779
780 intrfc->if_next = NULL;
781 if (ipx_interfaces == NULL) {
782 ipx_interfaces = intrfc;
783 } else {
784 for (i = ipx_interfaces; i->if_next != NULL; i = i->if_next)
785 ;
786 i->if_next = intrfc;
787 }
788
789 if (ipxcfg_auto_select_primary && (ipx_primary_net == NULL))
790 ipx_primary_net = intrfc;
791 }
792
793 static int
794 ipxitf_create_internal(ipx_interface_definition *idef)
795 {
796 ipx_interface *intrfc;
797
798
799 if (ipx_primary_net != NULL) return -EEXIST;
800
801
802 if (idef->ipx_network == 0L) return -EADDRNOTAVAIL;
803 if (ipxitf_find_using_net(idef->ipx_network) != NULL)
804 return -EADDRINUSE;
805
806 intrfc=(ipx_interface *)kmalloc(sizeof(ipx_interface),GFP_ATOMIC);
807 if (intrfc==NULL)
808 return -EAGAIN;
809 intrfc->if_dev=NULL;
810 intrfc->if_netnum=idef->ipx_network;
811 intrfc->if_dlink_type = 0;
812 intrfc->if_dlink = NULL;
813 intrfc->if_sklist = NULL;
814 intrfc->if_internal = 1;
815 intrfc->if_ipx_offset = 0;
816 intrfc->if_sknum = IPX_MIN_EPHEMERAL_SOCKET;
817 memcpy((char *)&(intrfc->if_node), idef->ipx_node, IPX_NODE_LEN);
818 ipx_internal_net = intrfc;
819 ipx_primary_net = intrfc;
820 ipxitf_insert(intrfc);
821 return ipxitf_add_local_route(intrfc);
822 }
823
824 static int
825 ipx_map_frame_type(unsigned char type)
826 {
827 switch (type) {
828 case IPX_FRAME_ETHERII: return htons(ETH_P_IPX);
829 case IPX_FRAME_8022: return htons(ETH_P_802_2);
830 case IPX_FRAME_SNAP: return htons(ETH_P_SNAP);
831 case IPX_FRAME_8023: return htons(ETH_P_802_3);
832 }
833 return 0;
834 }
835
836 static int
837 ipxitf_create(ipx_interface_definition *idef)
838 {
839 struct device *dev;
840 unsigned short dlink_type = 0;
841 struct datalink_proto *datalink = NULL;
842 ipx_interface *intrfc;
843
844 if (idef->ipx_special == IPX_INTERNAL)
845 return ipxitf_create_internal(idef);
846
847 if ((idef->ipx_special == IPX_PRIMARY) && (ipx_primary_net != NULL))
848 return -EEXIST;
849
850 if ((idef->ipx_network != 0L) &&
851 (ipxitf_find_using_net(idef->ipx_network) != NULL))
852 return -EADDRINUSE;
853
854 switch (idef->ipx_dlink_type) {
855 case IPX_FRAME_ETHERII:
856 dlink_type = htons(ETH_P_IPX);
857 datalink = pEII_datalink;
858 break;
859 case IPX_FRAME_8022:
860 dlink_type = htons(ETH_P_802_2);
861 datalink = p8022_datalink;
862 break;
863 case IPX_FRAME_SNAP:
864 dlink_type = htons(ETH_P_SNAP);
865 datalink = pSNAP_datalink;
866 break;
867 case IPX_FRAME_8023:
868 dlink_type = htons(ETH_P_802_3);
869 datalink = p8023_datalink;
870 break;
871 case IPX_FRAME_NONE:
872 default:
873 break;
874 }
875
876 if (datalink == NULL)
877 return -EPROTONOSUPPORT;
878
879 dev=dev_get(idef->ipx_device);
880 if (dev==NULL)
881 return -ENODEV;
882
883 if (!(dev->flags & IFF_UP))
884 return -ENETDOWN;
885
886
887 if(dev->addr_len>IPX_NODE_LEN)
888 return -EINVAL;
889
890 if ((intrfc = ipxitf_find_using_phys(dev, dlink_type)) == NULL) {
891
892
893 intrfc=(ipx_interface *)kmalloc(sizeof(ipx_interface),GFP_ATOMIC);
894 if (intrfc==NULL)
895 return -EAGAIN;
896 intrfc->if_dev=dev;
897 intrfc->if_netnum=idef->ipx_network;
898 intrfc->if_dlink_type = dlink_type;
899 intrfc->if_dlink = datalink;
900 intrfc->if_sklist = NULL;
901 intrfc->if_sknum = IPX_MIN_EPHEMERAL_SOCKET;
902
903 if ((idef->ipx_special == IPX_PRIMARY))
904 ipx_primary_net = intrfc;
905 intrfc->if_internal = 0;
906 intrfc->if_ipx_offset = dev->hard_header_len + datalink->header_length;
907 memset(intrfc->if_node, 0, IPX_NODE_LEN);
908 memcpy((char *)&(intrfc->if_node[IPX_NODE_LEN-dev->addr_len]), dev->dev_addr, dev->addr_len);
909
910 ipxitf_insert(intrfc);
911 }
912
913
914 if (intrfc->if_netnum == 0L)
915 return 0;
916
917 return ipxitf_add_local_route(intrfc);
918 }
919
920 static int
921 ipxitf_delete(ipx_interface_definition *idef)
922 {
923 struct device *dev = NULL;
924 unsigned short dlink_type = 0;
925 ipx_interface *intrfc;
926
927 if (idef->ipx_special == IPX_INTERNAL) {
928 if (ipx_internal_net != NULL) {
929 ipxitf_down(ipx_internal_net);
930 return 0;
931 }
932 return -ENOENT;
933 }
934
935 dlink_type = ipx_map_frame_type(idef->ipx_dlink_type);
936 if (dlink_type == 0)
937 return -EPROTONOSUPPORT;
938
939 dev=dev_get(idef->ipx_device);
940 if(dev==NULL) return -ENODEV;
941
942 intrfc = ipxitf_find_using_phys(dev, dlink_type);
943 if (intrfc != NULL) {
944 ipxitf_down(intrfc);
945 return 0;
946 }
947 return -EINVAL;
948 }
949
950 static ipx_interface *
951 ipxitf_auto_create(struct device *dev, unsigned short dlink_type)
952 {
953 struct datalink_proto *datalink = NULL;
954 ipx_interface *intrfc;
955
956 switch (htons(dlink_type)) {
957 case ETH_P_IPX: datalink = pEII_datalink; break;
958 case ETH_P_802_2: datalink = p8022_datalink; break;
959 case ETH_P_SNAP: datalink = pSNAP_datalink; break;
960 case ETH_P_802_3: datalink = p8023_datalink; break;
961 default: return NULL;
962 }
963
964 if (dev == NULL)
965 return NULL;
966
967
968 if(dev->addr_len>IPX_NODE_LEN) return NULL;
969
970 intrfc=(ipx_interface *)kmalloc(sizeof(ipx_interface),GFP_ATOMIC);
971 if (intrfc!=NULL) {
972 intrfc->if_dev=dev;
973 intrfc->if_netnum=0L;
974 intrfc->if_dlink_type = dlink_type;
975 intrfc->if_dlink = datalink;
976 intrfc->if_sklist = NULL;
977 intrfc->if_internal = 0;
978 intrfc->if_sknum = IPX_MIN_EPHEMERAL_SOCKET;
979 intrfc->if_ipx_offset = dev->hard_header_len +
980 datalink->header_length;
981 memset(intrfc->if_node, 0, IPX_NODE_LEN);
982 memcpy((char *)&(intrfc->if_node[IPX_NODE_LEN-dev->addr_len]),
983 dev->dev_addr, dev->addr_len);
984 ipxitf_insert(intrfc);
985 }
986
987 return intrfc;
988 }
989
990 static int
991 ipxitf_ioctl(unsigned int cmd, void *arg)
992 {
993 int err;
994 switch(cmd)
995 {
996 case SIOCSIFADDR:
997 {
998 struct ifreq ifr;
999 struct sockaddr_ipx *sipx;
1000 ipx_interface_definition f;
1001 err=verify_area(VERIFY_READ,arg,sizeof(ifr));
1002 if(err)
1003 return err;
1004 memcpy_fromfs(&ifr,arg,sizeof(ifr));
1005 sipx=(struct sockaddr_ipx *)&ifr.ifr_addr;
1006 if(sipx->sipx_family!=AF_IPX)
1007 return -EINVAL;
1008 f.ipx_network=sipx->sipx_network;
1009 memcpy(f.ipx_device, ifr.ifr_name, sizeof(f.ipx_device));
1010 memcpy(f.ipx_node, sipx->sipx_node, IPX_NODE_LEN);
1011 f.ipx_dlink_type=sipx->sipx_type;
1012 f.ipx_special=sipx->sipx_special;
1013 if(sipx->sipx_action==IPX_DLTITF)
1014 return ipxitf_delete(&f);
1015 else
1016 return ipxitf_create(&f);
1017 }
1018 case SIOCGIFADDR:
1019 {
1020 struct ifreq ifr;
1021 struct sockaddr_ipx *sipx;
1022 ipx_interface *ipxif;
1023 struct device *dev;
1024 err=verify_area(VERIFY_WRITE,arg,sizeof(ifr));
1025 if(err)
1026 return err;
1027 memcpy_fromfs(&ifr,arg,sizeof(ifr));
1028 sipx=(struct sockaddr_ipx *)&ifr.ifr_addr;
1029 dev=dev_get(ifr.ifr_name);
1030 if(!dev)
1031 return -ENODEV;
1032 ipxif=ipxitf_find_using_phys(dev, ipx_map_frame_type(sipx->sipx_type));
1033 if(ipxif==NULL)
1034 return -EADDRNOTAVAIL;
1035 sipx->sipx_family=AF_IPX;
1036 sipx->sipx_network=ipxif->if_netnum;
1037 memcpy(sipx->sipx_node, ipxif->if_node, sizeof(sipx->sipx_node));
1038 memcpy_tofs(arg,&ifr,sizeof(ifr));
1039 return 0;
1040 }
1041 case SIOCAIPXITFCRT:
1042 err=verify_area(VERIFY_READ,arg,sizeof(char));
1043 if(err)
1044 return err;
1045 return ipxcfg_set_auto_create(get_fs_byte(arg));
1046 case SIOCAIPXPRISLT:
1047 err=verify_area(VERIFY_READ,arg,sizeof(char));
1048 if(err)
1049 return err;
1050 return ipxcfg_set_auto_select(get_fs_byte(arg));
1051 default:
1052 return -EINVAL;
1053 }
1054 }
1055
1056
1057
1058
1059
1060
1061
1062 static ipx_route *
1063 ipxrtr_lookup(unsigned long net)
1064 {
1065 ipx_route *r;
1066
1067 for (r=ipx_routes; (r!=NULL) && (r->ir_net!=net); r=r->ir_next)
1068 ;
1069
1070 return r;
1071 }
1072
1073 static int
1074 ipxrtr_add_route(unsigned long network, ipx_interface *intrfc, unsigned char *node)
1075 {
1076 ipx_route *rt;
1077
1078
1079 rt = ipxrtr_lookup(network);
1080 if (rt==NULL) {
1081 rt=(ipx_route *)kmalloc(sizeof(ipx_route),GFP_ATOMIC);
1082 if(rt==NULL)
1083 return -EAGAIN;
1084 rt->ir_next=ipx_routes;
1085 ipx_routes=rt;
1086 }
1087 else if (intrfc == ipx_internal_net)
1088 return(-EINVAL);
1089
1090 rt->ir_net = network;
1091 rt->ir_intrfc = intrfc;
1092 if (node == NULL) {
1093 memset(rt->ir_router_node, '\0', IPX_NODE_LEN);
1094 rt->ir_routed = 0;
1095 } else {
1096 memcpy(rt->ir_router_node, node, IPX_NODE_LEN);
1097 rt->ir_routed=1;
1098 }
1099 return 0;
1100 }
1101
1102 static void
1103 ipxrtr_del_routes(ipx_interface *intrfc)
1104 {
1105 ipx_route **r, *tmp;
1106
1107 for (r = &ipx_routes; (tmp = *r) != NULL; ) {
1108 if (tmp->ir_intrfc == intrfc) {
1109 *r = tmp->ir_next;
1110 kfree_s(tmp, sizeof(ipx_route));
1111 } else {
1112 r = &(tmp->ir_next);
1113 }
1114 }
1115 }
1116
1117 static int
1118 ipxrtr_create(ipx_route_definition *rd)
1119 {
1120 ipx_interface *intrfc;
1121
1122
1123 intrfc = ipxitf_find_using_net(rd->ipx_router_network);
1124 if (intrfc == NULL)
1125 return -ENETUNREACH;
1126
1127 return ipxrtr_add_route(rd->ipx_network, intrfc, rd->ipx_router_node);
1128 }
1129
1130
1131 static int
1132 ipxrtr_delete(long net)
1133 {
1134 ipx_route **r;
1135 ipx_route *tmp;
1136
1137 for (r = &ipx_routes; (tmp = *r) != NULL; ) {
1138 if (tmp->ir_net == net) {
1139 if (!(tmp->ir_routed)) {
1140
1141 return -EPERM;
1142 }
1143 *r = tmp->ir_next;
1144 kfree_s(tmp, sizeof(ipx_route));
1145 return 0;
1146 }
1147 r = &(tmp->ir_next);
1148 }
1149
1150 return -ENOENT;
1151 }
1152
1153
1154
1155
1156
1157 static int ipxrtr_route_packet(ipx_socket *sk, struct sockaddr_ipx *usipx, struct iovec *iov, int len)
1158 {
1159 struct sk_buff *skb;
1160 ipx_interface *intrfc;
1161 ipx_packet *ipx;
1162 int size;
1163 int ipx_offset;
1164 ipx_route *rt = NULL;
1165 int err;
1166
1167
1168 if ((usipx->sipx_network == 0L) && (ipx_primary_net != NULL))
1169 {
1170 usipx->sipx_network = ipx_primary_net->if_netnum;
1171 intrfc = ipx_primary_net;
1172 }
1173 else
1174 {
1175 rt = ipxrtr_lookup(usipx->sipx_network);
1176 if (rt==NULL) {
1177 return -ENETUNREACH;
1178 }
1179 intrfc = rt->ir_intrfc;
1180 }
1181
1182 ipx_offset = intrfc->if_ipx_offset;
1183 size=sizeof(ipx_packet)+len;
1184 size += ipx_offset;
1185
1186 skb=sock_alloc_send_skb(sk, size, 0, 0, &err);
1187 if(skb==NULL)
1188 return err;
1189
1190 skb_reserve(skb,ipx_offset);
1191 skb->free=1;
1192 skb->arp=1;
1193 skb->sk=sk;
1194
1195
1196 ipx=(ipx_packet *)skb_put(skb,sizeof(ipx_packet));
1197 ipx->ipx_checksum=0xFFFF;
1198 ipx->ipx_pktsize=htons(len+sizeof(ipx_packet));
1199 ipx->ipx_tctrl=0;
1200 ipx->ipx_type=usipx->sipx_type;
1201 skb->h.raw = (unsigned char *)ipx;
1202
1203 ipx->ipx_source.net = sk->ipx_intrfc->if_netnum;
1204 #ifdef CONFIG_IPX_INTERN
1205 memcpy(ipx->ipx_source.node, sk->ipx_node, IPX_NODE_LEN);
1206 #else
1207 if ((err = ntohs(sk->ipx_port)) == 0x453 || err == 0x452)
1208 {
1209
1210 ipx->ipx_source.net = intrfc->if_netnum;
1211 memcpy(ipx->ipx_source.node, intrfc->if_node, IPX_NODE_LEN);
1212 }
1213 else
1214 {
1215 ipx->ipx_source.net = sk->ipx_intrfc->if_netnum;
1216 memcpy(ipx->ipx_source.node, sk->ipx_intrfc->if_node, IPX_NODE_LEN);
1217 }
1218 #endif
1219 ipx->ipx_source.sock = sk->ipx_port;
1220 ipx->ipx_dest.net=usipx->sipx_network;
1221 memcpy(ipx->ipx_dest.node,usipx->sipx_node,IPX_NODE_LEN);
1222 ipx->ipx_dest.sock=usipx->sipx_port;
1223
1224 memcpy_fromiovec(skb_put(skb,len),iov,len);
1225
1226 #ifdef CONFIG_FIREWALL
1227 if(call_out_firewall(PF_IPX, skb, ipx)!=FW_ACCEPT)
1228 {
1229 kfree_skb(skb, FREE_WRITE);
1230 return -EPERM;
1231 }
1232 #endif
1233
1234 return ipxitf_send(intrfc, skb, (rt && rt->ir_routed) ?
1235 rt->ir_router_node : ipx->ipx_dest.node);
1236 }
1237
1238 static int
1239 ipxrtr_route_skb(struct sk_buff *skb)
1240 {
1241 ipx_packet *ipx = (ipx_packet *) (skb->h.raw);
1242 ipx_route *r;
1243 ipx_interface *i;
1244
1245 r = ipxrtr_lookup(ipx->ipx_dest.net);
1246 if (r == NULL) {
1247
1248 kfree_skb(skb,FREE_READ);
1249 return 0;
1250 }
1251 i = r->ir_intrfc;
1252 (void)ipxitf_send(i, skb, (r->ir_routed) ?
1253 r->ir_router_node : ipx->ipx_dest.node);
1254 return 0;
1255 }
1256
1257
1258
1259
1260
1261 static int ipxrtr_ioctl(unsigned int cmd, void *arg)
1262 {
1263 int err;
1264 struct rtentry rt;
1265 struct sockaddr_ipx *sg,*st;
1266
1267 err=verify_area(VERIFY_READ,arg,sizeof(rt));
1268 if(err)
1269 return err;
1270
1271 memcpy_fromfs(&rt,arg,sizeof(rt));
1272
1273 sg=(struct sockaddr_ipx *)&rt.rt_gateway;
1274 st=(struct sockaddr_ipx *)&rt.rt_dst;
1275
1276 if(!(rt.rt_flags&RTF_GATEWAY))
1277 return -EINVAL;
1278 if(sg->sipx_family!=AF_IPX)
1279 return -EINVAL;
1280 if(st->sipx_family!=AF_IPX)
1281 return -EINVAL;
1282
1283 switch(cmd)
1284 {
1285 case SIOCDELRT:
1286 return ipxrtr_delete(st->sipx_network);
1287 case SIOCADDRT:
1288 {
1289 struct ipx_route_definition f;
1290 f.ipx_network=st->sipx_network;
1291 f.ipx_router_network=sg->sipx_network;
1292 memcpy(f.ipx_router_node, sg->sipx_node, IPX_NODE_LEN);
1293 return ipxrtr_create(&f);
1294 }
1295 default:
1296 return -EINVAL;
1297 }
1298 }
1299
1300 static const char *
1301 ipx_frame_name(unsigned short frame)
1302 {
1303 switch (ntohs(frame)) {
1304 case ETH_P_IPX: return "EtherII";
1305 case ETH_P_802_2: return "802.2";
1306 case ETH_P_SNAP: return "SNAP";
1307 case ETH_P_802_3: return "802.3";
1308 default: return "None";
1309 }
1310 }
1311
1312 static const char *
1313 ipx_device_name(ipx_interface *intrfc)
1314 {
1315 return (intrfc->if_internal ? "Internal" :
1316 (intrfc->if_dev ? intrfc->if_dev->name : "Unknown"));
1317 }
1318
1319
1320 static int ipx_interface_get_info(char *buffer, char **start, off_t offset,
1321 int length, int dummy)
1322 {
1323 ipx_interface *i;
1324 int len=0;
1325 off_t pos=0;
1326 off_t begin=0;
1327
1328
1329
1330 len += sprintf (buffer,"%-11s%-15s%-9s%-11s%s\n", "Network",
1331 "Node_Address", "Primary", "Device", "Frame_Type");
1332 for (i = ipx_interfaces; i != NULL; i = i->if_next) {
1333 len += sprintf(buffer+len, "%08lX ", ntohl(i->if_netnum));
1334 len += sprintf (buffer+len,"%02X%02X%02X%02X%02X%02X ",
1335 i->if_node[0], i->if_node[1], i->if_node[2],
1336 i->if_node[3], i->if_node[4], i->if_node[5]);
1337 len += sprintf(buffer+len, "%-9s", (i == ipx_primary_net) ?
1338 "Yes" : "No");
1339 len += sprintf (buffer+len, "%-11s", ipx_device_name(i));
1340 len += sprintf (buffer+len, "%s\n",
1341 ipx_frame_name(i->if_dlink_type));
1342
1343
1344 pos=begin+len;
1345
1346 if(pos<offset) {
1347 len=0;
1348 begin=pos;
1349 }
1350 if(pos>offset+length)
1351 break;
1352 }
1353
1354
1355 *start=buffer+(offset-begin);
1356 len-=(offset-begin);
1357 if(len>length)
1358 len=length;
1359
1360 return len;
1361 }
1362
1363 static int ipx_get_info(char *buffer, char **start, off_t offset,
1364 int length, int dummy)
1365 {
1366 ipx_socket *s;
1367 ipx_interface *i;
1368 int len=0;
1369 off_t pos=0;
1370 off_t begin=0;
1371
1372
1373
1374 #ifdef CONFIG_IPX_INTERN
1375 len += sprintf (buffer,"%-28s%-28s%-10s%-10s%-7s%s\n", "Local_Address",
1376 #else
1377 len += sprintf (buffer,"%-15s%-28s%-10s%-10s%-7s%s\n", "Local_Address",
1378 #endif
1379 "Remote_Address", "Tx_Queue", "Rx_Queue",
1380 "State", "Uid");
1381 for (i = ipx_interfaces; i != NULL; i = i->if_next) {
1382 for (s = i->if_sklist; s != NULL; s = s->next) {
1383 #ifdef CONFIG_IPX_INTERN
1384 len += sprintf(buffer+len,
1385 "%08lX:%02X%02X%02X%02X%02X%02X:%04X ",
1386 htonl(s->ipx_intrfc->if_netnum),
1387 s->ipx_node[0], s->ipx_node[1],
1388 s->ipx_node[2], s->ipx_node[3],
1389 s->ipx_node[4], s->ipx_node[5],
1390 htons(s->ipx_port));
1391 #else
1392 len += sprintf(buffer+len,"%08lX:%04X ",
1393 htonl(i->if_netnum),
1394 htons(s->ipx_port));
1395 #endif
1396 if (s->state!=TCP_ESTABLISHED) {
1397 len += sprintf(buffer+len, "%-28s", "Not_Connected");
1398 } else {
1399 len += sprintf (buffer+len,
1400 "%08lX:%02X%02X%02X%02X%02X%02X:%04X ",
1401 htonl(s->ipx_dest_addr.net),
1402 s->ipx_dest_addr.node[0], s->ipx_dest_addr.node[1],
1403 s->ipx_dest_addr.node[2], s->ipx_dest_addr.node[3],
1404 s->ipx_dest_addr.node[4], s->ipx_dest_addr.node[5],
1405 htons(s->ipx_dest_addr.sock));
1406 }
1407 len += sprintf (buffer+len,"%08lX %08lX ",
1408 s->wmem_alloc, s->rmem_alloc);
1409 len += sprintf (buffer+len,"%02X %03d\n",
1410 s->state, SOCK_INODE(s->socket)->i_uid);
1411
1412
1413 pos=begin+len;
1414
1415 if(pos<offset)
1416 {
1417 len=0;
1418 begin=pos;
1419 }
1420 if(pos>offset+length)
1421 break;
1422 }
1423 }
1424
1425
1426 *start=buffer+(offset-begin);
1427 len-=(offset-begin);
1428 if(len>length)
1429 len=length;
1430
1431 return len;
1432 }
1433
1434 static int ipx_rt_get_info(char *buffer, char **start, off_t offset,
1435 int length, int dummy)
1436 {
1437 ipx_route *rt;
1438 int len=0;
1439 off_t pos=0;
1440 off_t begin=0;
1441
1442 len += sprintf (buffer,"%-11s%-13s%s\n",
1443 "Network", "Router_Net", "Router_Node");
1444 for (rt = ipx_routes; rt != NULL; rt = rt->ir_next)
1445 {
1446 len += sprintf (buffer+len,"%08lX ", ntohl(rt->ir_net));
1447 if (rt->ir_routed) {
1448 len += sprintf (buffer+len,"%08lX %02X%02X%02X%02X%02X%02X\n",
1449 ntohl(rt->ir_intrfc->if_netnum),
1450 rt->ir_router_node[0], rt->ir_router_node[1],
1451 rt->ir_router_node[2], rt->ir_router_node[3],
1452 rt->ir_router_node[4], rt->ir_router_node[5]);
1453 } else {
1454 len += sprintf (buffer+len, "%-13s%s\n",
1455 "Directly", "Connected");
1456 }
1457 pos=begin+len;
1458 if(pos<offset)
1459 {
1460 len=0;
1461 begin=pos;
1462 }
1463 if(pos>offset+length)
1464 break;
1465 }
1466 *start=buffer+(offset-begin);
1467 len-=(offset-begin);
1468 if(len>length)
1469 len=length;
1470 return len;
1471 }
1472
1473
1474
1475
1476
1477
1478
1479 static int ipx_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
1480 {
1481 switch(cmd)
1482 {
1483 default:
1484 return(-EINVAL);
1485 }
1486 }
1487
1488 static int ipx_setsockopt(struct socket *sock, int level, int optname, char *optval, int optlen)
1489 {
1490 ipx_socket *sk;
1491 int err,opt;
1492
1493 sk=(ipx_socket *)sock->data;
1494
1495 if(optval==NULL)
1496 return(-EINVAL);
1497
1498 err=verify_area(VERIFY_READ,optval,sizeof(int));
1499 if(err)
1500 return err;
1501 opt=get_fs_long((unsigned long *)optval);
1502
1503 switch(level)
1504 {
1505 case SOL_IPX:
1506 switch(optname)
1507 {
1508 case IPX_TYPE:
1509 sk->ipx_type=opt;
1510 return 0;
1511 default:
1512 return -EOPNOTSUPP;
1513 }
1514 break;
1515
1516 case SOL_SOCKET:
1517 return sock_setsockopt(sk,level,optname,optval,optlen);
1518
1519 default:
1520 return -EOPNOTSUPP;
1521 }
1522 }
1523
1524 static int ipx_getsockopt(struct socket *sock, int level, int optname,
1525 char *optval, int *optlen)
1526 {
1527 ipx_socket *sk;
1528 int val=0;
1529 int err;
1530
1531 sk=(ipx_socket *)sock->data;
1532
1533 switch(level)
1534 {
1535
1536 case SOL_IPX:
1537 switch(optname)
1538 {
1539 case IPX_TYPE:
1540 val=sk->ipx_type;
1541 break;
1542 default:
1543 return -ENOPROTOOPT;
1544 }
1545 break;
1546
1547 case SOL_SOCKET:
1548 return sock_getsockopt(sk,level,optname,optval,optlen);
1549
1550 default:
1551 return -EOPNOTSUPP;
1552 }
1553 err=verify_area(VERIFY_WRITE,optlen,sizeof(int));
1554 if(err)
1555 return err;
1556 put_fs_long(sizeof(int),(unsigned long *)optlen);
1557 err=verify_area(VERIFY_WRITE,optval,sizeof(int));
1558 if (err) return err;
1559 put_fs_long(val,(unsigned long *)optval);
1560 return(0);
1561 }
1562
1563 static int ipx_listen(struct socket *sock, int backlog)
1564 {
1565 return -EOPNOTSUPP;
1566 }
1567
1568 static void def_callback1(struct sock *sk)
1569 {
1570 if(!sk->dead)
1571 wake_up_interruptible(sk->sleep);
1572 }
1573
1574 static void def_callback2(struct sock *sk, int len)
1575 {
1576 if(!sk->dead)
1577 {
1578 wake_up_interruptible(sk->sleep);
1579 sock_wake_async(sk->socket, 1);
1580 }
1581 }
1582
1583 static int
1584 ipx_create(struct socket *sock, int protocol)
1585 {
1586 ipx_socket *sk;
1587 sk=(ipx_socket *)kmalloc(sizeof(*sk),GFP_KERNEL);
1588 if(sk==NULL)
1589 return(-ENOMEM);
1590 switch(sock->type)
1591 {
1592 case SOCK_DGRAM:
1593 break;
1594 default:
1595 kfree_s((void *)sk,sizeof(*sk));
1596 return(-ESOCKTNOSUPPORT);
1597 }
1598 sk->dead=0;
1599 sk->next=NULL;
1600 sk->broadcast=0;
1601 sk->rcvbuf=SK_RMEM_MAX;
1602 sk->sndbuf=SK_WMEM_MAX;
1603 sk->wmem_alloc=0;
1604 sk->rmem_alloc=0;
1605 sk->users=0;
1606 sk->shutdown=0;
1607 sk->prot=NULL;
1608 sk->err=0;
1609 skb_queue_head_init(&sk->receive_queue);
1610 skb_queue_head_init(&sk->write_queue);
1611 sk->send_head=NULL;
1612 skb_queue_head_init(&sk->back_log);
1613 sk->state=TCP_CLOSE;
1614 sk->socket=sock;
1615 sk->type=sock->type;
1616 sk->ipx_type=0;
1617 sk->debug=0;
1618 sk->ipx_intrfc = NULL;
1619 memset(&sk->ipx_dest_addr,'\0',sizeof(sk->ipx_dest_addr));
1620 sk->ipx_port = 0;
1621 sk->mtu=IPX_MTU;
1622
1623 if(sock!=NULL)
1624 {
1625 sock->data=(void *)sk;
1626 sk->sleep=sock->wait;
1627 }
1628
1629 sk->state_change=def_callback1;
1630 sk->data_ready=def_callback2;
1631 sk->write_space=def_callback1;
1632 sk->error_report=def_callback1;
1633
1634 sk->zapped=1;
1635 return 0;
1636 }
1637
1638 static int ipx_release(struct socket *sock, struct socket *peer)
1639 {
1640 ipx_socket *sk=(ipx_socket *)sock->data;
1641 if(sk==NULL)
1642 return(0);
1643 if(!sk->dead)
1644 sk->state_change(sk);
1645 sk->dead=1;
1646 sock->data=NULL;
1647 ipx_destroy_socket(sk);
1648 return(0);
1649 }
1650
1651 static int ipx_dup(struct socket *newsock,struct socket *oldsock)
1652 {
1653 return(ipx_create(newsock,SOCK_DGRAM));
1654 }
1655
1656 static unsigned short
1657 ipx_first_free_socketnum(ipx_interface *intrfc)
1658 {
1659 unsigned short socketNum = intrfc->if_sknum;
1660
1661 if (socketNum < IPX_MIN_EPHEMERAL_SOCKET)
1662 socketNum = IPX_MIN_EPHEMERAL_SOCKET;
1663
1664 while (ipxitf_find_socket(intrfc, ntohs(socketNum)) != NULL)
1665 if (socketNum > IPX_MAX_EPHEMERAL_SOCKET)
1666 socketNum = IPX_MIN_EPHEMERAL_SOCKET;
1667 else
1668 socketNum++;
1669
1670 intrfc->if_sknum = socketNum;
1671 return ntohs(socketNum);
1672 }
1673
1674 static int ipx_bind(struct socket *sock, struct sockaddr *uaddr,int addr_len)
1675 {
1676 ipx_socket *sk;
1677 ipx_interface *intrfc;
1678 struct sockaddr_ipx *addr=(struct sockaddr_ipx *)uaddr;
1679
1680 sk=(ipx_socket *)sock->data;
1681
1682 if(sk->zapped==0)
1683 return -EIO;
1684
1685 if(addr_len!=sizeof(struct sockaddr_ipx))
1686 return -EINVAL;
1687
1688 intrfc = ipxitf_find_using_net(addr->sipx_network);
1689 if (intrfc == NULL)
1690 return -EADDRNOTAVAIL;
1691
1692 if (addr->sipx_port == 0) {
1693 addr->sipx_port = ipx_first_free_socketnum(intrfc);
1694 if (addr->sipx_port == 0)
1695 return -EINVAL;
1696 }
1697
1698 if(ntohs(addr->sipx_port)<IPX_MIN_EPHEMERAL_SOCKET && !suser())
1699 return -EPERM;
1700
1701 sk->ipx_port=addr->sipx_port;
1702
1703 #ifdef CONFIG_IPX_INTERN
1704 if (intrfc == ipx_internal_net)
1705 {
1706
1707
1708
1709
1710
1711 if (memcmp(addr->sipx_node, ipx_broadcast_node,
1712 IPX_NODE_LEN) == 0)
1713 {
1714 return -EINVAL;
1715 }
1716 if (memcmp(addr->sipx_node, ipx_this_node, IPX_NODE_LEN) == 0)
1717 {
1718 memcpy(sk->ipx_node, intrfc->if_node,
1719 IPX_NODE_LEN);
1720 }
1721 else
1722 {
1723 memcpy(sk->ipx_node, addr->sipx_node, IPX_NODE_LEN);
1724 }
1725 if (ipxitf_find_internal_socket(intrfc, sk->ipx_node,
1726 sk->ipx_port) != NULL)
1727 {
1728 if(sk->debug)
1729 printk("IPX: bind failed because port %X in"
1730 " use.\n", (int)addr->sipx_port);
1731 return -EADDRINUSE;
1732 }
1733 }
1734 else
1735 {
1736
1737
1738
1739
1740
1741 memcpy(sk->ipx_node, intrfc->if_node, IPX_NODE_LEN);
1742
1743 if(ipxitf_find_socket(intrfc, addr->sipx_port)!=NULL) {
1744 if(sk->debug)
1745 printk("IPX: bind failed because port %X in"
1746 " use.\n", (int)addr->sipx_port);
1747 return -EADDRINUSE;
1748 }
1749 }
1750
1751 #else
1752
1753
1754
1755
1756 if(ipxitf_find_socket(intrfc, addr->sipx_port)!=NULL) {
1757 if(sk->debug)
1758 printk("IPX: bind failed because port %X in use.\n",
1759 (int)addr->sipx_port);
1760 return -EADDRINUSE;
1761 }
1762
1763 #endif
1764
1765 ipxitf_insert_socket(intrfc, sk);
1766 sk->zapped=0;
1767 if(sk->debug)
1768 printk("IPX: socket is bound.\n");
1769 return 0;
1770 }
1771
1772 static int ipx_connect(struct socket *sock, struct sockaddr *uaddr,
1773 int addr_len, int flags)
1774 {
1775 ipx_socket *sk=(ipx_socket *)sock->data;
1776 struct sockaddr_ipx *addr;
1777
1778 sk->state = TCP_CLOSE;
1779 sock->state = SS_UNCONNECTED;
1780
1781 if(addr_len!=sizeof(*addr))
1782 return(-EINVAL);
1783 addr=(struct sockaddr_ipx *)uaddr;
1784
1785 if(sk->ipx_port==0)
1786
1787 {
1788 struct sockaddr_ipx uaddr;
1789 int ret;
1790
1791 uaddr.sipx_port = 0;
1792 uaddr.sipx_network = 0L;
1793 #ifdef CONFIG_IPX_INTERN
1794 memcpy(uaddr.sipx_node, sk->ipx_intrfc->if_node,
1795 IPX_NODE_LEN);
1796 #endif
1797 ret = ipx_bind (sock, (struct sockaddr *)&uaddr,
1798 sizeof(struct sockaddr_ipx));
1799 if (ret != 0) return (ret);
1800 }
1801
1802 if(ipxrtr_lookup(addr->sipx_network)==NULL)
1803 return -ENETUNREACH;
1804 sk->ipx_dest_addr.net=addr->sipx_network;
1805 sk->ipx_dest_addr.sock=addr->sipx_port;
1806 memcpy(sk->ipx_dest_addr.node,addr->sipx_node,IPX_NODE_LEN);
1807 sk->ipx_type=addr->sipx_type;
1808 sock->state = SS_CONNECTED;
1809 sk->state=TCP_ESTABLISHED;
1810 return 0;
1811 }
1812
1813 static int ipx_socketpair(struct socket *sock1, struct socket *sock2)
1814 {
1815 return(-EOPNOTSUPP);
1816 }
1817
1818 static int ipx_accept(struct socket *sock, struct socket *newsock, int flags)
1819 {
1820 if(newsock->data)
1821 kfree_s(newsock->data,sizeof(ipx_socket));
1822 return -EOPNOTSUPP;
1823 }
1824
1825 static int ipx_getname(struct socket *sock, struct sockaddr *uaddr,
1826 int *uaddr_len, int peer)
1827 {
1828 ipx_address *addr;
1829 struct sockaddr_ipx sipx;
1830 ipx_socket *sk;
1831
1832 sk=(ipx_socket *)sock->data;
1833
1834 *uaddr_len = sizeof(struct sockaddr_ipx);
1835
1836 if(peer) {
1837 if(sk->state!=TCP_ESTABLISHED)
1838 return -ENOTCONN;
1839 addr=&sk->ipx_dest_addr;
1840 sipx.sipx_network = addr->net;
1841 memcpy(sipx.sipx_node,addr->node,IPX_NODE_LEN);
1842 sipx.sipx_port = addr->sock;
1843 } else {
1844 if (sk->ipx_intrfc != NULL) {
1845 sipx.sipx_network = sk->ipx_intrfc->if_netnum;
1846 #ifdef CONFIG_IPX_INTERN
1847 memcpy(sipx.sipx_node, sk->ipx_node, IPX_NODE_LEN);
1848 #else
1849 memcpy(sipx.sipx_node, sk->ipx_intrfc->if_node,
1850 IPX_NODE_LEN);
1851 #endif
1852
1853 } else {
1854 sipx.sipx_network = 0L;
1855 memset(sipx.sipx_node, '\0', IPX_NODE_LEN);
1856 }
1857 sipx.sipx_port = sk->ipx_port;
1858 }
1859
1860 sipx.sipx_family = AF_IPX;
1861 sipx.sipx_type = sk->ipx_type;
1862 memcpy(uaddr,&sipx,sizeof(sipx));
1863 return 0;
1864 }
1865
1866 #if 0
1867
1868
1869
1870 void dump_data(char *str,unsigned char *d, int len) {
1871 static char h2c[] = "0123456789ABCDEF";
1872 int l,i;
1873 char *p, b[64];
1874 for (l=0;len > 0 && l<16;l++) {
1875 p = b;
1876 for (i=0; i < 8 ; i++, --len) {
1877 if (len > 0) {
1878 *(p++) = h2c[(d[i] >> 4) & 0x0f];
1879 *(p++) = h2c[d[i] & 0x0f];
1880 }
1881 else {
1882 *(p++) = ' ';
1883 *(p++) = ' ';
1884 }
1885 *(p++) = ' ';
1886 }
1887 *(p++) = '-';
1888 *(p++) = ' ';
1889 len += 8;
1890 for (i=0; i < 8 ; i++, --len)
1891 if (len > 0)
1892 *(p++) = ' '<= d[i] && d[i]<'\177' ? d[i] : '.';
1893 else
1894 *(p++) = ' ';
1895 *p = '\000';
1896 d += i;
1897 printk("%s-%04X: %s\n",str,l*8,b);
1898 }
1899 }
1900
1901 void dump_addr(char *str,ipx_address *p) {
1902 printk("%s: %08X:%02X%02X%02X%02X%02X%02X:%04X\n",
1903 str,ntohl(p->net),p->node[0],p->node[1],p->node[2],
1904 p->node[3],p->node[4],p->node[5],ntohs(p->sock));
1905 }
1906
1907 void dump_hdr(char *str,ipx_packet *p) {
1908 printk("%s: CHKSUM=%04X SIZE=%d (%04X) HOPS=%d (%02X) TYPE=%02X\n",
1909 str,p->ipx_checksum,ntohs(p->ipx_pktsize),ntohs(p->ipx_pktsize),
1910 p->ipx_tctrl,p->ipx_tctrl,p->ipx_type);
1911 dump_addr(" IPX-DST",&p->ipx_dest);
1912 dump_addr(" IPX-SRC",&p->ipx_source);
1913 }
1914
1915 void dump_pkt(char *str,ipx_packet *p) {
1916 int len = ntohs(p->ipx_pktsize);
1917 dump_hdr(str,p);
1918 if (len > 30)
1919 dump_data(str,(unsigned char *)p + 30, len - 30);
1920 }
1921 #endif
1922
1923 int ipx_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
1924 {
1925
1926 ipx_interface *intrfc;
1927 ipx_packet *ipx;
1928
1929
1930 ipx=(ipx_packet *)skb->h.raw;
1931
1932 if(ipx->ipx_checksum!=IPX_NO_CHECKSUM) {
1933
1934
1935
1936 kfree_skb(skb,FREE_READ);
1937 return 0;
1938 }
1939
1940
1941 if(htons(ipx->ipx_pktsize)<sizeof(ipx_packet)) {
1942 kfree_skb(skb,FREE_READ);
1943 return 0;
1944 }
1945
1946
1947 intrfc = ipxitf_find_using_phys(dev, pt->type);
1948 if (intrfc == NULL) {
1949 if (ipxcfg_auto_create_interfaces) {
1950 intrfc = ipxitf_auto_create(dev, pt->type);
1951 }
1952
1953 if (intrfc == NULL) {
1954
1955 kfree_skb(skb,FREE_READ);
1956 return 0;
1957 }
1958 }
1959
1960 return ipxitf_rcv(intrfc, skb);
1961 }
1962
1963 static int ipx_sendmsg(struct socket *sock, struct msghdr *msg, int len, int noblock,
1964 int flags)
1965 {
1966 ipx_socket *sk=(ipx_socket *)sock->data;
1967 struct sockaddr_ipx *usipx=(struct sockaddr_ipx *)msg->msg_name;
1968 struct sockaddr_ipx local_sipx;
1969 int retval;
1970
1971 if (sk->zapped) return -EIO;
1972 if(flags) return -EINVAL;
1973
1974 if(usipx)
1975 {
1976 if(sk->ipx_port == 0)
1977 {
1978 struct sockaddr_ipx uaddr;
1979 int ret;
1980
1981 uaddr.sipx_port = 0;
1982 uaddr.sipx_network = 0L;
1983 #ifdef CONFIG_IPX_INTERN
1984 memcpy(uaddr.sipx_node, sk->ipx_intrfc->if_node,
1985 IPX_NODE_LEN);
1986 #endif
1987 ret = ipx_bind (sock, (struct sockaddr *)&uaddr,
1988 sizeof(struct sockaddr_ipx));
1989 if (ret != 0) return ret;
1990 }
1991
1992 if(msg->msg_namelen <sizeof(*usipx))
1993 return -EINVAL;
1994 if(usipx->sipx_family != AF_IPX)
1995 return -EINVAL;
1996 }
1997 else
1998 {
1999 if(sk->state!=TCP_ESTABLISHED)
2000 return -ENOTCONN;
2001 usipx=&local_sipx;
2002 usipx->sipx_family=AF_IPX;
2003 usipx->sipx_type=sk->ipx_type;
2004 usipx->sipx_port=sk->ipx_dest_addr.sock;
2005 usipx->sipx_network=sk->ipx_dest_addr.net;
2006 memcpy(usipx->sipx_node,sk->ipx_dest_addr.node,IPX_NODE_LEN);
2007 }
2008
2009 retval = ipxrtr_route_packet(sk, usipx, msg->msg_iov, len);
2010 if (retval < 0) return retval;
2011
2012 return len;
2013 }
2014
2015
2016 static int ipx_recvmsg(struct socket *sock, struct msghdr *msg, int size, int noblock,
2017 int flags, int *addr_len)
2018 {
2019 ipx_socket *sk=(ipx_socket *)sock->data;
2020 struct sockaddr_ipx *sipx=(struct sockaddr_ipx *)msg->msg_name;
2021 struct ipx_packet *ipx = NULL;
2022 int copied = 0;
2023 int truesize;
2024 struct sk_buff *skb;
2025 int er;
2026
2027 if(sk->err)
2028 return sock_error(sk);
2029
2030 if (sk->zapped)
2031 return -EIO;
2032
2033
2034 skb=skb_recv_datagram(sk,flags,noblock,&er);
2035 if(skb==NULL)
2036 return er;
2037
2038 if(addr_len)
2039 *addr_len=sizeof(*sipx);
2040
2041 ipx = (ipx_packet *)(skb->h.raw);
2042 truesize=ntohs(ipx->ipx_pktsize) - sizeof(ipx_packet);
2043 copied = (truesize > size) ? size : truesize;
2044 skb_copy_datagram_iovec(skb,sizeof(struct ipx_packet),msg->msg_iov,copied);
2045
2046 if(sipx)
2047 {
2048 sipx->sipx_family=AF_IPX;
2049 sipx->sipx_port=ipx->ipx_source.sock;
2050 memcpy(sipx->sipx_node,ipx->ipx_source.node,IPX_NODE_LEN);
2051 sipx->sipx_network=ipx->ipx_source.net;
2052 sipx->sipx_type = ipx->ipx_type;
2053 }
2054 skb_free_datagram(sk, skb);
2055 return(truesize);
2056 }
2057
2058 static int ipx_shutdown(struct socket *sk,int how)
2059 {
2060 return -EOPNOTSUPP;
2061 }
2062
2063 static int ipx_select(struct socket *sock , int sel_type, select_table *wait)
2064 {
2065 ipx_socket *sk=(ipx_socket *)sock->data;
2066
2067 return datagram_select(sk,sel_type,wait);
2068 }
2069
2070 static int ipx_ioctl(struct socket *sock,unsigned int cmd, unsigned long arg)
2071 {
2072 int err;
2073 long amount=0;
2074 ipx_socket *sk=(ipx_socket *)sock->data;
2075
2076 switch(cmd)
2077 {
2078 case TIOCOUTQ:
2079 err=verify_area(VERIFY_WRITE,(void *)arg,sizeof(unsigned long));
2080 if(err)
2081 return err;
2082 amount=sk->sndbuf-sk->wmem_alloc;
2083 if(amount<0)
2084 amount=0;
2085 put_fs_long(amount,(unsigned long *)arg);
2086 return 0;
2087 case TIOCINQ:
2088 {
2089 struct sk_buff *skb;
2090
2091 if((skb=skb_peek(&sk->receive_queue))!=NULL)
2092 amount=skb->len-sizeof(struct ipx_packet);
2093 err=verify_area(VERIFY_WRITE,(void *)arg,sizeof(unsigned long));
2094 if(err)
2095 return err;
2096 put_fs_long(amount,(unsigned long *)arg);
2097 return 0;
2098 }
2099 case SIOCADDRT:
2100 case SIOCDELRT:
2101 if(!suser())
2102 return -EPERM;
2103 return(ipxrtr_ioctl(cmd,(void *)arg));
2104 case SIOCSIFADDR:
2105 case SIOCGIFADDR:
2106 case SIOCAIPXITFCRT:
2107 case SIOCAIPXPRISLT:
2108 if(!suser())
2109 return -EPERM;
2110 return(ipxitf_ioctl(cmd,(void *)arg));
2111 case SIOCIPXCFGDATA:
2112 {
2113 err=verify_area(VERIFY_WRITE,(void *)arg,
2114 sizeof(ipx_config_data));
2115 if(err) return err;
2116 return(ipxcfg_get_config_data((void *)arg));
2117 }
2118 case SIOCGSTAMP:
2119 if (sk)
2120 {
2121 if(sk->stamp.tv_sec==0)
2122 return -ENOENT;
2123 err=verify_area(VERIFY_WRITE,(void *)arg,sizeof(struct timeval));
2124 if(err)
2125 return err;
2126 memcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval));
2127 return 0;
2128 }
2129 return -EINVAL;
2130 case SIOCGIFDSTADDR:
2131 case SIOCSIFDSTADDR:
2132 case SIOCGIFBRDADDR:
2133 case SIOCSIFBRDADDR:
2134 case SIOCGIFNETMASK:
2135 case SIOCSIFNETMASK:
2136 return -EINVAL;
2137 default:
2138 return(dev_ioctl(cmd,(void *) arg));
2139 }
2140
2141 return(0);
2142 }
2143
2144 static struct proto_ops ipx_proto_ops = {
2145 AF_IPX,
2146
2147 ipx_create,
2148 ipx_dup,
2149 ipx_release,
2150 ipx_bind,
2151 ipx_connect,
2152 ipx_socketpair,
2153 ipx_accept,
2154 ipx_getname,
2155 ipx_select,
2156 ipx_ioctl,
2157 ipx_listen,
2158 ipx_shutdown,
2159 ipx_setsockopt,
2160 ipx_getsockopt,
2161 ipx_fcntl,
2162 ipx_sendmsg,
2163 ipx_recvmsg
2164 };
2165
2166
2167
2168 static struct packet_type ipx_8023_packet_type =
2169
2170 {
2171 0,
2172 NULL,
2173 ipx_rcv,
2174 NULL,
2175 NULL,
2176 };
2177
2178 static struct packet_type ipx_dix_packet_type =
2179 {
2180 0,
2181 NULL,
2182 ipx_rcv,
2183 NULL,
2184 NULL,
2185 };
2186
2187 static struct notifier_block ipx_dev_notifier={
2188 ipxitf_device_event,
2189 NULL,
2190 0
2191 };
2192
2193
2194 extern struct datalink_proto *make_EII_client(void);
2195 extern struct datalink_proto *make_8023_client(void);
2196
2197 void ipx_proto_init(struct net_proto *pro)
2198 {
2199 unsigned char val = 0xE0;
2200 unsigned char snapval[5] = { 0x0, 0x0, 0x0, 0x81, 0x37 };
2201
2202 (void) sock_register(ipx_proto_ops.family, &ipx_proto_ops);
2203
2204 pEII_datalink = make_EII_client();
2205 ipx_dix_packet_type.type=htons(ETH_P_IPX);
2206 dev_add_pack(&ipx_dix_packet_type);
2207
2208 p8023_datalink = make_8023_client();
2209 ipx_8023_packet_type.type=htons(ETH_P_802_3);
2210 dev_add_pack(&ipx_8023_packet_type);
2211
2212 if ((p8022_datalink = register_8022_client(val, ipx_rcv)) == NULL)
2213 printk("IPX: Unable to register with 802.2\n");
2214
2215 if ((pSNAP_datalink = register_snap_client(snapval, ipx_rcv)) == NULL)
2216 printk("IPX: Unable to register with SNAP\n");
2217
2218 register_netdevice_notifier(&ipx_dev_notifier);
2219
2220 proc_net_register(&(struct proc_dir_entry) {
2221 PROC_NET_IPX, 3, "ipx",
2222 S_IFREG | S_IRUGO, 1, 0, 0,
2223 0, &proc_net_inode_operations,
2224 ipx_get_info
2225 });
2226 proc_net_register(&(struct proc_dir_entry) {
2227 PROC_NET_IPX_INTERFACE, 13, "ipx_interface",
2228 S_IFREG | S_IRUGO, 1, 0, 0,
2229 0, &proc_net_inode_operations,
2230 ipx_interface_get_info
2231 });
2232 proc_net_register(&(struct proc_dir_entry) {
2233 PROC_NET_IPX_ROUTE, 9, "ipx_route",
2234 S_IFREG | S_IRUGO, 1, 0, 0,
2235 0, &proc_net_inode_operations,
2236 ipx_rt_get_info
2237 });
2238
2239 printk("Swansea University Computer Society IPX 0.33 for NET3.032\n");
2240 printk("IPX Portions Copyright (c) 1995 Caldera, Inc.\n");
2241 }
2242 #endif