aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorGreg Kroah-Hartman <gregkh@linuxfoundation.org>2018-06-01 14:39:54 -0400
committerGreg Kroah-Hartman <gregkh@linuxfoundation.org>2018-06-05 13:23:26 -0400
commit7a2e838d28cff6718a0bdf66164465402f8e40ed (patch)
treefb331c93eaa6d9104669cd276ae41e1916dbc15a
parent05e98465e08a58d7f8f577281f0c98c71c624c4b (diff)
staging: ipx: delete it from the tree
The ipx code moved into the staging tree back in November 2017 and no one has complained or even noticed it was gone. Because of that, let's just delete it. Note, the ipx header files are not removed here, that will come later through the networking tree, as that takes a bit more work to unwind. Cc: Stephen Hemminger <stephen@networkplumber.org> Cc: David S. Miller <davem@davemloft.net> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Diffstat
-rw-r--r--drivers/staging/Kconfig2
-rw-r--r--drivers/staging/Makefile1
-rw-r--r--drivers/staging/ipx/Kconfig61
-rw-r--r--drivers/staging/ipx/Makefile8
-rw-r--r--drivers/staging/ipx/TODO4
-rw-r--r--drivers/staging/ipx/af_ipx.c2082
-rw-r--r--drivers/staging/ipx/ipx_proc.c338
-rw-r--r--drivers/staging/ipx/ipx_route.c293
-rw-r--r--drivers/staging/ipx/pe2.c36
-rw-r--r--drivers/staging/ipx/sysctl_net_ipx.c40
10 files changed, 0 insertions, 2865 deletions
diff --git a/drivers/staging/Kconfig b/drivers/staging/Kconfig
index 0d8c7b546cf8..75a480497d22 100644
--- a/drivers/staging/Kconfig
+++ b/drivers/staging/Kconfig
@@ -24,8 +24,6 @@ menuconfig STAGING
24 24
25if STAGING 25if STAGING
26 26
27source "drivers/staging/ipx/Kconfig"
28
29source "drivers/staging/wlan-ng/Kconfig" 27source "drivers/staging/wlan-ng/Kconfig"
30 28
31source "drivers/staging/comedi/Kconfig" 29source "drivers/staging/comedi/Kconfig"
diff --git a/drivers/staging/Makefile b/drivers/staging/Makefile
index 64e7010a2ecd..e84959a8a684 100644
--- a/drivers/staging/Makefile
+++ b/drivers/staging/Makefile
@@ -3,7 +3,6 @@
3 3
4obj-y += media/ 4obj-y += media/
5obj-y += typec/ 5obj-y += typec/
6obj-$(CONFIG_IPX) += ipx/
7obj-$(CONFIG_PRISM2_USB) += wlan-ng/ 6obj-$(CONFIG_PRISM2_USB) += wlan-ng/
8obj-$(CONFIG_COMEDI) += comedi/ 7obj-$(CONFIG_COMEDI) += comedi/
9obj-$(CONFIG_FB_OLPC_DCON) += olpc_dcon/ 8obj-$(CONFIG_FB_OLPC_DCON) += olpc_dcon/
diff --git a/drivers/staging/ipx/Kconfig b/drivers/staging/ipx/Kconfig
deleted file mode 100644
index cdff083d0ee6..000000000000
--- a/drivers/staging/ipx/Kconfig
+++ /dev/null
@@ -1,61 +0,0 @@
1#
2# IPX configuration
3#
4config IPX
5 tristate "The IPX protocol"
6 depends on NET
7 select LLC
8 ---help---
9 This is support for the Novell networking protocol, IPX, commonly
10 used for local networks of Windows machines. You need it if you
11 want to access Novell NetWare file or print servers using the Linux
12 Novell client ncpfs (available from
13 <ftp://platan.vc.cvut.cz/pub/linux/ncpfs/>) or from
14 within the Linux DOS emulator DOSEMU (read the DOSEMU-HOWTO,
15 available from <http://www.tldp.org/docs.html#howto>). In order
16 to do the former, you'll also have to say Y to "NCP file system
17 support", below.
18
19 IPX is similar in scope to IP, while SPX, which runs on top of IPX,
20 is similar to TCP.
21
22 To turn your Linux box into a fully featured NetWare file server and
23 IPX router, say Y here and fetch either lwared from
24 <ftp://ibiblio.org/pub/Linux/system/network/daemons/> or
25 mars_nwe from <ftp://www.compu-art.de/mars_nwe/>. For more
26 information, read the IPX-HOWTO available from
27 <http://www.tldp.org/docs.html#howto>.
28
29 The IPX driver would enlarge your kernel by about 16 KB. To compile
30 this driver as a module, choose M here: the module will be called ipx.
31 Unless you want to integrate your Linux box with a local Novell
32 network, say N.
33
34config IPX_INTERN
35 bool "IPX: Full internal IPX network"
36 depends on IPX
37 ---help---
38 Every IPX network has an address that identifies it. Sometimes it is
39 useful to give an IPX "network" address to your Linux box as well
40 (for example if your box is acting as a file server for different
41 IPX networks: it will then be accessible from everywhere using the
42 same address). The way this is done is to create a virtual internal
43 "network" inside your box and to assign an IPX address to this
44 network. Say Y here if you want to do this; read the IPX-HOWTO at
45 <http://www.tldp.org/docs.html#howto> for details.
46
47 The full internal IPX network enables you to allocate sockets on
48 different virtual nodes of the internal network. This is done by
49 evaluating the field sipx_node of the socket address given to the
50 bind call. So applications should always initialize the node field
51 to 0 when binding a socket on the primary network. In this case the
52 socket is assigned the default node that has been given to the
53 kernel when the internal network was created. By enabling the full
54 internal IPX network the cross-forwarding of packets targeted at
55 'special' sockets to sockets listening on the primary network is
56 disabled. This might break existing applications, especially RIP/SAP
57 daemons. A RIP/SAP daemon that works well with the full internal net
58 can be found on <ftp://ftp.gwdg.de/pub/linux/misc/ncpfs/>.
59
60 If you don't know what you are doing, say N.
61
diff --git a/drivers/staging/ipx/Makefile b/drivers/staging/ipx/Makefile
deleted file mode 100644
index 440fafa9fd07..000000000000
--- a/drivers/staging/ipx/Makefile
+++ /dev/null
@@ -1,8 +0,0 @@
1#
2# Makefile for the Linux IPX layer.
3#
4
5obj-$(CONFIG_IPX) += ipx.o
6
7ipx-y := af_ipx.o ipx_route.o ipx_proc.o pe2.o
8ipx-$(CONFIG_SYSCTL) += sysctl_net_ipx.o
diff --git a/drivers/staging/ipx/TODO b/drivers/staging/ipx/TODO
deleted file mode 100644
index 80db5d968264..000000000000
--- a/drivers/staging/ipx/TODO
+++ /dev/null
@@ -1,4 +0,0 @@
1The ipx code will be removed soon from the kernel tree as it is old and
2obsolete and broken.
3
4Don't worry about fixing up anything here, it's not needed.
diff --git a/drivers/staging/ipx/af_ipx.c b/drivers/staging/ipx/af_ipx.c
deleted file mode 100644
index 5703dd176787..000000000000
--- a/drivers/staging/ipx/af_ipx.c
+++ /dev/null
@@ -1,2082 +0,0 @@
1/*
2 * Implements an IPX socket layer.
3 *
4 * This code is derived from work by
5 * Ross Biro : Writing the original IP stack
6 * Fred Van Kempen : Tidying up the TCP/IP
7 *
8 * Many thanks go to Keith Baker, Institute For Industrial Information
9 * Technology Ltd, Swansea University for allowing me to work on this
10 * in my own time even though it was in some ways related to commercial
11 * work I am currently employed to do there.
12 *
13 * All the material in this file is subject to the Gnu license version 2.
14 * Neither Alan Cox nor the Swansea University Computer Society admit
15 * liability nor provide warranty for any of this software. This material
16 * is provided as is and at no charge.
17 *
18 * Portions Copyright (c) 2000-2003 Conectiva, Inc. <acme@conectiva.com.br>
19 * Neither Arnaldo Carvalho de Melo nor Conectiva, Inc. admit liability nor
20 * provide warranty for any of this software. This material is provided
21 * "AS-IS" and at no charge.
22 *
23 * Portions Copyright (c) 1995 Caldera, Inc. <greg@caldera.com>
24 * Neither Greg Page nor Caldera, Inc. admit liability nor provide
25 * warranty for any of this software. This material is provided
26 * "AS-IS" and at no charge.
27 *
28 * See net/ipx/ChangeLog.
29 */
30
31#include <linux/capability.h>
32#include <linux/errno.h>
33#include <linux/if_arp.h>
34#include <linux/if_ether.h>
35#include <linux/init.h>
36#include <linux/ipx.h>
37#include <linux/kernel.h>
38#include <linux/list.h>
39#include <linux/module.h>
40#include <linux/net.h>
41#include <linux/netdevice.h>
42#include <linux/uio.h>
43#include <linux/slab.h>
44#include <linux/skbuff.h>
45#include <linux/socket.h>
46#include <linux/sockios.h>
47#include <linux/string.h>
48#include <linux/types.h>
49#include <linux/termios.h>
50
51#include <net/ipx.h>
52#include <net/p8022.h>
53#include <net/psnap.h>
54#include <net/sock.h>
55#include <net/datalink.h>
56#include <net/tcp_states.h>
57#include <net/net_namespace.h>
58
59#include <linux/uaccess.h>
60
61/* Configuration Variables */
62static unsigned char ipxcfg_max_hops = 16;
63static char ipxcfg_auto_select_primary;
64static char ipxcfg_auto_create_interfaces;
65int sysctl_ipx_pprop_broadcasting = 1;
66
67/* Global Variables */
68static struct datalink_proto *p8022_datalink;
69static struct datalink_proto *pEII_datalink;
70static struct datalink_proto *p8023_datalink;
71static struct datalink_proto *pSNAP_datalink;
72
73static const struct proto_ops ipx_dgram_ops;
74
75LIST_HEAD(ipx_interfaces);
76DEFINE_SPINLOCK(ipx_interfaces_lock);
77
78struct ipx_interface *ipx_primary_net;
79struct ipx_interface *ipx_internal_net;
80
81struct ipx_interface *ipx_interfaces_head(void)
82{
83 struct ipx_interface *rc = NULL;
84
85 if (!list_empty(&ipx_interfaces))
86 rc = list_entry(ipx_interfaces.next,
87 struct ipx_interface, node);
88 return rc;
89}
90
91static void ipxcfg_set_auto_select(char val)
92{
93 ipxcfg_auto_select_primary = val;
94 if (val && !ipx_primary_net)
95 ipx_primary_net = ipx_interfaces_head();
96}
97
98static int ipxcfg_get_config_data(struct ipx_config_data __user *arg)
99{
100 struct ipx_config_data vals;
101
102 vals.ipxcfg_auto_create_interfaces = ipxcfg_auto_create_interfaces;
103 vals.ipxcfg_auto_select_primary = ipxcfg_auto_select_primary;
104
105 return copy_to_user(arg, &vals, sizeof(vals)) ? -EFAULT : 0;
106}
107
108/*
109 * Note: Sockets may not be removed _during_ an interrupt or inet_bh
110 * handler using this technique. They can be added although we do not
111 * use this facility.
112 */
113
114static void ipx_remove_socket(struct sock *sk)
115{
116 /* Determine interface with which socket is associated */
117 struct ipx_interface *intrfc = ipx_sk(sk)->intrfc;
118
119 if (!intrfc)
120 goto out;
121
122 ipxitf_hold(intrfc);
123 spin_lock_bh(&intrfc->if_sklist_lock);
124 sk_del_node_init(sk);
125 spin_unlock_bh(&intrfc->if_sklist_lock);
126 ipxitf_put(intrfc);
127out:
128 return;
129}
130
131static void ipx_destroy_socket(struct sock *sk)
132{
133 ipx_remove_socket(sk);
134 skb_queue_purge(&sk->sk_receive_queue);
135 sk_refcnt_debug_dec(sk);
136}
137
138/*
139 * The following code is used to support IPX Interfaces (IPXITF). An
140 * IPX interface is defined by a physical device and a frame type.
141 */
142
143/* ipxitf_clear_primary_net has to be called with ipx_interfaces_lock held */
144
145static void ipxitf_clear_primary_net(void)
146{
147 ipx_primary_net = NULL;
148 if (ipxcfg_auto_select_primary)
149 ipx_primary_net = ipx_interfaces_head();
150}
151
152static struct ipx_interface *__ipxitf_find_using_phys(struct net_device *dev,
153 __be16 datalink)
154{
155 struct ipx_interface *i;
156
157 list_for_each_entry(i, &ipx_interfaces, node)
158 if (i->if_dev == dev && i->if_dlink_type == datalink)
159 goto out;
160 i = NULL;
161out:
162 return i;
163}
164
165static struct ipx_interface *ipxitf_find_using_phys(struct net_device *dev,
166 __be16 datalink)
167{
168 struct ipx_interface *i;
169
170 spin_lock_bh(&ipx_interfaces_lock);
171 i = __ipxitf_find_using_phys(dev, datalink);
172 if (i)
173 ipxitf_hold(i);
174 spin_unlock_bh(&ipx_interfaces_lock);
175 return i;
176}
177
178struct ipx_interface *ipxitf_find_using_net(__be32 net)
179{
180 struct ipx_interface *i;
181
182 spin_lock_bh(&ipx_interfaces_lock);
183 if (net) {
184 list_for_each_entry(i, &ipx_interfaces, node)
185 if (i->if_netnum == net)
186 goto hold;
187 i = NULL;
188 goto unlock;
189 }
190
191 i = ipx_primary_net;
192 if (i)
193hold:
194 ipxitf_hold(i);
195unlock:
196 spin_unlock_bh(&ipx_interfaces_lock);
197 return i;
198}
199
200/* Sockets are bound to a particular IPX interface. */
201static void ipxitf_insert_socket(struct ipx_interface *intrfc, struct sock *sk)
202{
203 ipxitf_hold(intrfc);
204 spin_lock_bh(&intrfc->if_sklist_lock);
205 ipx_sk(sk)->intrfc = intrfc;
206 sk_add_node(sk, &intrfc->if_sklist);
207 spin_unlock_bh(&intrfc->if_sklist_lock);
208 ipxitf_put(intrfc);
209}
210
211/* caller must hold intrfc->if_sklist_lock */
212static struct sock *__ipxitf_find_socket(struct ipx_interface *intrfc,
213 __be16 port)
214{
215 struct sock *s;
216
217 sk_for_each(s, &intrfc->if_sklist)
218 if (ipx_sk(s)->port == port)
219 goto found;
220 s = NULL;
221found:
222 return s;
223}
224
225/* caller must hold a reference to intrfc */
226static struct sock *ipxitf_find_socket(struct ipx_interface *intrfc,
227 __be16 port)
228{
229 struct sock *s;
230
231 spin_lock_bh(&intrfc->if_sklist_lock);
232 s = __ipxitf_find_socket(intrfc, port);
233 if (s)
234 sock_hold(s);
235 spin_unlock_bh(&intrfc->if_sklist_lock);
236
237 return s;
238}
239
240#ifdef CONFIG_IPX_INTERN
241static struct sock *ipxitf_find_internal_socket(struct ipx_interface *intrfc,
242 unsigned char *ipx_node,
243 __be16 port)
244{
245 struct sock *s;
246
247 ipxitf_hold(intrfc);
248 spin_lock_bh(&intrfc->if_sklist_lock);
249
250 sk_for_each(s, &intrfc->if_sklist) {
251 struct ipx_sock *ipxs = ipx_sk(s);
252
253 if (ipxs->port == port &&
254 !memcmp(ipx_node, ipxs->node, IPX_NODE_LEN))
255 goto found;
256 }
257 s = NULL;
258found:
259 spin_unlock_bh(&intrfc->if_sklist_lock);
260 ipxitf_put(intrfc);
261 return s;
262}
263#endif
264
265static void __ipxitf_down(struct ipx_interface *intrfc)
266{
267 struct sock *s;
268 struct hlist_node *t;
269
270 /* Delete all routes associated with this interface */
271 ipxrtr_del_routes(intrfc);
272
273 spin_lock_bh(&intrfc->if_sklist_lock);
274 /* error sockets */
275 sk_for_each_safe(s, t, &intrfc->if_sklist) {
276 struct ipx_sock *ipxs = ipx_sk(s);
277
278 s->sk_err = ENOLINK;
279 s->sk_error_report(s);
280 ipxs->intrfc = NULL;
281 ipxs->port = 0;
282 sock_set_flag(s, SOCK_ZAPPED); /* Indicates it is no longer bound */
283 sk_del_node_init(s);
284 }
285 INIT_HLIST_HEAD(&intrfc->if_sklist);
286 spin_unlock_bh(&intrfc->if_sklist_lock);
287
288 /* remove this interface from list */
289 list_del(&intrfc->node);
290
291 /* remove this interface from *special* networks */
292 if (intrfc == ipx_primary_net)
293 ipxitf_clear_primary_net();
294 if (intrfc == ipx_internal_net)
295 ipx_internal_net = NULL;
296
297 if (intrfc->if_dev)
298 dev_put(intrfc->if_dev);
299 kfree(intrfc);
300}
301
302void ipxitf_down(struct ipx_interface *intrfc)
303{
304 spin_lock_bh(&ipx_interfaces_lock);
305 __ipxitf_down(intrfc);
306 spin_unlock_bh(&ipx_interfaces_lock);
307}
308
309static void __ipxitf_put(struct ipx_interface *intrfc)
310{
311 if (refcount_dec_and_test(&intrfc->refcnt))
312 __ipxitf_down(intrfc);
313}
314
315static int ipxitf_device_event(struct notifier_block *notifier,
316 unsigned long event, void *ptr)
317{
318 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
319 struct ipx_interface *i, *tmp;
320
321 if (!net_eq(dev_net(dev), &init_net))
322 return NOTIFY_DONE;
323
324 if (event != NETDEV_DOWN && event != NETDEV_UP)
325 goto out;
326
327 spin_lock_bh(&ipx_interfaces_lock);
328 list_for_each_entry_safe(i, tmp, &ipx_interfaces, node)
329 if (i->if_dev == dev) {
330 if (event == NETDEV_UP)
331 ipxitf_hold(i);
332 else
333 __ipxitf_put(i);
334 }
335 spin_unlock_bh(&ipx_interfaces_lock);
336out:
337 return NOTIFY_DONE;
338}
339
340
341static __exit void ipxitf_cleanup(void)
342{
343 struct ipx_interface *i, *tmp;
344
345 spin_lock_bh(&ipx_interfaces_lock);
346 list_for_each_entry_safe(i, tmp, &ipx_interfaces, node)
347 __ipxitf_put(i);
348 spin_unlock_bh(&ipx_interfaces_lock);
349}
350
351static void ipxitf_def_skb_handler(struct sock *sock, struct sk_buff *skb)
352{
353 if (sock_queue_rcv_skb(sock, skb) < 0)
354 kfree_skb(skb);
355}
356
357/*
358 * On input skb->sk is NULL. Nobody is charged for the memory.
359 */
360
361/* caller must hold a reference to intrfc */
362
363#ifdef CONFIG_IPX_INTERN
364static int ipxitf_demux_socket(struct ipx_interface *intrfc,
365 struct sk_buff *skb, int copy)
366{
367 struct ipxhdr *ipx = ipx_hdr(skb);
368 int is_broadcast = !memcmp(ipx->ipx_dest.node, ipx_broadcast_node,
369 IPX_NODE_LEN);
370 struct sock *s;
371 int rc;
372
373 spin_lock_bh(&intrfc->if_sklist_lock);
374
375 sk_for_each(s, &intrfc->if_sklist) {
376 struct ipx_sock *ipxs = ipx_sk(s);
377
378 if (ipxs->port == ipx->ipx_dest.sock &&
379 (is_broadcast || !memcmp(ipx->ipx_dest.node,
380 ipxs->node, IPX_NODE_LEN))) {
381 /* We found a socket to which to send */
382 struct sk_buff *skb1;
383
384 if (copy) {
385 skb1 = skb_clone(skb, GFP_ATOMIC);
386 rc = -ENOMEM;
387 if (!skb1)
388 goto out;
389 } else {
390 skb1 = skb;
391 copy = 1; /* skb may only be used once */
392 }
393 ipxitf_def_skb_handler(s, skb1);
394
395 /* On an external interface, one socket can listen */
396 if (intrfc != ipx_internal_net)
397 break;
398 }
399 }
400
401 /* skb was solely for us, and we did not make a copy, so free it. */
402 if (!copy)
403 kfree_skb(skb);
404
405 rc = 0;
406out:
407 spin_unlock_bh(&intrfc->if_sklist_lock);
408 return rc;
409}
410#else
411static struct sock *ncp_connection_hack(struct ipx_interface *intrfc,
412 struct ipxhdr *ipx)
413{
414 /* The packet's target is a NCP connection handler. We want to hand it
415 * to the correct socket directly within the kernel, so that the
416 * mars_nwe packet distribution process does not have to do it. Here we
417 * only care about NCP and BURST packets.
418 *
419 * You might call this a hack, but believe me, you do not want a
420 * complete NCP layer in the kernel, and this is VERY fast as well. */
421 struct sock *sk = NULL;
422 int connection = 0;
423 u8 *ncphdr = (u8 *)(ipx + 1);
424
425 if (*ncphdr == 0x22 && *(ncphdr + 1) == 0x22) /* NCP request */
426 connection = (((int) *(ncphdr + 5)) << 8) | (int) *(ncphdr + 3);
427 else if (*ncphdr == 0x77 && *(ncphdr + 1) == 0x77) /* BURST packet */
428 connection = (((int) *(ncphdr + 9)) << 8) | (int) *(ncphdr + 8);
429
430 if (connection) {
431 /* Now we have to look for a special NCP connection handling
432 * socket. Only these sockets have ipx_ncp_conn != 0, set by
433 * SIOCIPXNCPCONN. */
434 spin_lock_bh(&intrfc->if_sklist_lock);
435 sk_for_each(sk, &intrfc->if_sklist)
436 if (ipx_sk(sk)->ipx_ncp_conn == connection) {
437 sock_hold(sk);
438 goto found;
439 }
440 sk = NULL;
441 found:
442 spin_unlock_bh(&intrfc->if_sklist_lock);
443 }
444 return sk;
445}
446
447static int ipxitf_demux_socket(struct ipx_interface *intrfc,
448 struct sk_buff *skb, int copy)
449{
450 struct ipxhdr *ipx = ipx_hdr(skb);
451 struct sock *sock1 = NULL, *sock2 = NULL;
452 struct sk_buff *skb1 = NULL, *skb2 = NULL;
453 int rc;
454
455 if (intrfc == ipx_primary_net && ntohs(ipx->ipx_dest.sock) == 0x451)
456 sock1 = ncp_connection_hack(intrfc, ipx);
457 if (!sock1)
458 /* No special socket found, forward the packet the normal way */
459 sock1 = ipxitf_find_socket(intrfc, ipx->ipx_dest.sock);
460
461 /*
462 * We need to check if there is a primary net and if
463 * this is addressed to one of the *SPECIAL* sockets because
464 * these need to be propagated to the primary net.
465 * The *SPECIAL* socket list contains: 0x452(SAP), 0x453(RIP) and
466 * 0x456(Diagnostic).
467 */
468
469 if (ipx_primary_net && intrfc != ipx_primary_net) {
470 const int dsock = ntohs(ipx->ipx_dest.sock);
471
472 if (dsock == 0x452 || dsock == 0x453 || dsock == 0x456)
473 /* The appropriate thing to do here is to dup the
474 * packet and route to the primary net interface via
475 * ipxitf_send; however, we'll cheat and just demux it
476 * here. */
477 sock2 = ipxitf_find_socket(ipx_primary_net,
478 ipx->ipx_dest.sock);
479 }
480
481 /*
482 * If there is nothing to do return. The kfree will cancel any charging.
483 */
484 rc = 0;
485 if (!sock1 && !sock2) {
486 if (!copy)
487 kfree_skb(skb);
488 goto out;
489 }
490
491 /*
492 * This next segment of code is a little awkward, but it sets it up
493 * so that the appropriate number of copies of the SKB are made and
494 * that skb1 and skb2 point to it (them) so that it (they) can be
495 * demuxed to sock1 and/or sock2. If we are unable to make enough
496 * copies, we do as much as is possible.
497 */
498
499 if (copy)
500 skb1 = skb_clone(skb, GFP_ATOMIC);
501 else
502 skb1 = skb;
503
504 rc = -ENOMEM;
505 if (!skb1)
506 goto out_put;
507
508 /* Do we need 2 SKBs? */
509 if (sock1 && sock2)
510 skb2 = skb_clone(skb1, GFP_ATOMIC);
511 else
512 skb2 = skb1;
513
514 if (sock1)
515 ipxitf_def_skb_handler(sock1, skb1);
516
517 if (!skb2)
518 goto out_put;
519
520 if (sock2)
521 ipxitf_def_skb_handler(sock2, skb2);
522
523 rc = 0;
524out_put:
525 if (sock1)
526 sock_put(sock1);
527 if (sock2)
528 sock_put(sock2);
529out:
530 return rc;
531}
532#endif /* CONFIG_IPX_INTERN */
533
534static struct sk_buff *ipxitf_adjust_skbuff(struct ipx_interface *intrfc,
535 struct sk_buff *skb)
536{
537 struct sk_buff *skb2;
538 int in_offset = (unsigned char *)ipx_hdr(skb) - skb->head;
539 int out_offset = intrfc->if_ipx_offset;
540 int len;
541
542 /* Hopefully, most cases */
543 if (in_offset >= out_offset)
544 return skb;
545
546 /* Need new SKB */
547 len = skb->len + out_offset;
548 skb2 = alloc_skb(len, GFP_ATOMIC);
549 if (skb2) {
550 skb_reserve(skb2, out_offset);
551 skb_reset_network_header(skb2);
552 skb_reset_transport_header(skb2);
553 skb_put(skb2, skb->len);
554 memcpy(ipx_hdr(skb2), ipx_hdr(skb), skb->len);
555 memcpy(skb2->cb, skb->cb, sizeof(skb->cb));
556 }
557 kfree_skb(skb);
558 return skb2;
559}
560
561/* caller must hold a reference to intrfc and the skb has to be unshared */
562int ipxitf_send(struct ipx_interface *intrfc, struct sk_buff *skb, char *node)
563{
564 struct ipxhdr *ipx = ipx_hdr(skb);
565 struct net_device *dev = intrfc->if_dev;
566 struct datalink_proto *dl = intrfc->if_dlink;
567 char dest_node[IPX_NODE_LEN];
568 int send_to_wire = 1;
569 int addr_len;
570
571 ipx->ipx_tctrl = IPX_SKB_CB(skb)->ipx_tctrl;
572 ipx->ipx_dest.net = IPX_SKB_CB(skb)->ipx_dest_net;
573 ipx->ipx_source.net = IPX_SKB_CB(skb)->ipx_source_net;
574
575 /* see if we need to include the netnum in the route list */
576 if (IPX_SKB_CB(skb)->last_hop.index >= 0) {
577 __be32 *last_hop = (__be32 *)(((u8 *) skb->data) +
578 sizeof(struct ipxhdr) +
579 IPX_SKB_CB(skb)->last_hop.index *
580 sizeof(__be32));
581 *last_hop = IPX_SKB_CB(skb)->last_hop.netnum;
582 IPX_SKB_CB(skb)->last_hop.index = -1;
583 }
584
585 /*
586 * We need to know how many skbuffs it will take to send out this
587 * packet to avoid unnecessary copies.
588 */
589
590 if (!dl || !dev || dev->flags & IFF_LOOPBACK)
591 send_to_wire = 0; /* No non looped */
592
593 /*
594 * See if this should be demuxed to sockets on this interface
595 *
596 * We want to ensure the original was eaten or that we only use
597 * up clones.
598 */
599
600 if (ipx->ipx_dest.net == intrfc->if_netnum) {
601 /*
602 * To our own node, loop and free the original.
603 * The internal net will receive on all node address.
604 */
605 if (intrfc == ipx_internal_net ||
606 !memcmp(intrfc->if_node, node, IPX_NODE_LEN)) {
607 /* Don't charge sender */
608 skb_orphan(skb);
609
610 /* Will charge receiver */
611 return ipxitf_demux_socket(intrfc, skb, 0);
612 }
613
614 /* Broadcast, loop and possibly keep to send on. */
615 if (!memcmp(ipx_broadcast_node, node, IPX_NODE_LEN)) {
616 if (!send_to_wire)
617 skb_orphan(skb);
618 ipxitf_demux_socket(intrfc, skb, send_to_wire);
619 if (!send_to_wire)
620 goto out;
621 }
622 }
623
624 /*
625 * If the originating net is not equal to our net; this is routed
626 * We are still charging the sender. Which is right - the driver
627 * free will handle this fairly.
628 */
629 if (ipx->ipx_source.net != intrfc->if_netnum) {
630 /*
631 * Unshare the buffer before modifying the count in
632 * case it's a flood or tcpdump
633 */
634 skb = skb_unshare(skb, GFP_ATOMIC);
635 if (!skb)
636 goto out;
637 if (++ipx->ipx_tctrl > ipxcfg_max_hops)
638 send_to_wire = 0;
639 }
640
641 if (!send_to_wire) {
642 kfree_skb(skb);
643 goto out;
644 }
645
646 /* Determine the appropriate hardware address */
647 addr_len = dev->addr_len;
648 if (!memcmp(ipx_broadcast_node, node, IPX_NODE_LEN))
649 memcpy(dest_node, dev->broadcast, addr_len);
650 else
651 memcpy(dest_node, &(node[IPX_NODE_LEN-addr_len]), addr_len);
652
653 /* Make any compensation for differing physical/data link size */
654 skb = ipxitf_adjust_skbuff(intrfc, skb);
655 if (!skb)
656 goto out;
657
658 /* set up data link and physical headers */
659 skb->dev = dev;
660 skb->protocol = htons(ETH_P_IPX);
661
662 /* Send it out */
663 dl->request(dl, skb, dest_node);
664out:
665 return 0;
666}
667
668static int ipxitf_add_local_route(struct ipx_interface *intrfc)
669{
670 return ipxrtr_add_route(intrfc->if_netnum, intrfc, NULL);
671}
672
673static void ipxitf_discover_netnum(struct ipx_interface *intrfc,
674 struct sk_buff *skb);
675static int ipxitf_pprop(struct ipx_interface *intrfc, struct sk_buff *skb);
676
677static int ipxitf_rcv(struct ipx_interface *intrfc, struct sk_buff *skb)
678{
679 struct ipxhdr *ipx = ipx_hdr(skb);
680 int rc = 0;
681
682 ipxitf_hold(intrfc);
683
684 /* See if we should update our network number */
685 if (!intrfc->if_netnum) /* net number of intrfc not known yet */
686 ipxitf_discover_netnum(intrfc, skb);
687
688 IPX_SKB_CB(skb)->last_hop.index = -1;
689 if (ipx->ipx_type == IPX_TYPE_PPROP) {
690 rc = ipxitf_pprop(intrfc, skb);
691 if (rc)
692 goto out_free_skb;
693 }
694
695 /* local processing follows */
696 if (!IPX_SKB_CB(skb)->ipx_dest_net)
697 IPX_SKB_CB(skb)->ipx_dest_net = intrfc->if_netnum;
698 if (!IPX_SKB_CB(skb)->ipx_source_net)
699 IPX_SKB_CB(skb)->ipx_source_net = intrfc->if_netnum;
700
701 /* it doesn't make sense to route a pprop packet, there's no meaning
702 * in the ipx_dest_net for such packets */
703 if (ipx->ipx_type != IPX_TYPE_PPROP &&
704 intrfc->if_netnum != IPX_SKB_CB(skb)->ipx_dest_net) {
705 /* We only route point-to-point packets. */
706 if (skb->pkt_type == PACKET_HOST) {
707 skb = skb_unshare(skb, GFP_ATOMIC);
708 if (skb)
709 rc = ipxrtr_route_skb(skb);
710 goto out_intrfc;
711 }
712
713 goto out_free_skb;
714 }
715
716 /* see if we should keep it */
717 if (!memcmp(ipx_broadcast_node, ipx->ipx_dest.node, IPX_NODE_LEN) ||
718 !memcmp(intrfc->if_node, ipx->ipx_dest.node, IPX_NODE_LEN)) {
719 rc = ipxitf_demux_socket(intrfc, skb, 0);
720 goto out_intrfc;
721 }
722
723 /* we couldn't pawn it off so unload it */
724out_free_skb:
725 kfree_skb(skb);
726out_intrfc:
727 ipxitf_put(intrfc);
728 return rc;
729}
730
731static void ipxitf_discover_netnum(struct ipx_interface *intrfc,
732 struct sk_buff *skb)
733{
734 const struct ipx_cb *cb = IPX_SKB_CB(skb);
735
736 /* see if this is an intra packet: source_net == dest_net */
737 if (cb->ipx_source_net == cb->ipx_dest_net && cb->ipx_source_net) {
738 struct ipx_interface *i =
739 ipxitf_find_using_net(cb->ipx_source_net);
740 /* NB: NetWare servers lie about their hop count so we
741 * dropped the test based on it. This is the best way
742 * to determine this is a 0 hop count packet. */
743 if (!i) {
744 intrfc->if_netnum = cb->ipx_source_net;
745 ipxitf_add_local_route(intrfc);
746 } else {
747 printk(KERN_WARNING "IPX: Network number collision "
748 "%lx\n %s %s and %s %s\n",
749 (unsigned long) ntohl(cb->ipx_source_net),
750 ipx_device_name(i),
751 ipx_frame_name(i->if_dlink_type),
752 ipx_device_name(intrfc),
753 ipx_frame_name(intrfc->if_dlink_type));
754 ipxitf_put(i);
755 }
756 }
757}
758
759/**
760 * ipxitf_pprop - Process packet propagation IPX packet type 0x14, used for
761 * NetBIOS broadcasts
762 * @intrfc: IPX interface receiving this packet
763 * @skb: Received packet
764 *
765 * Checks if packet is valid: if its more than %IPX_MAX_PPROP_HOPS hops or if it
766 * is smaller than a IPX header + the room for %IPX_MAX_PPROP_HOPS hops we drop
767 * it, not even processing it locally, if it has exact %IPX_MAX_PPROP_HOPS we
768 * don't broadcast it, but process it locally. See chapter 5 of Novell's "IPX
769 * RIP and SAP Router Specification", Part Number 107-000029-001.
770 *
771 * If it is valid, check if we have pprop broadcasting enabled by the user,
772 * if not, just return zero for local processing.
773 *
774 * If it is enabled check the packet and don't broadcast it if we have already
775 * seen this packet.
776 *
777 * Broadcast: send it to the interfaces that aren't on the packet visited nets
778 * array, just after the IPX header.
779 *
780 * Returns -EINVAL for invalid packets, so that the calling function drops
781 * the packet without local processing. 0 if packet is to be locally processed.
782 */
783static int ipxitf_pprop(struct ipx_interface *intrfc, struct sk_buff *skb)
784{
785 struct ipxhdr *ipx = ipx_hdr(skb);
786 int i, rc = -EINVAL;
787 struct ipx_interface *ifcs;
788 char *c;
789 __be32 *l;
790
791 /* Illegal packet - too many hops or too short */
792 /* We decide to throw it away: no broadcasting, no local processing.
793 * NetBIOS unaware implementations route them as normal packets -
794 * tctrl <= 15, any data payload... */
795 if (IPX_SKB_CB(skb)->ipx_tctrl > IPX_MAX_PPROP_HOPS ||
796 ntohs(ipx->ipx_pktsize) < sizeof(struct ipxhdr) +
797 IPX_MAX_PPROP_HOPS * sizeof(u32))
798 goto out;
799 /* are we broadcasting this damn thing? */
800 rc = 0;
801 if (!sysctl_ipx_pprop_broadcasting)
802 goto out;
803 /* We do broadcast packet on the IPX_MAX_PPROP_HOPS hop, but we
804 * process it locally. All previous hops broadcasted it, and process it
805 * locally. */
806 if (IPX_SKB_CB(skb)->ipx_tctrl == IPX_MAX_PPROP_HOPS)
807 goto out;
808
809 c = ((u8 *) ipx) + sizeof(struct ipxhdr);
810 l = (__be32 *) c;
811
812 /* Don't broadcast packet if already seen this net */
813 for (i = 0; i < IPX_SKB_CB(skb)->ipx_tctrl; i++)
814 if (*l++ == intrfc->if_netnum)
815 goto out;
816
817 /* < IPX_MAX_PPROP_HOPS hops && input interface not in list. Save the
818 * position where we will insert recvd netnum into list, later on,
819 * in ipxitf_send */
820 IPX_SKB_CB(skb)->last_hop.index = i;
821 IPX_SKB_CB(skb)->last_hop.netnum = intrfc->if_netnum;
822 /* xmit on all other interfaces... */
823 spin_lock_bh(&ipx_interfaces_lock);
824 list_for_each_entry(ifcs, &ipx_interfaces, node) {
825 /* Except unconfigured interfaces */
826 if (!ifcs->if_netnum)
827 continue;
828
829 /* That aren't in the list */
830 if (ifcs == intrfc)
831 continue;
832 l = (__be32 *) c;
833 /* don't consider the last entry in the packet list,
834 * it is our netnum, and it is not there yet */
835 for (i = 0; i < IPX_SKB_CB(skb)->ipx_tctrl; i++)
836 if (ifcs->if_netnum == *l++)
837 break;
838 if (i == IPX_SKB_CB(skb)->ipx_tctrl) {
839 struct sk_buff *s = skb_copy(skb, GFP_ATOMIC);
840
841 if (s) {
842 IPX_SKB_CB(s)->ipx_dest_net = ifcs->if_netnum;
843 ipxrtr_route_skb(s);
844 }
845 }
846 }
847 spin_unlock_bh(&ipx_interfaces_lock);
848out:
849 return rc;
850}
851
852static void ipxitf_insert(struct ipx_interface *intrfc)
853{
854 spin_lock_bh(&ipx_interfaces_lock);
855 list_add_tail(&intrfc->node, &ipx_interfaces);
856 spin_unlock_bh(&ipx_interfaces_lock);
857
858 if (ipxcfg_auto_select_primary && !ipx_primary_net)
859 ipx_primary_net = intrfc;
860}
861
862static struct ipx_interface *ipxitf_alloc(struct net_device *dev, __be32 netnum,
863 __be16 dlink_type,
864 struct datalink_proto *dlink,
865 unsigned char internal,
866 int ipx_offset)
867{
868 struct ipx_interface *intrfc = kmalloc(sizeof(*intrfc), GFP_ATOMIC);
869
870 if (intrfc) {
871 intrfc->if_dev = dev;
872 intrfc->if_netnum = netnum;
873 intrfc->if_dlink_type = dlink_type;
874 intrfc->if_dlink = dlink;
875 intrfc->if_internal = internal;
876 intrfc->if_ipx_offset = ipx_offset;
877 intrfc->if_sknum = IPX_MIN_EPHEMERAL_SOCKET;
878 INIT_HLIST_HEAD(&intrfc->if_sklist);
879 refcount_set(&intrfc->refcnt, 1);
880 spin_lock_init(&intrfc->if_sklist_lock);
881 }
882
883 return intrfc;
884}
885
886static int ipxitf_create_internal(struct ipx_interface_definition *idef)
887{
888 struct ipx_interface *intrfc;
889 int rc = -EEXIST;
890
891 /* Only one primary network allowed */
892 if (ipx_primary_net)
893 goto out;
894
895 /* Must have a valid network number */
896 rc = -EADDRNOTAVAIL;
897 if (!idef->ipx_network)
898 goto out;
899 intrfc = ipxitf_find_using_net(idef->ipx_network);
900 rc = -EADDRINUSE;
901 if (intrfc) {
902 ipxitf_put(intrfc);
903 goto out;
904 }
905 intrfc = ipxitf_alloc(NULL, idef->ipx_network, 0, NULL, 1, 0);
906 rc = -EAGAIN;
907 if (!intrfc)
908 goto out;
909 memcpy((char *)&(intrfc->if_node), idef->ipx_node, IPX_NODE_LEN);
910 ipx_internal_net = ipx_primary_net = intrfc;
911 ipxitf_hold(intrfc);
912 ipxitf_insert(intrfc);
913
914 rc = ipxitf_add_local_route(intrfc);
915 ipxitf_put(intrfc);
916out:
917 return rc;
918}
919
920static __be16 ipx_map_frame_type(unsigned char type)
921{
922 __be16 rc = 0;
923
924 switch (type) {
925 case IPX_FRAME_ETHERII: rc = htons(ETH_P_IPX); break;
926 case IPX_FRAME_8022: rc = htons(ETH_P_802_2); break;
927 case IPX_FRAME_SNAP: rc = htons(ETH_P_SNAP); break;
928 case IPX_FRAME_8023: rc = htons(ETH_P_802_3); break;
929 }
930
931 return rc;
932}
933
934static int ipxitf_create(struct ipx_interface_definition *idef)
935{
936 struct net_device *dev;
937 __be16 dlink_type = 0;
938 struct datalink_proto *datalink = NULL;
939 struct ipx_interface *intrfc;
940 int rc;
941
942 if (idef->ipx_special == IPX_INTERNAL) {
943 rc = ipxitf_create_internal(idef);
944 goto out;
945 }
946
947 rc = -EEXIST;
948 if (idef->ipx_special == IPX_PRIMARY && ipx_primary_net)
949 goto out;
950
951 intrfc = ipxitf_find_using_net(idef->ipx_network);
952 rc = -EADDRINUSE;
953 if (idef->ipx_network && intrfc) {
954 ipxitf_put(intrfc);
955 goto out;
956 }
957
958 if (intrfc)
959 ipxitf_put(intrfc);
960
961 dev = dev_get_by_name(&init_net, idef->ipx_device);
962 rc = -ENODEV;
963 if (!dev)
964 goto out;
965
966 switch (idef->ipx_dlink_type) {
967 case IPX_FRAME_8022:
968 dlink_type = htons(ETH_P_802_2);
969 datalink = p8022_datalink;
970 break;
971 case IPX_FRAME_ETHERII:
972 if (dev->type != ARPHRD_IEEE802) {
973 dlink_type = htons(ETH_P_IPX);
974 datalink = pEII_datalink;
975 break;
976 }
977 /* fall through */
978 case IPX_FRAME_SNAP:
979 dlink_type = htons(ETH_P_SNAP);
980 datalink = pSNAP_datalink;
981 break;
982 case IPX_FRAME_8023:
983 dlink_type = htons(ETH_P_802_3);
984 datalink = p8023_datalink;
985 break;
986 case IPX_FRAME_NONE:
987 default:
988 rc = -EPROTONOSUPPORT;
989 goto out_dev;
990 }
991
992 rc = -ENETDOWN;
993 if (!(dev->flags & IFF_UP))
994 goto out_dev;
995
996 /* Check addresses are suitable */
997 rc = -EINVAL;
998 if (dev->addr_len > IPX_NODE_LEN)
999 goto out_dev;
1000
1001 intrfc = ipxitf_find_using_phys(dev, dlink_type);
1002 if (!intrfc) {
1003 /* Ok now create */
1004 intrfc = ipxitf_alloc(dev, idef->ipx_network, dlink_type,
1005 datalink, 0, dev->hard_header_len +
1006 datalink->header_length);
1007 rc = -EAGAIN;
1008 if (!intrfc)
1009 goto out_dev;
1010 /* Setup primary if necessary */
1011 if (idef->ipx_special == IPX_PRIMARY)
1012 ipx_primary_net = intrfc;
1013 if (!memcmp(idef->ipx_node, "\000\000\000\000\000\000",
1014 IPX_NODE_LEN)) {
1015 memset(intrfc->if_node, 0, IPX_NODE_LEN);
1016 memcpy(intrfc->if_node + IPX_NODE_LEN - dev->addr_len,
1017 dev->dev_addr, dev->addr_len);
1018 } else
1019 memcpy(intrfc->if_node, idef->ipx_node, IPX_NODE_LEN);
1020 ipxitf_hold(intrfc);
1021 ipxitf_insert(intrfc);
1022 }
1023
1024
1025 /* If the network number is known, add a route */
1026 rc = 0;
1027 if (!intrfc->if_netnum)
1028 goto out_intrfc;
1029
1030 rc = ipxitf_add_local_route(intrfc);
1031out_intrfc:
1032 ipxitf_put(intrfc);
1033 goto out;
1034out_dev:
1035 dev_put(dev);
1036out:
1037 return rc;
1038}
1039
1040static int ipxitf_delete(struct ipx_interface_definition *idef)
1041{
1042 struct net_device *dev = NULL;
1043 __be16 dlink_type = 0;
1044 struct ipx_interface *intrfc;
1045 int rc = 0;
1046
1047 spin_lock_bh(&ipx_interfaces_lock);
1048 if (idef->ipx_special == IPX_INTERNAL) {
1049 if (ipx_internal_net) {
1050 __ipxitf_put(ipx_internal_net);
1051 goto out;
1052 }
1053 rc = -ENOENT;
1054 goto out;
1055 }
1056
1057 dlink_type = ipx_map_frame_type(idef->ipx_dlink_type);
1058 rc = -EPROTONOSUPPORT;
1059 if (!dlink_type)
1060 goto out;
1061
1062 dev = __dev_get_by_name(&init_net, idef->ipx_device);
1063 rc = -ENODEV;
1064 if (!dev)
1065 goto out;
1066
1067 intrfc = __ipxitf_find_using_phys(dev, dlink_type);
1068 rc = -EINVAL;
1069 if (!intrfc)
1070 goto out;
1071 __ipxitf_put(intrfc);
1072
1073 rc = 0;
1074out:
1075 spin_unlock_bh(&ipx_interfaces_lock);
1076 return rc;
1077}
1078
1079static struct ipx_interface *ipxitf_auto_create(struct net_device *dev,
1080 __be16 dlink_type)
1081{
1082 struct ipx_interface *intrfc = NULL;
1083 struct datalink_proto *datalink;
1084
1085 if (!dev)
1086 goto out;
1087
1088 /* Check addresses are suitable */
1089 if (dev->addr_len > IPX_NODE_LEN)
1090 goto out;
1091
1092 switch (ntohs(dlink_type)) {
1093 case ETH_P_IPX: datalink = pEII_datalink; break;
1094 case ETH_P_802_2: datalink = p8022_datalink; break;
1095 case ETH_P_SNAP: datalink = pSNAP_datalink; break;
1096 case ETH_P_802_3: datalink = p8023_datalink; break;
1097 default: goto out;
1098 }
1099
1100 intrfc = ipxitf_alloc(dev, 0, dlink_type, datalink, 0,
1101 dev->hard_header_len + datalink->header_length);
1102
1103 if (intrfc) {
1104 memset(intrfc->if_node, 0, IPX_NODE_LEN);
1105 memcpy((char *)&(intrfc->if_node[IPX_NODE_LEN-dev->addr_len]),
1106 dev->dev_addr, dev->addr_len);
1107 spin_lock_init(&intrfc->if_sklist_lock);
1108 refcount_set(&intrfc->refcnt, 1);
1109 ipxitf_insert(intrfc);
1110 dev_hold(dev);
1111 }
1112
1113out:
1114 return intrfc;
1115}
1116
1117static int ipxitf_ioctl(unsigned int cmd, void __user *arg)
1118{
1119 int rc = -EINVAL;
1120 struct ifreq ifr;
1121 int val;
1122
1123 switch (cmd) {
1124 case SIOCSIFADDR: {
1125 struct sockaddr_ipx *sipx;
1126 struct ipx_interface_definition f;
1127
1128 rc = -EFAULT;
1129 if (copy_from_user(&ifr, arg, sizeof(ifr)))
1130 break;
1131 sipx = (struct sockaddr_ipx *)&ifr.ifr_addr;
1132 rc = -EINVAL;
1133 if (sipx->sipx_family != AF_IPX)
1134 break;
1135 f.ipx_network = sipx->sipx_network;
1136 memcpy(f.ipx_device, ifr.ifr_name,
1137 sizeof(f.ipx_device));
1138 memcpy(f.ipx_node, sipx->sipx_node, IPX_NODE_LEN);
1139 f.ipx_dlink_type = sipx->sipx_type;
1140 f.ipx_special = sipx->sipx_special;
1141
1142 if (sipx->sipx_action == IPX_DLTITF)
1143 rc = ipxitf_delete(&f);
1144 else
1145 rc = ipxitf_create(&f);
1146 break;
1147 }
1148 case SIOCGIFADDR: {
1149 struct sockaddr_ipx *sipx;
1150 struct ipx_interface *ipxif;
1151 struct net_device *dev;
1152
1153 rc = -EFAULT;
1154 if (copy_from_user(&ifr, arg, sizeof(ifr)))
1155 break;
1156 sipx = (struct sockaddr_ipx *)&ifr.ifr_addr;
1157 dev = __dev_get_by_name(&init_net, ifr.ifr_name);
1158 rc = -ENODEV;
1159 if (!dev)
1160 break;
1161 ipxif = ipxitf_find_using_phys(dev,
1162 ipx_map_frame_type(sipx->sipx_type));
1163 rc = -EADDRNOTAVAIL;
1164 if (!ipxif)
1165 break;
1166
1167 sipx->sipx_family = AF_IPX;
1168 sipx->sipx_network = ipxif->if_netnum;
1169 memcpy(sipx->sipx_node, ipxif->if_node,
1170 sizeof(sipx->sipx_node));
1171 rc = 0;
1172 if (copy_to_user(arg, &ifr, sizeof(ifr)))
1173 rc = -EFAULT;
1174 ipxitf_put(ipxif);
1175 break;
1176 }
1177 case SIOCAIPXITFCRT:
1178 rc = -EFAULT;
1179 if (get_user(val, (unsigned char __user *) arg))
1180 break;
1181 rc = 0;
1182 ipxcfg_auto_create_interfaces = val;
1183 break;
1184 case SIOCAIPXPRISLT:
1185 rc = -EFAULT;
1186 if (get_user(val, (unsigned char __user *) arg))
1187 break;
1188 rc = 0;
1189 ipxcfg_set_auto_select(val);
1190 break;
1191 }
1192
1193 return rc;
1194}
1195
1196/*
1197 * Checksum routine for IPX
1198 */
1199
1200/* Note: We assume ipx_tctrl==0 and htons(length)==ipx_pktsize */
1201/* This functions should *not* mess with packet contents */
1202
1203__be16 ipx_cksum(struct ipxhdr *packet, int length)
1204{
1205 /*
1206 * NOTE: sum is a net byte order quantity, which optimizes the
1207 * loop. This only works on big and little endian machines. (I
1208 * don't know of a machine that isn't.)
1209 */
1210 /* handle the first 3 words separately; checksum should be skipped
1211 * and ipx_tctrl masked out */
1212 __u16 *p = (__u16 *)packet;
1213 __u32 sum = p[1] + (p[2] & (__force u16)htons(0x00ff));
1214 __u32 i = (length >> 1) - 3; /* Number of remaining complete words */
1215
1216 /* Loop through them */
1217 p += 3;
1218 while (i--)
1219 sum += *p++;
1220
1221 /* Add on the last part word if it exists */
1222 if (packet->ipx_pktsize & htons(1))
1223 sum += (__force u16)htons(0xff00) & *p;
1224
1225 /* Do final fixup */
1226 sum = (sum & 0xffff) + (sum >> 16);
1227
1228 /* It's a pity there's no concept of carry in C */
1229 if (sum >= 0x10000)
1230 sum++;
1231
1232 /*
1233 * Leave 0 alone; we don't want 0xffff here. Note that we can't get
1234 * here with 0x10000, so this check is the same as ((__u16)sum)
1235 */
1236 if (sum)
1237 sum = ~sum;
1238
1239 return (__force __be16)sum;
1240}
1241
1242const char *ipx_frame_name(__be16 frame)
1243{
1244 char* rc = "None";
1245
1246 switch (ntohs(frame)) {
1247 case ETH_P_IPX: rc = "EtherII"; break;
1248 case ETH_P_802_2: rc = "802.2"; break;
1249 case ETH_P_SNAP: rc = "SNAP"; break;
1250 case ETH_P_802_3: rc = "802.3"; break;
1251 }
1252
1253 return rc;
1254}
1255
1256const char *ipx_device_name(struct ipx_interface *intrfc)
1257{
1258 return intrfc->if_internal ? "Internal" :
1259 intrfc->if_dev ? intrfc->if_dev->name : "Unknown";
1260}
1261
1262/* Handling for system calls applied via the various interfaces to an IPX
1263 * socket object. */
1264
1265static int ipx_setsockopt(struct socket *sock, int level, int optname,
1266 char __user *optval, unsigned int optlen)
1267{
1268 struct sock *sk = sock->sk;
1269 int opt;
1270 int rc = -EINVAL;
1271
1272 lock_sock(sk);
1273 if (optlen != sizeof(int))
1274 goto out;
1275
1276 rc = -EFAULT;
1277 if (get_user(opt, (unsigned int __user *)optval))
1278 goto out;
1279
1280 rc = -ENOPROTOOPT;
1281 if (!(level == SOL_IPX && optname == IPX_TYPE))
1282 goto out;
1283
1284 ipx_sk(sk)->type = opt;
1285 rc = 0;
1286out:
1287 release_sock(sk);
1288 return rc;
1289}
1290
1291static int ipx_getsockopt(struct socket *sock, int level, int optname,
1292 char __user *optval, int __user *optlen)
1293{
1294 struct sock *sk = sock->sk;
1295 int val = 0;
1296 int len;
1297 int rc = -ENOPROTOOPT;
1298
1299 lock_sock(sk);
1300 if (!(level == SOL_IPX && optname == IPX_TYPE))
1301 goto out;
1302
1303 val = ipx_sk(sk)->type;
1304
1305 rc = -EFAULT;
1306 if (get_user(len, optlen))
1307 goto out;
1308
1309 len = min_t(unsigned int, len, sizeof(int));
1310 rc = -EINVAL;
1311 if(len < 0)
1312 goto out;
1313
1314 rc = -EFAULT;
1315 if (put_user(len, optlen) || copy_to_user(optval, &val, len))
1316 goto out;
1317
1318 rc = 0;
1319out:
1320 release_sock(sk);
1321 return rc;
1322}
1323
1324static struct proto ipx_proto = {
1325 .name = "IPX",
1326 .owner = THIS_MODULE,
1327 .obj_size = sizeof(struct ipx_sock),
1328};
1329
1330static int ipx_create(struct net *net, struct socket *sock, int protocol,
1331 int kern)
1332{
1333 int rc = -ESOCKTNOSUPPORT;
1334 struct sock *sk;
1335
1336 if (!net_eq(net, &init_net))
1337 return -EAFNOSUPPORT;
1338
1339 /*
1340 * SPX support is not anymore in the kernel sources. If you want to
1341 * ressurrect it, completing it and making it understand shared skbs,
1342 * be fully multithreaded, etc, grab the sources in an early 2.5 kernel
1343 * tree.
1344 */
1345 if (sock->type != SOCK_DGRAM)
1346 goto out;
1347
1348 rc = -ENOMEM;
1349 sk = sk_alloc(net, PF_IPX, GFP_KERNEL, &ipx_proto, kern);
1350 if (!sk)
1351 goto out;
1352
1353 sk_refcnt_debug_inc(sk);
1354 sock_init_data(sock, sk);
1355 sk->sk_no_check_tx = 1; /* Checksum off by default */
1356 sock->ops = &ipx_dgram_ops;
1357 rc = 0;
1358out:
1359 return rc;
1360}
1361
1362static int ipx_release(struct socket *sock)
1363{
1364 struct sock *sk = sock->sk;
1365
1366 if (!sk)
1367 goto out;
1368
1369 lock_sock(sk);
1370 sk->sk_shutdown = SHUTDOWN_MASK;
1371 if (!sock_flag(sk, SOCK_DEAD))
1372 sk->sk_state_change(sk);
1373
1374 sock_set_flag(sk, SOCK_DEAD);
1375 sock->sk = NULL;
1376 sk_refcnt_debug_release(sk);
1377 ipx_destroy_socket(sk);
1378 release_sock(sk);
1379 sock_put(sk);
1380out:
1381 return 0;
1382}
1383
1384/* caller must hold a reference to intrfc */
1385
1386static __be16 ipx_first_free_socketnum(struct ipx_interface *intrfc)
1387{
1388 unsigned short socketNum = intrfc->if_sknum;
1389
1390 spin_lock_bh(&intrfc->if_sklist_lock);
1391
1392 if (socketNum < IPX_MIN_EPHEMERAL_SOCKET)
1393 socketNum = IPX_MIN_EPHEMERAL_SOCKET;
1394
1395 while (__ipxitf_find_socket(intrfc, htons(socketNum)))
1396 if (socketNum > IPX_MAX_EPHEMERAL_SOCKET)
1397 socketNum = IPX_MIN_EPHEMERAL_SOCKET;
1398 else
1399 socketNum++;
1400
1401 spin_unlock_bh(&intrfc->if_sklist_lock);
1402 intrfc->if_sknum = socketNum;
1403
1404 return htons(socketNum);
1405}
1406
1407static int __ipx_bind(struct socket *sock,
1408 struct sockaddr *uaddr, int addr_len)
1409{
1410 struct sock *sk = sock->sk;
1411 struct ipx_sock *ipxs = ipx_sk(sk);
1412 struct ipx_interface *intrfc;
1413 struct sockaddr_ipx *addr = (struct sockaddr_ipx *)uaddr;
1414 int rc = -EINVAL;
1415
1416 if (!sock_flag(sk, SOCK_ZAPPED) || addr_len != sizeof(struct sockaddr_ipx))
1417 goto out;
1418
1419 intrfc = ipxitf_find_using_net(addr->sipx_network);
1420 rc = -EADDRNOTAVAIL;
1421 if (!intrfc)
1422 goto out;
1423
1424 if (!addr->sipx_port) {
1425 addr->sipx_port = ipx_first_free_socketnum(intrfc);
1426 rc = -EINVAL;
1427 if (!addr->sipx_port)
1428 goto out_put;
1429 }
1430
1431 /* protect IPX system stuff like routing/sap */
1432 rc = -EACCES;
1433 if (ntohs(addr->sipx_port) < IPX_MIN_EPHEMERAL_SOCKET &&
1434 !capable(CAP_NET_ADMIN))
1435 goto out_put;
1436
1437 ipxs->port = addr->sipx_port;
1438
1439#ifdef CONFIG_IPX_INTERN
1440 if (intrfc == ipx_internal_net) {
1441 /* The source address is to be set explicitly if the
1442 * socket is to be bound on the internal network. If a
1443 * node number 0 was specified, the default is used.
1444 */
1445
1446 rc = -EINVAL;
1447 if (!memcmp(addr->sipx_node, ipx_broadcast_node, IPX_NODE_LEN))
1448 goto out_put;
1449 if (!memcmp(addr->sipx_node, ipx_this_node, IPX_NODE_LEN))
1450 memcpy(ipxs->node, intrfc->if_node, IPX_NODE_LEN);
1451 else
1452 memcpy(ipxs->node, addr->sipx_node, IPX_NODE_LEN);
1453
1454 rc = -EADDRINUSE;
1455 if (ipxitf_find_internal_socket(intrfc, ipxs->node,
1456 ipxs->port)) {
1457 SOCK_DEBUG(sk,
1458 "IPX: bind failed because port %X in use.\n",
1459 ntohs(addr->sipx_port));
1460 goto out_put;
1461 }
1462 } else {
1463 /* Source addresses are easy. It must be our
1464 * network:node pair for an interface routed to IPX
1465 * with the ipx routing ioctl()
1466 */
1467
1468 memcpy(ipxs->node, intrfc->if_node, IPX_NODE_LEN);
1469
1470 rc = -EADDRINUSE;
1471 if (ipxitf_find_socket(intrfc, addr->sipx_port)) {
1472 SOCK_DEBUG(sk,
1473 "IPX: bind failed because port %X in use.\n",
1474 ntohs(addr->sipx_port));
1475 goto out_put;
1476 }
1477 }
1478
1479#else /* !def CONFIG_IPX_INTERN */
1480
1481 /* Source addresses are easy. It must be our network:node pair for
1482 an interface routed to IPX with the ipx routing ioctl() */
1483
1484 rc = -EADDRINUSE;
1485 if (ipxitf_find_socket(intrfc, addr->sipx_port)) {
1486 SOCK_DEBUG(sk, "IPX: bind failed because port %X in use.\n",
1487 ntohs((int)addr->sipx_port));
1488 goto out_put;
1489 }
1490
1491#endif /* CONFIG_IPX_INTERN */
1492
1493 ipxitf_insert_socket(intrfc, sk);
1494 sock_reset_flag(sk, SOCK_ZAPPED);
1495
1496 rc = 0;
1497out_put:
1498 ipxitf_put(intrfc);
1499out:
1500 return rc;
1501}
1502
1503static int ipx_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1504{
1505 struct sock *sk = sock->sk;
1506 int rc;
1507
1508 lock_sock(sk);
1509 rc = __ipx_bind(sock, uaddr, addr_len);
1510 release_sock(sk);
1511
1512 return rc;
1513}
1514
1515static int ipx_connect(struct socket *sock, struct sockaddr *uaddr,
1516 int addr_len, int flags)
1517{
1518 struct sock *sk = sock->sk;
1519 struct ipx_sock *ipxs = ipx_sk(sk);
1520 struct sockaddr_ipx *addr;
1521 int rc = -EINVAL;
1522 struct ipx_route *rt;
1523
1524 sk->sk_state = TCP_CLOSE;
1525 sock->state = SS_UNCONNECTED;
1526
1527 lock_sock(sk);
1528 if (addr_len != sizeof(*addr))
1529 goto out;
1530 addr = (struct sockaddr_ipx *)uaddr;
1531
1532 /* put the autobinding in */
1533 if (!ipxs->port) {
1534 struct sockaddr_ipx uaddr;
1535
1536 uaddr.sipx_port = 0;
1537 uaddr.sipx_network = 0;
1538
1539#ifdef CONFIG_IPX_INTERN
1540 rc = -ENETDOWN;
1541 if (!ipxs->intrfc)
1542 goto out; /* Someone zonked the iface */
1543 memcpy(uaddr.sipx_node, ipxs->intrfc->if_node,
1544 IPX_NODE_LEN);
1545#endif /* CONFIG_IPX_INTERN */
1546
1547 rc = __ipx_bind(sock, (struct sockaddr *)&uaddr,
1548 sizeof(struct sockaddr_ipx));
1549 if (rc)
1550 goto out;
1551 }
1552
1553 /* We can either connect to primary network or somewhere
1554 * we can route to */
1555 rt = ipxrtr_lookup(addr->sipx_network);
1556 rc = -ENETUNREACH;
1557 if (!rt && !(!addr->sipx_network && ipx_primary_net))
1558 goto out;
1559
1560 ipxs->dest_addr.net = addr->sipx_network;
1561 ipxs->dest_addr.sock = addr->sipx_port;
1562 memcpy(ipxs->dest_addr.node, addr->sipx_node, IPX_NODE_LEN);
1563 ipxs->type = addr->sipx_type;
1564
1565 if (sock->type == SOCK_DGRAM) {
1566 sock->state = SS_CONNECTED;
1567 sk->sk_state = TCP_ESTABLISHED;
1568 }
1569
1570 if (rt)
1571 ipxrtr_put(rt);
1572 rc = 0;
1573out:
1574 release_sock(sk);
1575 return rc;
1576}
1577
1578
1579static int ipx_getname(struct socket *sock, struct sockaddr *uaddr,
1580 int peer)
1581{
1582 struct ipx_address *addr;
1583 struct sockaddr_ipx sipx;
1584 struct sock *sk = sock->sk;
1585 struct ipx_sock *ipxs = ipx_sk(sk);
1586 int rc;
1587
1588 lock_sock(sk);
1589 if (peer) {
1590 rc = -ENOTCONN;
1591 if (sk->sk_state != TCP_ESTABLISHED)
1592 goto out;
1593
1594 addr = &ipxs->dest_addr;
1595 sipx.sipx_network = addr->net;
1596 sipx.sipx_port = addr->sock;
1597 memcpy(sipx.sipx_node, addr->node, IPX_NODE_LEN);
1598 } else {
1599 if (ipxs->intrfc) {
1600 sipx.sipx_network = ipxs->intrfc->if_netnum;
1601#ifdef CONFIG_IPX_INTERN
1602 memcpy(sipx.sipx_node, ipxs->node, IPX_NODE_LEN);
1603#else
1604 memcpy(sipx.sipx_node, ipxs->intrfc->if_node,
1605 IPX_NODE_LEN);
1606#endif /* CONFIG_IPX_INTERN */
1607
1608 } else {
1609 sipx.sipx_network = 0;
1610 memset(sipx.sipx_node, '\0', IPX_NODE_LEN);
1611 }
1612
1613 sipx.sipx_port = ipxs->port;
1614 }
1615
1616 sipx.sipx_family = AF_IPX;
1617 sipx.sipx_type = ipxs->type;
1618 sipx.sipx_zero = 0;
1619 memcpy(uaddr, &sipx, sizeof(sipx));
1620
1621 rc = sizeof(struct sockaddr_ipx);
1622out:
1623 release_sock(sk);
1624 return rc;
1625}
1626
1627static int ipx_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
1628{
1629 /* NULL here for pt means the packet was looped back */
1630 struct ipx_interface *intrfc;
1631 struct ipxhdr *ipx;
1632 u16 ipx_pktsize;
1633 int rc = 0;
1634
1635 if (!net_eq(dev_net(dev), &init_net))
1636 goto drop;
1637
1638 /* Not ours */
1639 if (skb->pkt_type == PACKET_OTHERHOST)
1640 goto drop;
1641
1642 if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
1643 goto out;
1644
1645 if (!pskb_may_pull(skb, sizeof(struct ipxhdr)))
1646 goto drop;
1647
1648 ipx_pktsize = ntohs(ipx_hdr(skb)->ipx_pktsize);
1649
1650 /* Too small or invalid header? */
1651 if (ipx_pktsize < sizeof(struct ipxhdr) ||
1652 !pskb_may_pull(skb, ipx_pktsize))
1653 goto drop;
1654
1655 ipx = ipx_hdr(skb);
1656 if (ipx->ipx_checksum != IPX_NO_CHECKSUM &&
1657 ipx->ipx_checksum != ipx_cksum(ipx, ipx_pktsize))
1658 goto drop;
1659
1660 IPX_SKB_CB(skb)->ipx_tctrl = ipx->ipx_tctrl;
1661 IPX_SKB_CB(skb)->ipx_dest_net = ipx->ipx_dest.net;
1662 IPX_SKB_CB(skb)->ipx_source_net = ipx->ipx_source.net;
1663
1664 /* Determine what local ipx endpoint this is */
1665 intrfc = ipxitf_find_using_phys(dev, pt->type);
1666 if (!intrfc) {
1667 if (ipxcfg_auto_create_interfaces &&
1668 IPX_SKB_CB(skb)->ipx_dest_net) {
1669 intrfc = ipxitf_auto_create(dev, pt->type);
1670 if (intrfc)
1671 ipxitf_hold(intrfc);
1672 }
1673
1674 if (!intrfc) /* Not one of ours */
1675 /* or invalid packet for auto creation */
1676 goto drop;
1677 }
1678
1679 rc = ipxitf_rcv(intrfc, skb);
1680 ipxitf_put(intrfc);
1681 goto out;
1682drop:
1683 kfree_skb(skb);
1684out:
1685 return rc;
1686}
1687
1688static int ipx_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1689{
1690 struct sock *sk = sock->sk;
1691 struct ipx_sock *ipxs = ipx_sk(sk);
1692 DECLARE_SOCKADDR(struct sockaddr_ipx *, usipx, msg->msg_name);
1693 struct sockaddr_ipx local_sipx;
1694 int rc = -EINVAL;
1695 int flags = msg->msg_flags;
1696
1697 lock_sock(sk);
1698 /* Socket gets bound below anyway */
1699/* if (sk->sk_zapped)
1700 return -EIO; */ /* Socket not bound */
1701 if (flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
1702 goto out;
1703
1704 /* Max possible packet size limited by 16 bit pktsize in header */
1705 if (len >= 65535 - sizeof(struct ipxhdr))
1706 goto out;
1707
1708 if (usipx) {
1709 if (!ipxs->port) {
1710 struct sockaddr_ipx uaddr;
1711
1712 uaddr.sipx_port = 0;
1713 uaddr.sipx_network = 0;
1714#ifdef CONFIG_IPX_INTERN
1715 rc = -ENETDOWN;
1716 if (!ipxs->intrfc)
1717 goto out; /* Someone zonked the iface */
1718 memcpy(uaddr.sipx_node, ipxs->intrfc->if_node,
1719 IPX_NODE_LEN);
1720#endif
1721 rc = __ipx_bind(sock, (struct sockaddr *)&uaddr,
1722 sizeof(struct sockaddr_ipx));
1723 if (rc)
1724 goto out;
1725 }
1726
1727 rc = -EINVAL;
1728 if (msg->msg_namelen < sizeof(*usipx) ||
1729 usipx->sipx_family != AF_IPX)
1730 goto out;
1731 } else {
1732 rc = -ENOTCONN;
1733 if (sk->sk_state != TCP_ESTABLISHED)
1734 goto out;
1735
1736 usipx = &local_sipx;
1737 usipx->sipx_family = AF_IPX;
1738 usipx->sipx_type = ipxs->type;
1739 usipx->sipx_port = ipxs->dest_addr.sock;
1740 usipx->sipx_network = ipxs->dest_addr.net;
1741 memcpy(usipx->sipx_node, ipxs->dest_addr.node, IPX_NODE_LEN);
1742 }
1743
1744 rc = ipxrtr_route_packet(sk, usipx, msg, len, flags & MSG_DONTWAIT);
1745 if (rc >= 0)
1746 rc = len;
1747out:
1748 release_sock(sk);
1749 return rc;
1750}
1751
1752
1753static int ipx_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1754 int flags)
1755{
1756 struct sock *sk = sock->sk;
1757 struct ipx_sock *ipxs = ipx_sk(sk);
1758 DECLARE_SOCKADDR(struct sockaddr_ipx *, sipx, msg->msg_name);
1759 struct ipxhdr *ipx = NULL;
1760 struct sk_buff *skb;
1761 int copied, rc;
1762 bool locked = true;
1763
1764 lock_sock(sk);
1765 /* put the autobinding in */
1766 if (!ipxs->port) {
1767 struct sockaddr_ipx uaddr;
1768
1769 uaddr.sipx_port = 0;
1770 uaddr.sipx_network = 0;
1771
1772#ifdef CONFIG_IPX_INTERN
1773 rc = -ENETDOWN;
1774 if (!ipxs->intrfc)
1775 goto out; /* Someone zonked the iface */
1776 memcpy(uaddr.sipx_node, ipxs->intrfc->if_node, IPX_NODE_LEN);
1777#endif /* CONFIG_IPX_INTERN */
1778
1779 rc = __ipx_bind(sock, (struct sockaddr *)&uaddr,
1780 sizeof(struct sockaddr_ipx));
1781 if (rc)
1782 goto out;
1783 }
1784
1785 rc = -ENOTCONN;
1786 if (sock_flag(sk, SOCK_ZAPPED))
1787 goto out;
1788
1789 release_sock(sk);
1790 locked = false;
1791 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1792 flags & MSG_DONTWAIT, &rc);
1793 if (!skb) {
1794 if (rc == -EAGAIN && (sk->sk_shutdown & RCV_SHUTDOWN))
1795 rc = 0;
1796 goto out;
1797 }
1798
1799 ipx = ipx_hdr(skb);
1800 copied = ntohs(ipx->ipx_pktsize) - sizeof(struct ipxhdr);
1801 if (copied > size) {
1802 copied = size;
1803 msg->msg_flags |= MSG_TRUNC;
1804 }
1805
1806 rc = skb_copy_datagram_msg(skb, sizeof(struct ipxhdr), msg, copied);
1807 if (rc)
1808 goto out_free;
1809 if (skb->tstamp)
1810 sk->sk_stamp = skb->tstamp;
1811
1812 if (sipx) {
1813 sipx->sipx_family = AF_IPX;
1814 sipx->sipx_port = ipx->ipx_source.sock;
1815 memcpy(sipx->sipx_node, ipx->ipx_source.node, IPX_NODE_LEN);
1816 sipx->sipx_network = IPX_SKB_CB(skb)->ipx_source_net;
1817 sipx->sipx_type = ipx->ipx_type;
1818 sipx->sipx_zero = 0;
1819 msg->msg_namelen = sizeof(*sipx);
1820 }
1821 rc = copied;
1822
1823out_free:
1824 skb_free_datagram(sk, skb);
1825out:
1826 if (locked)
1827 release_sock(sk);
1828 return rc;
1829}
1830
1831
1832static int ipx_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1833{
1834 int rc = 0;
1835 long amount = 0;
1836 struct sock *sk = sock->sk;
1837 void __user *argp = (void __user *)arg;
1838
1839 lock_sock(sk);
1840 switch (cmd) {
1841 case TIOCOUTQ:
1842 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1843 if (amount < 0)
1844 amount = 0;
1845 rc = put_user(amount, (int __user *)argp);
1846 break;
1847 case TIOCINQ: {
1848 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
1849 /* These two are safe on a single CPU system as only
1850 * user tasks fiddle here */
1851 if (skb)
1852 amount = skb->len - sizeof(struct ipxhdr);
1853 rc = put_user(amount, (int __user *)argp);
1854 break;
1855 }
1856 case SIOCADDRT:
1857 case SIOCDELRT:
1858 rc = -EPERM;
1859 if (capable(CAP_NET_ADMIN))
1860 rc = ipxrtr_ioctl(cmd, argp);
1861 break;
1862 case SIOCSIFADDR:
1863 case SIOCAIPXITFCRT:
1864 case SIOCAIPXPRISLT:
1865 rc = -EPERM;
1866 if (!capable(CAP_NET_ADMIN))
1867 break;
1868 /* fall through */
1869 case SIOCGIFADDR:
1870 rc = ipxitf_ioctl(cmd, argp);
1871 break;
1872 case SIOCIPXCFGDATA:
1873 rc = ipxcfg_get_config_data(argp);
1874 break;
1875 case SIOCIPXNCPCONN:
1876 /*
1877 * This socket wants to take care of the NCP connection
1878 * handed to us in arg.
1879 */
1880 rc = -EPERM;
1881 if (!capable(CAP_NET_ADMIN))
1882 break;
1883 rc = get_user(ipx_sk(sk)->ipx_ncp_conn,
1884 (const unsigned short __user *)argp);
1885 break;
1886 case SIOCGSTAMP:
1887 rc = sock_get_timestamp(sk, argp);
1888 break;
1889 case SIOCGIFDSTADDR:
1890 case SIOCSIFDSTADDR:
1891 case SIOCGIFBRDADDR:
1892 case SIOCSIFBRDADDR:
1893 case SIOCGIFNETMASK:
1894 case SIOCSIFNETMASK:
1895 rc = -EINVAL;
1896 break;
1897 default:
1898 rc = -ENOIOCTLCMD;
1899 break;
1900 }
1901 release_sock(sk);
1902
1903 return rc;
1904}
1905
1906
1907#ifdef CONFIG_COMPAT
1908static int ipx_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1909{
1910 /*
1911 * These 4 commands use same structure on 32bit and 64bit. Rest of IPX
1912 * commands is handled by generic ioctl code. As these commands are
1913 * SIOCPROTOPRIVATE..SIOCPROTOPRIVATE+3, they cannot be handled by generic
1914 * code.
1915 */
1916 switch (cmd) {
1917 case SIOCAIPXITFCRT:
1918 case SIOCAIPXPRISLT:
1919 case SIOCIPXCFGDATA:
1920 case SIOCIPXNCPCONN:
1921 return ipx_ioctl(sock, cmd, arg);
1922 default:
1923 return -ENOIOCTLCMD;
1924 }
1925}
1926#endif
1927
1928static int ipx_shutdown(struct socket *sock, int mode)
1929{
1930 struct sock *sk = sock->sk;
1931
1932 if (mode < SHUT_RD || mode > SHUT_RDWR)
1933 return -EINVAL;
1934 /* This maps:
1935 * SHUT_RD (0) -> RCV_SHUTDOWN (1)
1936 * SHUT_WR (1) -> SEND_SHUTDOWN (2)
1937 * SHUT_RDWR (2) -> SHUTDOWN_MASK (3)
1938 */
1939 ++mode;
1940
1941 lock_sock(sk);
1942 sk->sk_shutdown |= mode;
1943 release_sock(sk);
1944 sk->sk_state_change(sk);
1945
1946 return 0;
1947}
1948
1949/*
1950 * Socket family declarations
1951 */
1952
1953static const struct net_proto_family ipx_family_ops = {
1954 .family = PF_IPX,
1955 .create = ipx_create,
1956 .owner = THIS_MODULE,
1957};
1958
1959static const struct proto_ops ipx_dgram_ops = {
1960 .family = PF_IPX,
1961 .owner = THIS_MODULE,
1962 .release = ipx_release,
1963 .bind = ipx_bind,
1964 .connect = ipx_connect,
1965 .socketpair = sock_no_socketpair,
1966 .accept = sock_no_accept,
1967 .getname = ipx_getname,
1968 .poll = datagram_poll,
1969 .ioctl = ipx_ioctl,
1970#ifdef CONFIG_COMPAT
1971 .compat_ioctl = ipx_compat_ioctl,
1972#endif
1973 .listen = sock_no_listen,
1974 .shutdown = ipx_shutdown,
1975 .setsockopt = ipx_setsockopt,
1976 .getsockopt = ipx_getsockopt,
1977 .sendmsg = ipx_sendmsg,
1978 .recvmsg = ipx_recvmsg,
1979 .mmap = sock_no_mmap,
1980 .sendpage = sock_no_sendpage,
1981};
1982
1983static struct packet_type ipx_8023_packet_type __read_mostly = {
1984 .type = cpu_to_be16(ETH_P_802_3),
1985 .func = ipx_rcv,
1986};
1987
1988static struct packet_type ipx_dix_packet_type __read_mostly = {
1989 .type = cpu_to_be16(ETH_P_IPX),
1990 .func = ipx_rcv,
1991};
1992
1993static struct notifier_block ipx_dev_notifier = {
1994 .notifier_call = ipxitf_device_event,
1995};
1996
1997static const unsigned char ipx_8022_type = 0xE0;
1998static const unsigned char ipx_snap_id[5] = { 0x0, 0x0, 0x0, 0x81, 0x37 };
1999static const char ipx_EII_err_msg[] __initconst =
2000 KERN_CRIT "IPX: Unable to register with Ethernet II\n";
2001static const char ipx_8023_err_msg[] __initconst =
2002 KERN_CRIT "IPX: Unable to register with 802.3\n";
2003static const char ipx_llc_err_msg[] __initconst =
2004 KERN_CRIT "IPX: Unable to register with 802.2\n";
2005static const char ipx_snap_err_msg[] __initconst =
2006 KERN_CRIT "IPX: Unable to register with SNAP\n";
2007
2008static int __init ipx_init(void)
2009{
2010 int rc = proto_register(&ipx_proto, 1);
2011
2012 if (rc != 0)
2013 goto out;
2014
2015 sock_register(&ipx_family_ops);
2016
2017 pEII_datalink = make_EII_client();
2018 if (pEII_datalink)
2019 dev_add_pack(&ipx_dix_packet_type);
2020 else
2021 printk(ipx_EII_err_msg);
2022
2023 p8023_datalink = make_8023_client();
2024 if (p8023_datalink)
2025 dev_add_pack(&ipx_8023_packet_type);
2026 else
2027 printk(ipx_8023_err_msg);
2028
2029 p8022_datalink = register_8022_client(ipx_8022_type, ipx_rcv);
2030 if (!p8022_datalink)
2031 printk(ipx_llc_err_msg);
2032
2033 pSNAP_datalink = register_snap_client(ipx_snap_id, ipx_rcv);
2034 if (!pSNAP_datalink)
2035 printk(ipx_snap_err_msg);
2036
2037 register_netdevice_notifier(&ipx_dev_notifier);
2038 ipx_register_sysctl();
2039 ipx_proc_init();
2040out:
2041 return rc;
2042}
2043
2044static void __exit ipx_proto_finito(void)
2045{
2046 ipx_proc_exit();
2047 ipx_unregister_sysctl();
2048
2049 unregister_netdevice_notifier(&ipx_dev_notifier);
2050
2051 ipxitf_cleanup();
2052
2053 if (pSNAP_datalink) {
2054 unregister_snap_client(pSNAP_datalink);
2055 pSNAP_datalink = NULL;
2056 }
2057
2058 if (p8022_datalink) {
2059 unregister_8022_client(p8022_datalink);
2060 p8022_datalink = NULL;
2061 }
2062
2063 dev_remove_pack(&ipx_8023_packet_type);
2064 if (p8023_datalink) {
2065 destroy_8023_client(p8023_datalink);
2066 p8023_datalink = NULL;
2067 }
2068
2069 dev_remove_pack(&ipx_dix_packet_type);
2070 if (pEII_datalink) {
2071 destroy_EII_client(pEII_datalink);
2072 pEII_datalink = NULL;
2073 }
2074
2075 proto_unregister(&ipx_proto);
2076 sock_unregister(ipx_family_ops.family);
2077}
2078
2079module_init(ipx_init);
2080module_exit(ipx_proto_finito);
2081MODULE_LICENSE("GPL");
2082MODULE_ALIAS_NETPROTO(PF_IPX);
diff --git a/drivers/staging/ipx/ipx_proc.c b/drivers/staging/ipx/ipx_proc.c
deleted file mode 100644
index b9232e4e2ed4..000000000000
--- a/drivers/staging/ipx/ipx_proc.c
+++ /dev/null
@@ -1,338 +0,0 @@
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * IPX proc routines
4 *
5 * Copyright(C) Arnaldo Carvalho de Melo <acme@conectiva.com.br>, 2002
6 */
7
8#include <linux/init.h>
9#ifdef CONFIG_PROC_FS
10#include <linux/proc_fs.h>
11#include <linux/spinlock.h>
12#include <linux/seq_file.h>
13#include <linux/export.h>
14#include <net/net_namespace.h>
15#include <net/tcp_states.h>
16#include <net/ipx.h>
17
18static void *ipx_seq_interface_start(struct seq_file *seq, loff_t *pos)
19{
20 spin_lock_bh(&ipx_interfaces_lock);
21 return seq_list_start_head(&ipx_interfaces, *pos);
22}
23
24static void *ipx_seq_interface_next(struct seq_file *seq, void *v, loff_t *pos)
25{
26 return seq_list_next(v, &ipx_interfaces, pos);
27}
28
29static void ipx_seq_interface_stop(struct seq_file *seq, void *v)
30{
31 spin_unlock_bh(&ipx_interfaces_lock);
32}
33
34static int ipx_seq_interface_show(struct seq_file *seq, void *v)
35{
36 struct ipx_interface *i;
37
38 if (v == &ipx_interfaces) {
39 seq_puts(seq, "Network Node_Address Primary Device "
40 "Frame_Type");
41#ifdef IPX_REFCNT_DEBUG
42 seq_puts(seq, " refcnt");
43#endif
44 seq_puts(seq, "\n");
45 goto out;
46 }
47
48 i = list_entry(v, struct ipx_interface, node);
49 seq_printf(seq, "%08X ", ntohl(i->if_netnum));
50 seq_printf(seq, "%02X%02X%02X%02X%02X%02X ",
51 i->if_node[0], i->if_node[1], i->if_node[2],
52 i->if_node[3], i->if_node[4], i->if_node[5]);
53 seq_printf(seq, "%-9s", i == ipx_primary_net ? "Yes" : "No");
54 seq_printf(seq, "%-11s", ipx_device_name(i));
55 seq_printf(seq, "%-9s", ipx_frame_name(i->if_dlink_type));
56#ifdef IPX_REFCNT_DEBUG
57 seq_printf(seq, "%6d", refcount_read(&i->refcnt));
58#endif
59 seq_puts(seq, "\n");
60out:
61 return 0;
62}
63
64static void *ipx_seq_route_start(struct seq_file *seq, loff_t *pos)
65{
66 read_lock_bh(&ipx_routes_lock);
67 return seq_list_start_head(&ipx_routes, *pos);
68}
69
70static void *ipx_seq_route_next(struct seq_file *seq, void *v, loff_t *pos)
71{
72 return seq_list_next(v, &ipx_routes, pos);
73}
74
75static void ipx_seq_route_stop(struct seq_file *seq, void *v)
76{
77 read_unlock_bh(&ipx_routes_lock);
78}
79
80static int ipx_seq_route_show(struct seq_file *seq, void *v)
81{
82 struct ipx_route *rt;
83
84 if (v == &ipx_routes) {
85 seq_puts(seq, "Network Router_Net Router_Node\n");
86 goto out;
87 }
88
89 rt = list_entry(v, struct ipx_route, node);
90
91 seq_printf(seq, "%08X ", ntohl(rt->ir_net));
92 if (rt->ir_routed)
93 seq_printf(seq, "%08X %02X%02X%02X%02X%02X%02X\n",
94 ntohl(rt->ir_intrfc->if_netnum),
95 rt->ir_router_node[0], rt->ir_router_node[1],
96 rt->ir_router_node[2], rt->ir_router_node[3],
97 rt->ir_router_node[4], rt->ir_router_node[5]);
98 else
99 seq_puts(seq, "Directly Connected\n");
100out:
101 return 0;
102}
103
104static __inline__ struct sock *ipx_get_socket_idx(loff_t pos)
105{
106 struct sock *s = NULL;
107 struct ipx_interface *i;
108
109 list_for_each_entry(i, &ipx_interfaces, node) {
110 spin_lock_bh(&i->if_sklist_lock);
111 sk_for_each(s, &i->if_sklist) {
112 if (!pos)
113 break;
114 --pos;
115 }
116 spin_unlock_bh(&i->if_sklist_lock);
117 if (!pos) {
118 if (s)
119 goto found;
120 break;
121 }
122 }
123 s = NULL;
124found:
125 return s;
126}
127
128static void *ipx_seq_socket_start(struct seq_file *seq, loff_t *pos)
129{
130 loff_t l = *pos;
131
132 spin_lock_bh(&ipx_interfaces_lock);
133 return l ? ipx_get_socket_idx(--l) : SEQ_START_TOKEN;
134}
135
136static void *ipx_seq_socket_next(struct seq_file *seq, void *v, loff_t *pos)
137{
138 struct sock* sk, *next;
139 struct ipx_interface *i;
140 struct ipx_sock *ipxs;
141
142 ++*pos;
143 if (v == SEQ_START_TOKEN) {
144 sk = NULL;
145 i = ipx_interfaces_head();
146 if (!i)
147 goto out;
148 sk = sk_head(&i->if_sklist);
149 if (sk)
150 spin_lock_bh(&i->if_sklist_lock);
151 goto out;
152 }
153 sk = v;
154 next = sk_next(sk);
155 if (next) {
156 sk = next;
157 goto out;
158 }
159 ipxs = ipx_sk(sk);
160 i = ipxs->intrfc;
161 spin_unlock_bh(&i->if_sklist_lock);
162 sk = NULL;
163 for (;;) {
164 if (i->node.next == &ipx_interfaces)
165 break;
166 i = list_entry(i->node.next, struct ipx_interface, node);
167 spin_lock_bh(&i->if_sklist_lock);
168 if (!hlist_empty(&i->if_sklist)) {
169 sk = sk_head(&i->if_sklist);
170 break;
171 }
172 spin_unlock_bh(&i->if_sklist_lock);
173 }
174out:
175 return sk;
176}
177
178static int ipx_seq_socket_show(struct seq_file *seq, void *v)
179{
180 struct sock *s;
181 struct ipx_sock *ipxs;
182
183 if (v == SEQ_START_TOKEN) {
184#ifdef CONFIG_IPX_INTERN
185 seq_puts(seq, "Local_Address "
186 "Remote_Address Tx_Queue "
187 "Rx_Queue State Uid\n");
188#else
189 seq_puts(seq, "Local_Address Remote_Address "
190 "Tx_Queue Rx_Queue State Uid\n");
191#endif
192 goto out;
193 }
194
195 s = v;
196 ipxs = ipx_sk(s);
197#ifdef CONFIG_IPX_INTERN
198 seq_printf(seq, "%08X:%02X%02X%02X%02X%02X%02X:%04X ",
199 ntohl(ipxs->intrfc->if_netnum),
200 ipxs->node[0], ipxs->node[1], ipxs->node[2], ipxs->node[3],
201 ipxs->node[4], ipxs->node[5], ntohs(ipxs->port));
202#else
203 seq_printf(seq, "%08X:%04X ", ntohl(ipxs->intrfc->if_netnum),
204 ntohs(ipxs->port));
205#endif /* CONFIG_IPX_INTERN */
206 if (s->sk_state != TCP_ESTABLISHED)
207 seq_printf(seq, "%-28s", "Not_Connected");
208 else {
209 seq_printf(seq, "%08X:%02X%02X%02X%02X%02X%02X:%04X ",
210 ntohl(ipxs->dest_addr.net),
211 ipxs->dest_addr.node[0], ipxs->dest_addr.node[1],
212 ipxs->dest_addr.node[2], ipxs->dest_addr.node[3],
213 ipxs->dest_addr.node[4], ipxs->dest_addr.node[5],
214 ntohs(ipxs->dest_addr.sock));
215 }
216
217 seq_printf(seq, "%08X %08X %02X %03u\n",
218 sk_wmem_alloc_get(s),
219 sk_rmem_alloc_get(s),
220 s->sk_state,
221 from_kuid_munged(seq_user_ns(seq), sock_i_uid(s)));
222out:
223 return 0;
224}
225
226static const struct seq_operations ipx_seq_interface_ops = {
227 .start = ipx_seq_interface_start,
228 .next = ipx_seq_interface_next,
229 .stop = ipx_seq_interface_stop,
230 .show = ipx_seq_interface_show,
231};
232
233static const struct seq_operations ipx_seq_route_ops = {
234 .start = ipx_seq_route_start,
235 .next = ipx_seq_route_next,
236 .stop = ipx_seq_route_stop,
237 .show = ipx_seq_route_show,
238};
239
240static const struct seq_operations ipx_seq_socket_ops = {
241 .start = ipx_seq_socket_start,
242 .next = ipx_seq_socket_next,
243 .stop = ipx_seq_interface_stop,
244 .show = ipx_seq_socket_show,
245};
246
247static int ipx_seq_route_open(struct inode *inode, struct file *file)
248{
249 return seq_open(file, &ipx_seq_route_ops);
250}
251
252static int ipx_seq_interface_open(struct inode *inode, struct file *file)
253{
254 return seq_open(file, &ipx_seq_interface_ops);
255}
256
257static int ipx_seq_socket_open(struct inode *inode, struct file *file)
258{
259 return seq_open(file, &ipx_seq_socket_ops);
260}
261
262static const struct file_operations ipx_seq_interface_fops = {
263 .open = ipx_seq_interface_open,
264 .read = seq_read,
265 .llseek = seq_lseek,
266 .release = seq_release,
267};
268
269static const struct file_operations ipx_seq_route_fops = {
270 .open = ipx_seq_route_open,
271 .read = seq_read,
272 .llseek = seq_lseek,
273 .release = seq_release,
274};
275
276static const struct file_operations ipx_seq_socket_fops = {
277 .open = ipx_seq_socket_open,
278 .read = seq_read,
279 .llseek = seq_lseek,
280 .release = seq_release,
281};
282
283static struct proc_dir_entry *ipx_proc_dir;
284
285int __init ipx_proc_init(void)
286{
287 struct proc_dir_entry *p;
288 int rc = -ENOMEM;
289
290 ipx_proc_dir = proc_mkdir("ipx", init_net.proc_net);
291
292 if (!ipx_proc_dir)
293 goto out;
294 p = proc_create("interface", S_IRUGO,
295 ipx_proc_dir, &ipx_seq_interface_fops);
296 if (!p)
297 goto out_interface;
298
299 p = proc_create("route", S_IRUGO, ipx_proc_dir, &ipx_seq_route_fops);
300 if (!p)
301 goto out_route;
302
303 p = proc_create("socket", S_IRUGO, ipx_proc_dir, &ipx_seq_socket_fops);
304 if (!p)
305 goto out_socket;
306
307 rc = 0;
308out:
309 return rc;
310out_socket:
311 remove_proc_entry("route", ipx_proc_dir);
312out_route:
313 remove_proc_entry("interface", ipx_proc_dir);
314out_interface:
315 remove_proc_entry("ipx", init_net.proc_net);
316 goto out;
317}
318
319void __exit ipx_proc_exit(void)
320{
321 remove_proc_entry("interface", ipx_proc_dir);
322 remove_proc_entry("route", ipx_proc_dir);
323 remove_proc_entry("socket", ipx_proc_dir);
324 remove_proc_entry("ipx", init_net.proc_net);
325}
326
327#else /* CONFIG_PROC_FS */
328
329int __init ipx_proc_init(void)
330{
331 return 0;
332}
333
334void __exit ipx_proc_exit(void)
335{
336}
337
338#endif /* CONFIG_PROC_FS */
diff --git a/drivers/staging/ipx/ipx_route.c b/drivers/staging/ipx/ipx_route.c
deleted file mode 100644
index 3cf93aa9f284..000000000000
--- a/drivers/staging/ipx/ipx_route.c
+++ /dev/null
@@ -1,293 +0,0 @@
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Implements the IPX routing routines.
4 * Code moved from af_ipx.c.
5 *
6 * Arnaldo Carvalho de Melo <acme@conectiva.com.br>, 2003
7 *
8 * See net/ipx/ChangeLog.
9 */
10
11#include <linux/list.h>
12#include <linux/route.h>
13#include <linux/slab.h>
14#include <linux/spinlock.h>
15
16#include <net/ipx.h>
17#include <net/sock.h>
18
19LIST_HEAD(ipx_routes);
20DEFINE_RWLOCK(ipx_routes_lock);
21
22extern struct ipx_interface *ipx_internal_net;
23
24extern struct ipx_interface *ipxitf_find_using_net(__be32 net);
25extern int ipxitf_demux_socket(struct ipx_interface *intrfc,
26 struct sk_buff *skb, int copy);
27extern int ipxitf_demux_socket(struct ipx_interface *intrfc,
28 struct sk_buff *skb, int copy);
29
30struct ipx_route *ipxrtr_lookup(__be32 net)
31{
32 struct ipx_route *r;
33
34 read_lock_bh(&ipx_routes_lock);
35 list_for_each_entry(r, &ipx_routes, node)
36 if (r->ir_net == net) {
37 ipxrtr_hold(r);
38 goto unlock;
39 }
40 r = NULL;
41unlock:
42 read_unlock_bh(&ipx_routes_lock);
43 return r;
44}
45
46/*
47 * Caller must hold a reference to intrfc
48 */
49int ipxrtr_add_route(__be32 network, struct ipx_interface *intrfc,
50 unsigned char *node)
51{
52 struct ipx_route *rt;
53 int rc;
54
55 /* Get a route structure; either existing or create */
56 rt = ipxrtr_lookup(network);
57 if (!rt) {
58 rt = kmalloc(sizeof(*rt), GFP_ATOMIC);
59 rc = -EAGAIN;
60 if (!rt)
61 goto out;
62
63 refcount_set(&rt->refcnt, 1);
64 ipxrtr_hold(rt);
65 write_lock_bh(&ipx_routes_lock);
66 list_add(&rt->node, &ipx_routes);
67 write_unlock_bh(&ipx_routes_lock);
68 } else {
69 rc = -EEXIST;
70 if (intrfc == ipx_internal_net)
71 goto out_put;
72 }
73
74 rt->ir_net = network;
75 rt->ir_intrfc = intrfc;
76 if (!node) {
77 memset(rt->ir_router_node, '\0', IPX_NODE_LEN);
78 rt->ir_routed = 0;
79 } else {
80 memcpy(rt->ir_router_node, node, IPX_NODE_LEN);
81 rt->ir_routed = 1;
82 }
83
84 rc = 0;
85out_put:
86 ipxrtr_put(rt);
87out:
88 return rc;
89}
90
91void ipxrtr_del_routes(struct ipx_interface *intrfc)
92{
93 struct ipx_route *r, *tmp;
94
95 write_lock_bh(&ipx_routes_lock);
96 list_for_each_entry_safe(r, tmp, &ipx_routes, node)
97 if (r->ir_intrfc == intrfc) {
98 list_del(&r->node);
99 ipxrtr_put(r);
100 }
101 write_unlock_bh(&ipx_routes_lock);
102}
103
104static int ipxrtr_create(struct ipx_route_definition *rd)
105{
106 struct ipx_interface *intrfc;
107 int rc = -ENETUNREACH;
108
109 /* Find the appropriate interface */
110 intrfc = ipxitf_find_using_net(rd->ipx_router_network);
111 if (!intrfc)
112 goto out;
113 rc = ipxrtr_add_route(rd->ipx_network, intrfc, rd->ipx_router_node);
114 ipxitf_put(intrfc);
115out:
116 return rc;
117}
118
119static int ipxrtr_delete(__be32 net)
120{
121 struct ipx_route *r, *tmp;
122 int rc;
123
124 write_lock_bh(&ipx_routes_lock);
125 list_for_each_entry_safe(r, tmp, &ipx_routes, node)
126 if (r->ir_net == net) {
127 /* Directly connected; can't lose route */
128 rc = -EPERM;
129 if (!r->ir_routed)
130 goto out;
131 list_del(&r->node);
132 ipxrtr_put(r);
133 rc = 0;
134 goto out;
135 }
136 rc = -ENOENT;
137out:
138 write_unlock_bh(&ipx_routes_lock);
139 return rc;
140}
141
142/*
143 * The skb has to be unshared, we'll end up calling ipxitf_send, that'll
144 * modify the packet
145 */
146int ipxrtr_route_skb(struct sk_buff *skb)
147{
148 struct ipxhdr *ipx = ipx_hdr(skb);
149 struct ipx_route *r = ipxrtr_lookup(IPX_SKB_CB(skb)->ipx_dest_net);
150
151 if (!r) { /* no known route */
152 kfree_skb(skb);
153 return 0;
154 }
155
156 ipxitf_hold(r->ir_intrfc);
157 ipxitf_send(r->ir_intrfc, skb, r->ir_routed ?
158 r->ir_router_node : ipx->ipx_dest.node);
159 ipxitf_put(r->ir_intrfc);
160 ipxrtr_put(r);
161
162 return 0;
163}
164
165/*
166 * Route an outgoing frame from a socket.
167 */
168int ipxrtr_route_packet(struct sock *sk, struct sockaddr_ipx *usipx,
169 struct msghdr *msg, size_t len, int noblock)
170{
171 struct sk_buff *skb;
172 struct ipx_sock *ipxs = ipx_sk(sk);
173 struct ipx_interface *intrfc;
174 struct ipxhdr *ipx;
175 size_t size;
176 int ipx_offset;
177 struct ipx_route *rt = NULL;
178 int rc;
179
180 /* Find the appropriate interface on which to send packet */
181 if (!usipx->sipx_network && ipx_primary_net) {
182 usipx->sipx_network = ipx_primary_net->if_netnum;
183 intrfc = ipx_primary_net;
184 } else {
185 rt = ipxrtr_lookup(usipx->sipx_network);
186 rc = -ENETUNREACH;
187 if (!rt)
188 goto out;
189 intrfc = rt->ir_intrfc;
190 }
191
192 ipxitf_hold(intrfc);
193 ipx_offset = intrfc->if_ipx_offset;
194 size = sizeof(struct ipxhdr) + len + ipx_offset;
195
196 skb = sock_alloc_send_skb(sk, size, noblock, &rc);
197 if (!skb)
198 goto out_put;
199
200 skb_reserve(skb, ipx_offset);
201 skb->sk = sk;
202
203 /* Fill in IPX header */
204 skb_reset_network_header(skb);
205 skb_reset_transport_header(skb);
206 skb_put(skb, sizeof(struct ipxhdr));
207 ipx = ipx_hdr(skb);
208 ipx->ipx_pktsize = htons(len + sizeof(struct ipxhdr));
209 IPX_SKB_CB(skb)->ipx_tctrl = 0;
210 ipx->ipx_type = usipx->sipx_type;
211
212 IPX_SKB_CB(skb)->last_hop.index = -1;
213#ifdef CONFIG_IPX_INTERN
214 IPX_SKB_CB(skb)->ipx_source_net = ipxs->intrfc->if_netnum;
215 memcpy(ipx->ipx_source.node, ipxs->node, IPX_NODE_LEN);
216#else
217 rc = ntohs(ipxs->port);
218 if (rc == 0x453 || rc == 0x452) {
219 /* RIP/SAP special handling for mars_nwe */
220 IPX_SKB_CB(skb)->ipx_source_net = intrfc->if_netnum;
221 memcpy(ipx->ipx_source.node, intrfc->if_node, IPX_NODE_LEN);
222 } else {
223 IPX_SKB_CB(skb)->ipx_source_net = ipxs->intrfc->if_netnum;
224 memcpy(ipx->ipx_source.node, ipxs->intrfc->if_node,
225 IPX_NODE_LEN);
226 }
227#endif /* CONFIG_IPX_INTERN */
228 ipx->ipx_source.sock = ipxs->port;
229 IPX_SKB_CB(skb)->ipx_dest_net = usipx->sipx_network;
230 memcpy(ipx->ipx_dest.node, usipx->sipx_node, IPX_NODE_LEN);
231 ipx->ipx_dest.sock = usipx->sipx_port;
232
233 rc = memcpy_from_msg(skb_put(skb, len), msg, len);
234 if (rc) {
235 kfree_skb(skb);
236 goto out_put;
237 }
238
239 /* Apply checksum. Not allowed on 802.3 links. */
240 if (sk->sk_no_check_tx ||
241 intrfc->if_dlink_type == htons(IPX_FRAME_8023))
242 ipx->ipx_checksum = htons(0xFFFF);
243 else
244 ipx->ipx_checksum = ipx_cksum(ipx, len + sizeof(struct ipxhdr));
245
246 rc = ipxitf_send(intrfc, skb, (rt && rt->ir_routed) ?
247 rt->ir_router_node : ipx->ipx_dest.node);
248out_put:
249 ipxitf_put(intrfc);
250 if (rt)
251 ipxrtr_put(rt);
252out:
253 return rc;
254}
255
256/*
257 * We use a normal struct rtentry for route handling
258 */
259int ipxrtr_ioctl(unsigned int cmd, void __user *arg)
260{
261 struct rtentry rt; /* Use these to behave like 'other' stacks */
262 struct sockaddr_ipx *sg, *st;
263 int rc = -EFAULT;
264
265 if (copy_from_user(&rt, arg, sizeof(rt)))
266 goto out;
267
268 sg = (struct sockaddr_ipx *)&rt.rt_gateway;
269 st = (struct sockaddr_ipx *)&rt.rt_dst;
270
271 rc = -EINVAL;
272 if (!(rt.rt_flags & RTF_GATEWAY) || /* Direct routes are fixed */
273 sg->sipx_family != AF_IPX ||
274 st->sipx_family != AF_IPX)
275 goto out;
276
277 switch (cmd) {
278 case SIOCDELRT:
279 rc = ipxrtr_delete(st->sipx_network);
280 break;
281 case SIOCADDRT: {
282 struct ipx_route_definition f;
283 f.ipx_network = st->sipx_network;
284 f.ipx_router_network = sg->sipx_network;
285 memcpy(f.ipx_router_node, sg->sipx_node, IPX_NODE_LEN);
286 rc = ipxrtr_create(&f);
287 break;
288 }
289 }
290
291out:
292 return rc;
293}
diff --git a/drivers/staging/ipx/pe2.c b/drivers/staging/ipx/pe2.c
deleted file mode 100644
index ba7d4214bbff..000000000000
--- a/drivers/staging/ipx/pe2.c
+++ /dev/null
@@ -1,36 +0,0 @@
1// SPDX-License-Identifier: GPL-2.0
2#include <linux/in.h>
3#include <linux/mm.h>
4#include <linux/module.h>
5#include <linux/netdevice.h>
6#include <linux/skbuff.h>
7#include <linux/slab.h>
8
9#include <net/datalink.h>
10
11static int pEII_request(struct datalink_proto *dl,
12 struct sk_buff *skb, unsigned char *dest_node)
13{
14 struct net_device *dev = skb->dev;
15
16 skb->protocol = htons(ETH_P_IPX);
17 dev_hard_header(skb, dev, ETH_P_IPX, dest_node, NULL, skb->len);
18 return dev_queue_xmit(skb);
19}
20
21struct datalink_proto *make_EII_client(void)
22{
23 struct datalink_proto *proto = kmalloc(sizeof(*proto), GFP_ATOMIC);
24
25 if (proto) {
26 proto->header_length = 0;
27 proto->request = pEII_request;
28 }
29
30 return proto;
31}
32
33void destroy_EII_client(struct datalink_proto *dl)
34{
35 kfree(dl);
36}
diff --git a/drivers/staging/ipx/sysctl_net_ipx.c b/drivers/staging/ipx/sysctl_net_ipx.c
deleted file mode 100644
index c3eef457db88..000000000000
--- a/drivers/staging/ipx/sysctl_net_ipx.c
+++ /dev/null
@@ -1,40 +0,0 @@
1// SPDX-License-Identifier: GPL-2.0
2/* -*- linux-c -*-
3 * sysctl_net_ipx.c: sysctl interface to net IPX subsystem.
4 *
5 * Begun April 1, 1996, Mike Shaver.
6 * Added /proc/sys/net/ipx directory entry (empty =) ). [MS]
7 * Added /proc/sys/net/ipx/ipx_pprop_broadcasting - acme March 4, 2001
8 */
9
10#include <linux/mm.h>
11#include <linux/sysctl.h>
12#include <net/net_namespace.h>
13#include <net/ipx.h>
14
15#ifndef CONFIG_SYSCTL
16#error This file should not be compiled without CONFIG_SYSCTL defined
17#endif
18
19static struct ctl_table ipx_table[] = {
20 {
21 .procname = "ipx_pprop_broadcasting",
22 .data = &sysctl_ipx_pprop_broadcasting,
23 .maxlen = sizeof(int),
24 .mode = 0644,
25 .proc_handler = proc_dointvec,
26 },
27 { },
28};
29
30static struct ctl_table_header *ipx_table_header;
31
32void ipx_register_sysctl(void)
33{
34 ipx_table_header = register_net_sysctl(&init_net, "net/ipx", ipx_table);
35}
36
37void ipx_unregister_sysctl(void)
38{
39 unregister_net_sysctl_table(ipx_table_header);
40}
generated by cgit v1.2.2 (git 2.25.0) at 2025-08-28 22:18:08 -0400