2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
|
|
|
|
* Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
|
|
|
|
* Copyright (C) Terry Dawson VK2KTJ (terry@animats.net)
|
|
|
|
* Copyright (C) Tomi Manninen OH2BNS (oh2bns@sral.fi)
|
|
|
|
*/
|
2006-01-12 03:17:47 +07:00
|
|
|
|
|
|
|
#include <linux/capability.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/socket.h>
|
|
|
|
#include <linux/in.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 15:04:11 +07:00
|
|
|
#include <linux/slab.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/kernel.h>
|
2017-02-09 00:51:30 +07:00
|
|
|
#include <linux/sched/signal.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/sockios.h>
|
|
|
|
#include <linux/net.h>
|
|
|
|
#include <linux/stat.h>
|
2007-09-12 17:01:34 +07:00
|
|
|
#include <net/net_namespace.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <net/ax25.h>
|
|
|
|
#include <linux/inet.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/if_arp.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <net/sock.h>
|
2016-12-25 02:46:01 +07:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/fcntl.h>
|
|
|
|
#include <linux/termios.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/notifier.h>
|
|
|
|
#include <net/rose.h>
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/seq_file.h>
|
2005-08-10 10:08:28 +07:00
|
|
|
#include <net/tcp_states.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <net/ip.h>
|
|
|
|
#include <net/arp.h>
|
|
|
|
|
|
|
|
static int rose_ndevs = 10;
|
|
|
|
|
|
|
|
int sysctl_rose_restart_request_timeout = ROSE_DEFAULT_T0;
|
|
|
|
int sysctl_rose_call_request_timeout = ROSE_DEFAULT_T1;
|
|
|
|
int sysctl_rose_reset_request_timeout = ROSE_DEFAULT_T2;
|
|
|
|
int sysctl_rose_clear_request_timeout = ROSE_DEFAULT_T3;
|
|
|
|
int sysctl_rose_no_activity_timeout = ROSE_DEFAULT_IDLE;
|
|
|
|
int sysctl_rose_ack_hold_back_timeout = ROSE_DEFAULT_HB;
|
|
|
|
int sysctl_rose_routing_control = ROSE_DEFAULT_ROUTING;
|
|
|
|
int sysctl_rose_link_fail_timeout = ROSE_DEFAULT_FAIL_TIMEOUT;
|
|
|
|
int sysctl_rose_maximum_vcs = ROSE_DEFAULT_MAXVC;
|
|
|
|
int sysctl_rose_window_size = ROSE_DEFAULT_WINDOW_SIZE;
|
|
|
|
|
|
|
|
static HLIST_HEAD(rose_list);
|
|
|
|
static DEFINE_SPINLOCK(rose_list_lock);
|
|
|
|
|
2009-09-14 19:23:23 +07:00
|
|
|
static const struct proto_ops rose_proto_ops;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
ax25_address rose_callsign;
|
|
|
|
|
2006-07-13 03:25:56 +07:00
|
|
|
/*
|
|
|
|
* ROSE network devices are virtual network devices encapsulating ROSE
|
|
|
|
* frames into AX.25 which will be sent through an AX.25 device, so form a
|
|
|
|
* special "super class" of normal net devices; split their locks off into a
|
|
|
|
* separate class since they always nest.
|
|
|
|
*/
|
|
|
|
static struct lock_class_key rose_netdev_xmit_lock_key;
|
2008-07-23 04:16:42 +07:00
|
|
|
static struct lock_class_key rose_netdev_addr_lock_key;
|
2006-07-13 03:25:56 +07:00
|
|
|
|
2008-07-17 14:34:19 +07:00
|
|
|
static void rose_set_lockdep_one(struct net_device *dev,
|
|
|
|
struct netdev_queue *txq,
|
|
|
|
void *_unused)
|
2008-07-09 13:13:53 +07:00
|
|
|
{
|
|
|
|
lockdep_set_class(&txq->_xmit_lock, &rose_netdev_xmit_lock_key);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rose_set_lockdep_key(struct net_device *dev)
|
|
|
|
{
|
2008-07-23 04:16:42 +07:00
|
|
|
lockdep_set_class(&dev->addr_list_lock, &rose_netdev_addr_lock_key);
|
2008-07-17 14:34:19 +07:00
|
|
|
netdev_for_each_tx_queue(dev, rose_set_lockdep_one, NULL);
|
2008-07-09 13:13:53 +07:00
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Convert a ROSE address into text.
|
|
|
|
*/
|
2009-07-27 09:11:14 +07:00
|
|
|
char *rose2asc(char *buf, const rose_address *addr)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
if (addr->rose_addr[0] == 0x00 && addr->rose_addr[1] == 0x00 &&
|
|
|
|
addr->rose_addr[2] == 0x00 && addr->rose_addr[3] == 0x00 &&
|
|
|
|
addr->rose_addr[4] == 0x00) {
|
2009-07-27 09:11:14 +07:00
|
|
|
strcpy(buf, "*");
|
2005-04-17 05:20:36 +07:00
|
|
|
} else {
|
2009-07-27 09:11:14 +07:00
|
|
|
sprintf(buf, "%02X%02X%02X%02X%02X", addr->rose_addr[0] & 0xFF,
|
2005-04-17 05:20:36 +07:00
|
|
|
addr->rose_addr[1] & 0xFF,
|
|
|
|
addr->rose_addr[2] & 0xFF,
|
|
|
|
addr->rose_addr[3] & 0xFF,
|
|
|
|
addr->rose_addr[4] & 0xFF);
|
|
|
|
}
|
|
|
|
|
2009-07-27 09:11:14 +07:00
|
|
|
return buf;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compare two ROSE addresses, 0 == equal.
|
|
|
|
*/
|
|
|
|
int rosecmp(rose_address *addr1, rose_address *addr2)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < 5; i++)
|
|
|
|
if (addr1->rose_addr[i] != addr2->rose_addr[i])
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compare two ROSE addresses for only mask digits, 0 == equal.
|
|
|
|
*/
|
|
|
|
int rosecmpm(rose_address *addr1, rose_address *addr2, unsigned short mask)
|
|
|
|
{
|
2008-01-15 18:30:35 +07:00
|
|
|
unsigned int i, j;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (mask > 10)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
for (i = 0; i < mask; i++) {
|
|
|
|
j = i / 2;
|
|
|
|
|
|
|
|
if ((i % 2) != 0) {
|
|
|
|
if ((addr1->rose_addr[j] & 0x0F) != (addr2->rose_addr[j] & 0x0F))
|
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
if ((addr1->rose_addr[j] & 0xF0) != (addr2->rose_addr[j] & 0xF0))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Socket removal during an interrupt is now safe.
|
|
|
|
*/
|
|
|
|
static void rose_remove_socket(struct sock *sk)
|
|
|
|
{
|
|
|
|
spin_lock_bh(&rose_list_lock);
|
|
|
|
sk_del_node_init(sk);
|
|
|
|
spin_unlock_bh(&rose_list_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Kill all bound sockets on a broken link layer connection to a
|
|
|
|
* particular neighbour.
|
|
|
|
*/
|
|
|
|
void rose_kill_by_neigh(struct rose_neigh *neigh)
|
|
|
|
{
|
|
|
|
struct sock *s;
|
|
|
|
|
|
|
|
spin_lock_bh(&rose_list_lock);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:06:00 +07:00
|
|
|
sk_for_each(s, &rose_list) {
|
2005-04-17 05:20:36 +07:00
|
|
|
struct rose_sock *rose = rose_sk(s);
|
|
|
|
|
|
|
|
if (rose->neighbour == neigh) {
|
|
|
|
rose_disconnect(s, ENETUNREACH, ROSE_OUT_OF_ORDER, 0);
|
|
|
|
rose->neighbour->use--;
|
|
|
|
rose->neighbour = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&rose_list_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Kill all bound sockets on a dropped device.
|
|
|
|
*/
|
|
|
|
static void rose_kill_by_device(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct sock *s;
|
|
|
|
|
|
|
|
spin_lock_bh(&rose_list_lock);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:06:00 +07:00
|
|
|
sk_for_each(s, &rose_list) {
|
2005-04-17 05:20:36 +07:00
|
|
|
struct rose_sock *rose = rose_sk(s);
|
|
|
|
|
|
|
|
if (rose->device == dev) {
|
|
|
|
rose_disconnect(s, ENETUNREACH, ROSE_OUT_OF_ORDER, 0);
|
2015-06-19 05:46:53 +07:00
|
|
|
if (rose->neighbour)
|
|
|
|
rose->neighbour->use--;
|
2005-04-17 05:20:36 +07:00
|
|
|
rose->device = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&rose_list_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle device status changes.
|
|
|
|
*/
|
2013-05-28 08:30:21 +07:00
|
|
|
static int rose_device_event(struct notifier_block *this,
|
|
|
|
unsigned long event, void *ptr)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2013-05-28 08:30:21 +07:00
|
|
|
struct net_device *dev = netdev_notifier_info_to_dev(ptr);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-07-20 12:34:43 +07:00
|
|
|
if (!net_eq(dev_net(dev), &init_net))
|
2007-09-12 18:02:17 +07:00
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (event != NETDEV_DOWN)
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
|
|
|
switch (dev->type) {
|
|
|
|
case ARPHRD_ROSE:
|
|
|
|
rose_kill_by_device(dev);
|
|
|
|
break;
|
|
|
|
case ARPHRD_AX25:
|
|
|
|
rose_link_device_down(dev);
|
|
|
|
rose_rt_device_down(dev);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add a socket to the bound sockets list.
|
|
|
|
*/
|
|
|
|
static void rose_insert_socket(struct sock *sk)
|
|
|
|
{
|
|
|
|
|
|
|
|
spin_lock_bh(&rose_list_lock);
|
|
|
|
sk_add_node(sk, &rose_list);
|
|
|
|
spin_unlock_bh(&rose_list_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find a socket that wants to accept the Call Request we just
|
|
|
|
* received.
|
|
|
|
*/
|
|
|
|
static struct sock *rose_find_listener(rose_address *addr, ax25_address *call)
|
|
|
|
{
|
|
|
|
struct sock *s;
|
|
|
|
|
|
|
|
spin_lock_bh(&rose_list_lock);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:06:00 +07:00
|
|
|
sk_for_each(s, &rose_list) {
|
2005-04-17 05:20:36 +07:00
|
|
|
struct rose_sock *rose = rose_sk(s);
|
|
|
|
|
|
|
|
if (!rosecmp(&rose->source_addr, addr) &&
|
|
|
|
!ax25cmp(&rose->source_call, call) &&
|
|
|
|
!rose->source_ndigis && s->sk_state == TCP_LISTEN)
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:06:00 +07:00
|
|
|
sk_for_each(s, &rose_list) {
|
2005-04-17 05:20:36 +07:00
|
|
|
struct rose_sock *rose = rose_sk(s);
|
|
|
|
|
|
|
|
if (!rosecmp(&rose->source_addr, addr) &&
|
|
|
|
!ax25cmp(&rose->source_call, &null_ax25_address) &&
|
|
|
|
s->sk_state == TCP_LISTEN)
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
s = NULL;
|
|
|
|
found:
|
|
|
|
spin_unlock_bh(&rose_list_lock);
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find a connected ROSE socket given my LCI and device.
|
|
|
|
*/
|
|
|
|
struct sock *rose_find_socket(unsigned int lci, struct rose_neigh *neigh)
|
|
|
|
{
|
|
|
|
struct sock *s;
|
|
|
|
|
|
|
|
spin_lock_bh(&rose_list_lock);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:06:00 +07:00
|
|
|
sk_for_each(s, &rose_list) {
|
2005-04-17 05:20:36 +07:00
|
|
|
struct rose_sock *rose = rose_sk(s);
|
|
|
|
|
|
|
|
if (rose->lci == lci && rose->neighbour == neigh)
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
s = NULL;
|
|
|
|
found:
|
|
|
|
spin_unlock_bh(&rose_list_lock);
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find a unique LCI for a given device.
|
|
|
|
*/
|
|
|
|
unsigned int rose_new_lci(struct rose_neigh *neigh)
|
|
|
|
{
|
|
|
|
int lci;
|
|
|
|
|
|
|
|
if (neigh->dce_mode) {
|
|
|
|
for (lci = 1; lci <= sysctl_rose_maximum_vcs; lci++)
|
|
|
|
if (rose_find_socket(lci, neigh) == NULL && rose_route_free_lci(lci, neigh) == NULL)
|
|
|
|
return lci;
|
|
|
|
} else {
|
|
|
|
for (lci = sysctl_rose_maximum_vcs; lci > 0; lci--)
|
|
|
|
if (rose_find_socket(lci, neigh) == NULL && rose_route_free_lci(lci, neigh) == NULL)
|
|
|
|
return lci;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Deferred destroy.
|
|
|
|
*/
|
|
|
|
void rose_destroy_socket(struct sock *);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handler for deferred kills.
|
|
|
|
*/
|
2017-10-17 07:28:47 +07:00
|
|
|
static void rose_destroy_timer(struct timer_list *t)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2017-10-17 07:28:47 +07:00
|
|
|
struct sock *sk = from_timer(sk, t, sk_timer);
|
|
|
|
|
|
|
|
rose_destroy_socket(sk);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is called from user mode and the timers. Thus it protects itself
|
|
|
|
* against interrupt users but doesn't worry about being called during
|
|
|
|
* work. Once it is removed from the queue no interrupt or bottom half
|
|
|
|
* will touch it and we are (fairly 8-) ) safe.
|
|
|
|
*/
|
|
|
|
void rose_destroy_socket(struct sock *sk)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
|
|
|
rose_remove_socket(sk);
|
|
|
|
rose_stop_heartbeat(sk);
|
|
|
|
rose_stop_idletimer(sk);
|
|
|
|
rose_stop_timer(sk);
|
|
|
|
|
|
|
|
rose_clear_queues(sk); /* Flush the queues */
|
|
|
|
|
|
|
|
while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
|
|
|
|
if (skb->sk != sk) { /* A pending connection */
|
|
|
|
/* Queue the unaccepted socket for death */
|
|
|
|
sock_set_flag(skb->sk, SOCK_DEAD);
|
|
|
|
rose_start_heartbeat(skb->sk);
|
|
|
|
rose_sk(skb->sk)->state = ROSE_STATE_0;
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree_skb(skb);
|
|
|
|
}
|
|
|
|
|
2009-06-16 17:12:03 +07:00
|
|
|
if (sk_has_allocations(sk)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Defer: outstanding buffers */
|
2017-10-17 07:28:47 +07:00
|
|
|
timer_setup(&sk->sk_timer, rose_destroy_timer, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
sk->sk_timer.expires = jiffies + 10 * HZ;
|
|
|
|
add_timer(&sk->sk_timer);
|
|
|
|
} else
|
|
|
|
sock_put(sk);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handling for system calls applied via the various interfaces to a
|
|
|
|
* ROSE socket object.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int rose_setsockopt(struct socket *sock, int level, int optname,
|
2009-10-01 06:12:20 +07:00
|
|
|
char __user *optval, unsigned int optlen)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct sock *sk = sock->sk;
|
|
|
|
struct rose_sock *rose = rose_sk(sk);
|
|
|
|
int opt;
|
|
|
|
|
|
|
|
if (level != SOL_ROSE)
|
|
|
|
return -ENOPROTOOPT;
|
|
|
|
|
|
|
|
if (optlen < sizeof(int))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (get_user(opt, (int __user *)optval))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
switch (optname) {
|
|
|
|
case ROSE_DEFER:
|
|
|
|
rose->defer = opt ? 1 : 0;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case ROSE_T1:
|
|
|
|
if (opt < 1)
|
|
|
|
return -EINVAL;
|
|
|
|
rose->t1 = opt * HZ;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case ROSE_T2:
|
|
|
|
if (opt < 1)
|
|
|
|
return -EINVAL;
|
|
|
|
rose->t2 = opt * HZ;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case ROSE_T3:
|
|
|
|
if (opt < 1)
|
|
|
|
return -EINVAL;
|
|
|
|
rose->t3 = opt * HZ;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case ROSE_HOLDBACK:
|
|
|
|
if (opt < 1)
|
|
|
|
return -EINVAL;
|
|
|
|
rose->hb = opt * HZ;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case ROSE_IDLE:
|
|
|
|
if (opt < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
rose->idle = opt * 60 * HZ;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case ROSE_QBITINCL:
|
|
|
|
rose->qbitincl = opt ? 1 : 0;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -ENOPROTOOPT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rose_getsockopt(struct socket *sock, int level, int optname,
|
|
|
|
char __user *optval, int __user *optlen)
|
|
|
|
{
|
|
|
|
struct sock *sk = sock->sk;
|
|
|
|
struct rose_sock *rose = rose_sk(sk);
|
|
|
|
int val = 0;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (level != SOL_ROSE)
|
|
|
|
return -ENOPROTOOPT;
|
|
|
|
|
|
|
|
if (get_user(len, optlen))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
if (len < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
switch (optname) {
|
|
|
|
case ROSE_DEFER:
|
|
|
|
val = rose->defer;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ROSE_T1:
|
|
|
|
val = rose->t1 / HZ;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ROSE_T2:
|
|
|
|
val = rose->t2 / HZ;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ROSE_T3:
|
|
|
|
val = rose->t3 / HZ;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ROSE_HOLDBACK:
|
|
|
|
val = rose->hb / HZ;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ROSE_IDLE:
|
|
|
|
val = rose->idle / (60 * HZ);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ROSE_QBITINCL:
|
|
|
|
val = rose->qbitincl;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -ENOPROTOOPT;
|
|
|
|
}
|
|
|
|
|
|
|
|
len = min_t(unsigned int, len, sizeof(int));
|
|
|
|
|
|
|
|
if (put_user(len, optlen))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
return copy_to_user(optval, &val, len) ? -EFAULT : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rose_listen(struct socket *sock, int backlog)
|
|
|
|
{
|
|
|
|
struct sock *sk = sock->sk;
|
|
|
|
|
|
|
|
if (sk->sk_state != TCP_LISTEN) {
|
|
|
|
struct rose_sock *rose = rose_sk(sk);
|
|
|
|
|
|
|
|
rose->dest_ndigis = 0;
|
|
|
|
memset(&rose->dest_addr, 0, ROSE_ADDR_LEN);
|
|
|
|
memset(&rose->dest_call, 0, AX25_ADDR_LEN);
|
|
|
|
memset(rose->dest_digis, 0, AX25_ADDR_LEN * ROSE_MAX_DIGIS);
|
|
|
|
sk->sk_max_ack_backlog = backlog;
|
|
|
|
sk->sk_state = TCP_LISTEN;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct proto rose_proto = {
|
|
|
|
.name = "ROSE",
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.obj_size = sizeof(struct rose_sock),
|
|
|
|
};
|
|
|
|
|
2009-11-06 13:18:14 +07:00
|
|
|
static int rose_create(struct net *net, struct socket *sock, int protocol,
|
|
|
|
int kern)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct sock *sk;
|
|
|
|
struct rose_sock *rose;
|
|
|
|
|
2009-11-26 06:14:13 +07:00
|
|
|
if (!net_eq(net, &init_net))
|
2007-10-09 13:24:22 +07:00
|
|
|
return -EAFNOSUPPORT;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (sock->type != SOCK_SEQPACKET || protocol != 0)
|
|
|
|
return -ESOCKTNOSUPPORT;
|
|
|
|
|
2015-05-09 09:09:13 +07:00
|
|
|
sk = sk_alloc(net, PF_ROSE, GFP_ATOMIC, &rose_proto, kern);
|
2007-11-01 14:39:31 +07:00
|
|
|
if (sk == NULL)
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
rose = rose_sk(sk);
|
|
|
|
|
|
|
|
sock_init_data(sock, sk);
|
|
|
|
|
|
|
|
skb_queue_head_init(&rose->ack_queue);
|
|
|
|
#ifdef M_BIT
|
|
|
|
skb_queue_head_init(&rose->frag_queue);
|
|
|
|
rose->fraglen = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
sock->ops = &rose_proto_ops;
|
|
|
|
sk->sk_protocol = protocol;
|
|
|
|
|
2017-10-17 07:28:47 +07:00
|
|
|
timer_setup(&rose->timer, NULL, 0);
|
|
|
|
timer_setup(&rose->idletimer, NULL, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-05-04 13:28:20 +07:00
|
|
|
rose->t1 = msecs_to_jiffies(sysctl_rose_call_request_timeout);
|
|
|
|
rose->t2 = msecs_to_jiffies(sysctl_rose_reset_request_timeout);
|
|
|
|
rose->t3 = msecs_to_jiffies(sysctl_rose_clear_request_timeout);
|
|
|
|
rose->hb = msecs_to_jiffies(sysctl_rose_ack_hold_back_timeout);
|
|
|
|
rose->idle = msecs_to_jiffies(sysctl_rose_no_activity_timeout);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
rose->state = ROSE_STATE_0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct sock *rose_make_new(struct sock *osk)
|
|
|
|
{
|
|
|
|
struct sock *sk;
|
|
|
|
struct rose_sock *rose, *orose;
|
|
|
|
|
|
|
|
if (osk->sk_type != SOCK_SEQPACKET)
|
|
|
|
return NULL;
|
|
|
|
|
2015-05-09 09:09:13 +07:00
|
|
|
sk = sk_alloc(sock_net(osk), PF_ROSE, GFP_ATOMIC, &rose_proto, 0);
|
2007-11-01 14:39:31 +07:00
|
|
|
if (sk == NULL)
|
2005-04-17 05:20:36 +07:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
rose = rose_sk(sk);
|
|
|
|
|
|
|
|
sock_init_data(NULL, sk);
|
|
|
|
|
|
|
|
skb_queue_head_init(&rose->ack_queue);
|
|
|
|
#ifdef M_BIT
|
|
|
|
skb_queue_head_init(&rose->frag_queue);
|
|
|
|
rose->fraglen = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
sk->sk_type = osk->sk_type;
|
|
|
|
sk->sk_priority = osk->sk_priority;
|
|
|
|
sk->sk_protocol = osk->sk_protocol;
|
|
|
|
sk->sk_rcvbuf = osk->sk_rcvbuf;
|
|
|
|
sk->sk_sndbuf = osk->sk_sndbuf;
|
|
|
|
sk->sk_state = TCP_ESTABLISHED;
|
2005-08-24 00:11:30 +07:00
|
|
|
sock_copy_flags(sk, osk);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2017-10-17 07:28:47 +07:00
|
|
|
timer_setup(&rose->timer, NULL, 0);
|
|
|
|
timer_setup(&rose->idletimer, NULL, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
orose = rose_sk(osk);
|
|
|
|
rose->t1 = orose->t1;
|
|
|
|
rose->t2 = orose->t2;
|
|
|
|
rose->t3 = orose->t3;
|
|
|
|
rose->hb = orose->hb;
|
|
|
|
rose->idle = orose->idle;
|
|
|
|
rose->defer = orose->defer;
|
|
|
|
rose->device = orose->device;
|
|
|
|
rose->qbitincl = orose->qbitincl;
|
|
|
|
|
|
|
|
return sk;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rose_release(struct socket *sock)
|
|
|
|
{
|
|
|
|
struct sock *sk = sock->sk;
|
|
|
|
struct rose_sock *rose;
|
|
|
|
|
|
|
|
if (sk == NULL) return 0;
|
|
|
|
|
2008-04-02 13:56:17 +07:00
|
|
|
sock_hold(sk);
|
|
|
|
sock_orphan(sk);
|
|
|
|
lock_sock(sk);
|
2005-04-17 05:20:36 +07:00
|
|
|
rose = rose_sk(sk);
|
|
|
|
|
|
|
|
switch (rose->state) {
|
|
|
|
case ROSE_STATE_0:
|
2008-04-02 13:56:17 +07:00
|
|
|
release_sock(sk);
|
2005-04-17 05:20:36 +07:00
|
|
|
rose_disconnect(sk, 0, -1, -1);
|
2008-04-02 13:56:17 +07:00
|
|
|
lock_sock(sk);
|
2005-04-17 05:20:36 +07:00
|
|
|
rose_destroy_socket(sk);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ROSE_STATE_2:
|
|
|
|
rose->neighbour->use--;
|
2008-04-02 13:56:17 +07:00
|
|
|
release_sock(sk);
|
2005-04-17 05:20:36 +07:00
|
|
|
rose_disconnect(sk, 0, -1, -1);
|
2008-04-02 13:56:17 +07:00
|
|
|
lock_sock(sk);
|
2005-04-17 05:20:36 +07:00
|
|
|
rose_destroy_socket(sk);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ROSE_STATE_1:
|
|
|
|
case ROSE_STATE_3:
|
|
|
|
case ROSE_STATE_4:
|
|
|
|
case ROSE_STATE_5:
|
|
|
|
rose_clear_queues(sk);
|
|
|
|
rose_stop_idletimer(sk);
|
|
|
|
rose_write_internal(sk, ROSE_CLEAR_REQUEST);
|
|
|
|
rose_start_t3timer(sk);
|
|
|
|
rose->state = ROSE_STATE_2;
|
|
|
|
sk->sk_state = TCP_CLOSE;
|
|
|
|
sk->sk_shutdown |= SEND_SHUTDOWN;
|
|
|
|
sk->sk_state_change(sk);
|
|
|
|
sock_set_flag(sk, SOCK_DEAD);
|
|
|
|
sock_set_flag(sk, SOCK_DESTROY);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
sock->sk = NULL;
|
2008-04-02 13:56:17 +07:00
|
|
|
release_sock(sk);
|
|
|
|
sock_put(sk);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rose_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
|
|
|
|
{
|
|
|
|
struct sock *sk = sock->sk;
|
|
|
|
struct rose_sock *rose = rose_sk(sk);
|
|
|
|
struct sockaddr_rose *addr = (struct sockaddr_rose *)uaddr;
|
|
|
|
struct net_device *dev;
|
2005-08-24 00:11:45 +07:00
|
|
|
ax25_address *source;
|
|
|
|
ax25_uid_assoc *user;
|
2005-04-17 05:20:36 +07:00
|
|
|
int n;
|
|
|
|
|
|
|
|
if (!sock_flag(sk, SOCK_ZAPPED))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (addr_len != sizeof(struct sockaddr_rose) && addr_len != sizeof(struct full_sockaddr_rose))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (addr->srose_family != AF_ROSE)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (addr_len == sizeof(struct sockaddr_rose) && addr->srose_ndigis > 1)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-09-21 05:40:35 +07:00
|
|
|
if ((unsigned int) addr->srose_ndigis > ROSE_MAX_DIGIS)
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2011-04-14 14:20:07 +07:00
|
|
|
if ((dev = rose_dev_get(&addr->srose_addr)) == NULL)
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
|
|
|
|
source = &addr->srose_call;
|
|
|
|
|
2008-11-14 06:39:08 +07:00
|
|
|
user = ax25_findbyuid(current_euid());
|
2005-08-24 00:11:45 +07:00
|
|
|
if (user) {
|
|
|
|
rose->source_call = user->call;
|
|
|
|
ax25_uid_put(user);
|
|
|
|
} else {
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ax25_uid_policy && !capable(CAP_NET_BIND_SERVICE))
|
|
|
|
return -EACCES;
|
2005-08-24 00:11:45 +07:00
|
|
|
rose->source_call = *source;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
rose->source_addr = addr->srose_addr;
|
|
|
|
rose->device = dev;
|
|
|
|
rose->source_ndigis = addr->srose_ndigis;
|
|
|
|
|
|
|
|
if (addr_len == sizeof(struct full_sockaddr_rose)) {
|
|
|
|
struct full_sockaddr_rose *full_addr = (struct full_sockaddr_rose *)uaddr;
|
|
|
|
for (n = 0 ; n < addr->srose_ndigis ; n++)
|
|
|
|
rose->source_digis[n] = full_addr->srose_digis[n];
|
|
|
|
} else {
|
|
|
|
if (rose->source_ndigis == 1) {
|
|
|
|
rose->source_digis[0] = addr->srose_digi;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
rose_insert_socket(sk);
|
|
|
|
|
|
|
|
sock_reset_flag(sk, SOCK_ZAPPED);
|
2011-04-14 14:20:07 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rose_connect(struct socket *sock, struct sockaddr *uaddr, int addr_len, int flags)
|
|
|
|
{
|
|
|
|
struct sock *sk = sock->sk;
|
|
|
|
struct rose_sock *rose = rose_sk(sk);
|
|
|
|
struct sockaddr_rose *addr = (struct sockaddr_rose *)uaddr;
|
|
|
|
unsigned char cause, diagnostic;
|
|
|
|
struct net_device *dev;
|
2005-08-24 00:11:45 +07:00
|
|
|
ax25_uid_assoc *user;
|
2007-03-13 05:53:33 +07:00
|
|
|
int n, err = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (addr_len != sizeof(struct sockaddr_rose) && addr_len != sizeof(struct full_sockaddr_rose))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (addr->srose_family != AF_ROSE)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (addr_len == sizeof(struct sockaddr_rose) && addr->srose_ndigis > 1)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-09-21 05:40:35 +07:00
|
|
|
if ((unsigned int) addr->srose_ndigis > ROSE_MAX_DIGIS)
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* Source + Destination digis should not exceed ROSE_MAX_DIGIS */
|
|
|
|
if ((rose->source_ndigis + addr->srose_ndigis) > ROSE_MAX_DIGIS)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2007-03-13 05:53:33 +07:00
|
|
|
lock_sock(sk);
|
|
|
|
|
|
|
|
if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
|
|
|
|
/* Connect completed during a ERESTARTSYS event */
|
|
|
|
sock->state = SS_CONNECTED;
|
|
|
|
goto out_release;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) {
|
|
|
|
sock->state = SS_UNCONNECTED;
|
|
|
|
err = -ECONNREFUSED;
|
|
|
|
goto out_release;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sk->sk_state == TCP_ESTABLISHED) {
|
|
|
|
/* No reconnect on a seqpacket socket */
|
|
|
|
err = -EISCONN;
|
|
|
|
goto out_release;
|
|
|
|
}
|
|
|
|
|
|
|
|
sk->sk_state = TCP_CLOSE;
|
|
|
|
sock->state = SS_UNCONNECTED;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
rose->neighbour = rose_get_neigh(&addr->srose_addr, &cause,
|
rose: improving AX25 routing frames via ROSE network
ROSE network is organized through nodes connected via hamradio or Internet.
AX25 packet radio frames sent to a remote ROSE address destination are routed
through these nodes.
Without the present patch, automatic routing mechanism did not work optimally
due to an improper parameter checking.
rose_get_neigh() function is called either by rose_connect() or by
rose_route_frame().
In the case of a call from rose_connect(), f0 timer is checked to find if a connection
is already pending. In that case it returns the address of the neighbour, or returns a NULL otherwise.
When called by rose_route_frame() the purpose was to route a packet AX25 frame
through an adjacent node given a destination rose address.
However, in that case, t0 timer checked does not indicate if the adjacent node
is actually connected even if the timer is not null. Thus, for each frame sent, the
function often tried to start a new connexion even if the adjacent node was already connected.
The patch adds a "new" parameter that is true when the function is called by
rose route_frame().
This instructs rose_get_neigh() to check node parameter "restarted".
If restarted is true it means that the route to the destination address is opened via a neighbour
node already connected.
If "restarted" is false the function returns a NULL.
In that case the calling function will initiate a new connection as before.
This results in a fast routing of frames, from nodes to nodes, until
destination is reached, as originaly specified by ROSE protocole.
Signed-off-by: Bernard Pidoux <f6bvp@amsat.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-06-18 07:08:32 +07:00
|
|
|
&diagnostic, 0);
|
2008-04-20 08:41:51 +07:00
|
|
|
if (!rose->neighbour) {
|
|
|
|
err = -ENETUNREACH;
|
|
|
|
goto out_release;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
rose->lci = rose_new_lci(rose->neighbour);
|
2007-03-13 05:53:33 +07:00
|
|
|
if (!rose->lci) {
|
|
|
|
err = -ENETUNREACH;
|
|
|
|
goto out_release;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (sock_flag(sk, SOCK_ZAPPED)) { /* Must bind first - autobinding in this may or may not work */
|
|
|
|
sock_reset_flag(sk, SOCK_ZAPPED);
|
|
|
|
|
2007-03-13 05:53:33 +07:00
|
|
|
if ((dev = rose_dev_first()) == NULL) {
|
|
|
|
err = -ENETUNREACH;
|
|
|
|
goto out_release;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-11-14 06:39:08 +07:00
|
|
|
user = ax25_findbyuid(current_euid());
|
2007-03-13 05:53:33 +07:00
|
|
|
if (!user) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out_release;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
memcpy(&rose->source_addr, dev->dev_addr, ROSE_ADDR_LEN);
|
2005-08-24 00:11:45 +07:00
|
|
|
rose->source_call = user->call;
|
2005-04-17 05:20:36 +07:00
|
|
|
rose->device = dev;
|
2005-08-24 00:11:45 +07:00
|
|
|
ax25_uid_put(user);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
rose_insert_socket(sk); /* Finish the bind */
|
|
|
|
}
|
|
|
|
rose->dest_addr = addr->srose_addr;
|
|
|
|
rose->dest_call = addr->srose_call;
|
|
|
|
rose->rand = ((long)rose & 0xFFFF) + rose->lci;
|
|
|
|
rose->dest_ndigis = addr->srose_ndigis;
|
|
|
|
|
|
|
|
if (addr_len == sizeof(struct full_sockaddr_rose)) {
|
|
|
|
struct full_sockaddr_rose *full_addr = (struct full_sockaddr_rose *)uaddr;
|
|
|
|
for (n = 0 ; n < addr->srose_ndigis ; n++)
|
|
|
|
rose->dest_digis[n] = full_addr->srose_digis[n];
|
|
|
|
} else {
|
|
|
|
if (rose->dest_ndigis == 1) {
|
|
|
|
rose->dest_digis[0] = addr->srose_digi;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Move to connecting socket, start sending Connect Requests */
|
|
|
|
sock->state = SS_CONNECTING;
|
|
|
|
sk->sk_state = TCP_SYN_SENT;
|
|
|
|
|
|
|
|
rose->state = ROSE_STATE_1;
|
|
|
|
|
|
|
|
rose->neighbour->use++;
|
|
|
|
|
|
|
|
rose_write_internal(sk, ROSE_CALL_REQUEST);
|
|
|
|
rose_start_heartbeat(sk);
|
|
|
|
rose_start_t1timer(sk);
|
|
|
|
|
|
|
|
/* Now the loop */
|
2007-03-13 05:53:33 +07:00
|
|
|
if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
|
|
|
|
err = -EINPROGRESS;
|
|
|
|
goto out_release;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* A Connect Ack with Choke or timeout or failed routing will go to
|
|
|
|
* closed.
|
|
|
|
*/
|
|
|
|
if (sk->sk_state == TCP_SYN_SENT) {
|
2007-04-21 06:06:45 +07:00
|
|
|
DEFINE_WAIT(wait);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
for (;;) {
|
2010-04-20 20:03:51 +07:00
|
|
|
prepare_to_wait(sk_sleep(sk), &wait,
|
2007-07-19 08:44:40 +07:00
|
|
|
TASK_INTERRUPTIBLE);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (sk->sk_state != TCP_SYN_SENT)
|
|
|
|
break;
|
2007-04-21 06:06:45 +07:00
|
|
|
if (!signal_pending(current)) {
|
|
|
|
release_sock(sk);
|
2005-04-17 05:20:36 +07:00
|
|
|
schedule();
|
2007-03-13 05:53:33 +07:00
|
|
|
lock_sock(sk);
|
2005-04-17 05:20:36 +07:00
|
|
|
continue;
|
|
|
|
}
|
2007-04-21 06:06:45 +07:00
|
|
|
err = -ERESTARTSYS;
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2010-04-20 20:03:51 +07:00
|
|
|
finish_wait(sk_sleep(sk), &wait);
|
2007-04-21 06:06:45 +07:00
|
|
|
|
|
|
|
if (err)
|
|
|
|
goto out_release;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (sk->sk_state != TCP_ESTABLISHED) {
|
|
|
|
sock->state = SS_UNCONNECTED;
|
2007-03-13 05:53:33 +07:00
|
|
|
err = sock_error(sk); /* Always set at this point */
|
|
|
|
goto out_release;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
sock->state = SS_CONNECTED;
|
|
|
|
|
2007-03-13 05:53:33 +07:00
|
|
|
out_release:
|
|
|
|
release_sock(sk);
|
|
|
|
|
|
|
|
return err;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2017-03-09 15:09:05 +07:00
|
|
|
static int rose_accept(struct socket *sock, struct socket *newsock, int flags,
|
|
|
|
bool kern)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct sock *newsk;
|
2007-04-21 06:06:45 +07:00
|
|
|
DEFINE_WAIT(wait);
|
2005-04-17 05:20:36 +07:00
|
|
|
struct sock *sk;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
if ((sk = sock->sk) == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
lock_sock(sk);
|
|
|
|
if (sk->sk_type != SOCK_SEQPACKET) {
|
|
|
|
err = -EOPNOTSUPP;
|
2007-04-21 06:06:45 +07:00
|
|
|
goto out_release;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (sk->sk_state != TCP_LISTEN) {
|
|
|
|
err = -EINVAL;
|
2007-04-21 06:06:45 +07:00
|
|
|
goto out_release;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The write queue this time is holding sockets ready to use
|
|
|
|
* hooked into the SABM we saved
|
|
|
|
*/
|
|
|
|
for (;;) {
|
2010-04-20 20:03:51 +07:00
|
|
|
prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
|
2007-04-21 06:06:45 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
skb = skb_dequeue(&sk->sk_receive_queue);
|
|
|
|
if (skb)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (flags & O_NONBLOCK) {
|
2007-04-21 06:06:45 +07:00
|
|
|
err = -EWOULDBLOCK;
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2007-04-21 06:06:45 +07:00
|
|
|
if (!signal_pending(current)) {
|
|
|
|
release_sock(sk);
|
2005-04-17 05:20:36 +07:00
|
|
|
schedule();
|
|
|
|
lock_sock(sk);
|
|
|
|
continue;
|
|
|
|
}
|
2007-04-21 06:06:45 +07:00
|
|
|
err = -ERESTARTSYS;
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2010-04-20 20:03:51 +07:00
|
|
|
finish_wait(sk_sleep(sk), &wait);
|
2007-04-21 06:06:45 +07:00
|
|
|
if (err)
|
|
|
|
goto out_release;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
newsk = skb->sk;
|
2008-06-17 16:39:21 +07:00
|
|
|
sock_graft(newsk, newsock);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Now attach up the new socket */
|
|
|
|
skb->sk = NULL;
|
|
|
|
kfree_skb(skb);
|
|
|
|
sk->sk_ack_backlog--;
|
|
|
|
|
2007-04-21 06:06:45 +07:00
|
|
|
out_release:
|
2005-04-17 05:20:36 +07:00
|
|
|
release_sock(sk);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rose_getname(struct socket *sock, struct sockaddr *uaddr,
|
2018-02-13 02:00:20 +07:00
|
|
|
int peer)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct full_sockaddr_rose *srose = (struct full_sockaddr_rose *)uaddr;
|
|
|
|
struct sock *sk = sock->sk;
|
|
|
|
struct rose_sock *rose = rose_sk(sk);
|
|
|
|
int n;
|
|
|
|
|
2009-08-06 10:34:06 +07:00
|
|
|
memset(srose, 0, sizeof(*srose));
|
2005-04-17 05:20:36 +07:00
|
|
|
if (peer != 0) {
|
|
|
|
if (sk->sk_state != TCP_ESTABLISHED)
|
|
|
|
return -ENOTCONN;
|
|
|
|
srose->srose_family = AF_ROSE;
|
|
|
|
srose->srose_addr = rose->dest_addr;
|
|
|
|
srose->srose_call = rose->dest_call;
|
|
|
|
srose->srose_ndigis = rose->dest_ndigis;
|
|
|
|
for (n = 0; n < rose->dest_ndigis; n++)
|
|
|
|
srose->srose_digis[n] = rose->dest_digis[n];
|
|
|
|
} else {
|
|
|
|
srose->srose_family = AF_ROSE;
|
|
|
|
srose->srose_addr = rose->source_addr;
|
|
|
|
srose->srose_call = rose->source_call;
|
|
|
|
srose->srose_ndigis = rose->source_ndigis;
|
|
|
|
for (n = 0; n < rose->source_ndigis; n++)
|
|
|
|
srose->srose_digis[n] = rose->source_digis[n];
|
|
|
|
}
|
|
|
|
|
2018-02-13 02:00:20 +07:00
|
|
|
return sizeof(struct full_sockaddr_rose);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
int rose_rx_call_request(struct sk_buff *skb, struct net_device *dev, struct rose_neigh *neigh, unsigned int lci)
|
|
|
|
{
|
|
|
|
struct sock *sk;
|
|
|
|
struct sock *make;
|
|
|
|
struct rose_sock *make_rose;
|
|
|
|
struct rose_facilities_struct facilities;
|
2011-03-20 13:48:05 +07:00
|
|
|
int n;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
skb->sk = NULL; /* Initially we don't know who it's for */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* skb->data points to the rose frame start
|
|
|
|
*/
|
|
|
|
memset(&facilities, 0x00, sizeof(struct rose_facilities_struct));
|
|
|
|
|
2011-03-20 13:48:05 +07:00
|
|
|
if (!rose_parse_facilities(skb->data + ROSE_CALL_REQ_FACILITIES_OFF,
|
|
|
|
skb->len - ROSE_CALL_REQ_FACILITIES_OFF,
|
|
|
|
&facilities)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
rose_transmit_clear_request(neigh, lci, ROSE_INVALID_FACILITY, 76);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
sk = rose_find_listener(&facilities.source_addr, &facilities.source_call);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We can't accept the Call Request.
|
|
|
|
*/
|
|
|
|
if (sk == NULL || sk_acceptq_is_full(sk) ||
|
|
|
|
(make = rose_make_new(sk)) == NULL) {
|
|
|
|
rose_transmit_clear_request(neigh, lci, ROSE_NETWORK_CONGESTION, 120);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
skb->sk = make;
|
|
|
|
make->sk_state = TCP_ESTABLISHED;
|
|
|
|
make_rose = rose_sk(make);
|
|
|
|
|
|
|
|
make_rose->lci = lci;
|
|
|
|
make_rose->dest_addr = facilities.dest_addr;
|
|
|
|
make_rose->dest_call = facilities.dest_call;
|
|
|
|
make_rose->dest_ndigis = facilities.dest_ndigis;
|
|
|
|
for (n = 0 ; n < facilities.dest_ndigis ; n++)
|
|
|
|
make_rose->dest_digis[n] = facilities.dest_digis[n];
|
|
|
|
make_rose->source_addr = facilities.source_addr;
|
|
|
|
make_rose->source_call = facilities.source_call;
|
|
|
|
make_rose->source_ndigis = facilities.source_ndigis;
|
|
|
|
for (n = 0 ; n < facilities.source_ndigis ; n++)
|
2013-12-19 10:55:17 +07:00
|
|
|
make_rose->source_digis[n] = facilities.source_digis[n];
|
2005-04-17 05:20:36 +07:00
|
|
|
make_rose->neighbour = neigh;
|
|
|
|
make_rose->device = dev;
|
|
|
|
make_rose->facilities = facilities;
|
|
|
|
|
|
|
|
make_rose->neighbour->use++;
|
|
|
|
|
|
|
|
if (rose_sk(sk)->defer) {
|
|
|
|
make_rose->state = ROSE_STATE_5;
|
|
|
|
} else {
|
|
|
|
rose_write_internal(make, ROSE_CALL_ACCEPTED);
|
|
|
|
make_rose->state = ROSE_STATE_3;
|
|
|
|
rose_start_idletimer(make);
|
|
|
|
}
|
|
|
|
|
|
|
|
make_rose->condition = 0x00;
|
|
|
|
make_rose->vs = 0;
|
|
|
|
make_rose->va = 0;
|
|
|
|
make_rose->vr = 0;
|
|
|
|
make_rose->vl = 0;
|
|
|
|
sk->sk_ack_backlog++;
|
|
|
|
|
|
|
|
rose_insert_socket(make);
|
|
|
|
|
|
|
|
skb_queue_head(&sk->sk_receive_queue, skb);
|
|
|
|
|
|
|
|
rose_start_heartbeat(make);
|
|
|
|
|
|
|
|
if (!sock_flag(sk, SOCK_DEAD))
|
2014-04-12 03:15:36 +07:00
|
|
|
sk->sk_data_ready(sk);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-03-02 14:37:48 +07:00
|
|
|
static int rose_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct sock *sk = sock->sk;
|
|
|
|
struct rose_sock *rose = rose_sk(sk);
|
2014-01-18 04:53:15 +07:00
|
|
|
DECLARE_SOCKADDR(struct sockaddr_rose *, usrose, msg->msg_name);
|
2005-04-17 05:20:36 +07:00
|
|
|
int err;
|
|
|
|
struct full_sockaddr_rose srose;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
unsigned char *asmptr;
|
|
|
|
int n, size, qbit = 0;
|
|
|
|
|
|
|
|
if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (sock_flag(sk, SOCK_ZAPPED))
|
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
|
|
|
|
if (sk->sk_shutdown & SEND_SHUTDOWN) {
|
|
|
|
send_sig(SIGPIPE, current, 0);
|
|
|
|
return -EPIPE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rose->neighbour == NULL || rose->device == NULL)
|
|
|
|
return -ENETUNREACH;
|
|
|
|
|
|
|
|
if (usrose != NULL) {
|
|
|
|
if (msg->msg_namelen != sizeof(struct sockaddr_rose) && msg->msg_namelen != sizeof(struct full_sockaddr_rose))
|
|
|
|
return -EINVAL;
|
|
|
|
memset(&srose, 0, sizeof(struct full_sockaddr_rose));
|
|
|
|
memcpy(&srose, usrose, msg->msg_namelen);
|
|
|
|
if (rosecmp(&rose->dest_addr, &srose.srose_addr) != 0 ||
|
|
|
|
ax25cmp(&rose->dest_call, &srose.srose_call) != 0)
|
|
|
|
return -EISCONN;
|
|
|
|
if (srose.srose_ndigis != rose->dest_ndigis)
|
|
|
|
return -EISCONN;
|
|
|
|
if (srose.srose_ndigis == rose->dest_ndigis) {
|
|
|
|
for (n = 0 ; n < srose.srose_ndigis ; n++)
|
|
|
|
if (ax25cmp(&rose->dest_digis[n],
|
|
|
|
&srose.srose_digis[n]))
|
|
|
|
return -EISCONN;
|
|
|
|
}
|
|
|
|
if (srose.srose_family != AF_ROSE)
|
|
|
|
return -EINVAL;
|
|
|
|
} else {
|
|
|
|
if (sk->sk_state != TCP_ESTABLISHED)
|
|
|
|
return -ENOTCONN;
|
|
|
|
|
|
|
|
srose.srose_family = AF_ROSE;
|
|
|
|
srose.srose_addr = rose->dest_addr;
|
|
|
|
srose.srose_call = rose->dest_call;
|
|
|
|
srose.srose_ndigis = rose->dest_ndigis;
|
|
|
|
for (n = 0 ; n < rose->dest_ndigis ; n++)
|
|
|
|
srose.srose_digis[n] = rose->dest_digis[n];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Build a packet */
|
2009-03-27 14:28:21 +07:00
|
|
|
/* Sanity check the packet size */
|
|
|
|
if (len > 65535)
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
size = len + AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + ROSE_MIN_LEN;
|
|
|
|
|
|
|
|
if ((skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT, &err)) == NULL)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
skb_reserve(skb, AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + ROSE_MIN_LEN);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Put the data on the end
|
|
|
|
*/
|
|
|
|
|
2007-03-15 07:04:34 +07:00
|
|
|
skb_reset_transport_header(skb);
|
|
|
|
skb_put(skb, len);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2014-04-07 08:25:44 +07:00
|
|
|
err = memcpy_from_msg(skb_transport_header(skb), msg, len);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (err) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the Q BIT Include socket option is in force, the first
|
|
|
|
* byte of the user data is the logical value of the Q Bit.
|
|
|
|
*/
|
|
|
|
if (rose->qbitincl) {
|
|
|
|
qbit = skb->data[0];
|
|
|
|
skb_pull(skb, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Push down the ROSE header
|
|
|
|
*/
|
|
|
|
asmptr = skb_push(skb, ROSE_MIN_LEN);
|
|
|
|
|
|
|
|
/* Build a ROSE Network header */
|
|
|
|
asmptr[0] = ((rose->lci >> 8) & 0x0F) | ROSE_GFI;
|
|
|
|
asmptr[1] = (rose->lci >> 0) & 0xFF;
|
|
|
|
asmptr[2] = ROSE_DATA;
|
|
|
|
|
|
|
|
if (qbit)
|
|
|
|
asmptr[0] |= ROSE_Q_BIT;
|
|
|
|
|
|
|
|
if (sk->sk_state != TCP_ESTABLISHED) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return -ENOTCONN;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef M_BIT
|
|
|
|
#define ROSE_PACLEN (256-ROSE_MIN_LEN)
|
|
|
|
if (skb->len - ROSE_MIN_LEN > ROSE_PACLEN) {
|
|
|
|
unsigned char header[ROSE_MIN_LEN];
|
|
|
|
struct sk_buff *skbn;
|
|
|
|
int frontlen;
|
|
|
|
int lg;
|
|
|
|
|
|
|
|
/* Save a copy of the Header */
|
2007-03-28 04:55:52 +07:00
|
|
|
skb_copy_from_linear_data(skb, header, ROSE_MIN_LEN);
|
2005-04-17 05:20:36 +07:00
|
|
|
skb_pull(skb, ROSE_MIN_LEN);
|
|
|
|
|
|
|
|
frontlen = skb_headroom(skb);
|
|
|
|
|
|
|
|
while (skb->len > 0) {
|
|
|
|
if ((skbn = sock_alloc_send_skb(sk, frontlen + ROSE_PACLEN, 0, &err)) == NULL) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
skbn->sk = sk;
|
|
|
|
skbn->free = 1;
|
|
|
|
skbn->arp = 1;
|
|
|
|
|
|
|
|
skb_reserve(skbn, frontlen);
|
|
|
|
|
|
|
|
lg = (ROSE_PACLEN > skb->len) ? skb->len : ROSE_PACLEN;
|
|
|
|
|
|
|
|
/* Copy the user data */
|
2007-03-28 04:55:52 +07:00
|
|
|
skb_copy_from_linear_data(skb, skb_put(skbn, lg), lg);
|
2005-04-17 05:20:36 +07:00
|
|
|
skb_pull(skb, lg);
|
|
|
|
|
|
|
|
/* Duplicate the Header */
|
|
|
|
skb_push(skbn, ROSE_MIN_LEN);
|
2007-03-31 21:55:19 +07:00
|
|
|
skb_copy_to_linear_data(skbn, header, ROSE_MIN_LEN);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (skb->len > 0)
|
|
|
|
skbn->data[2] |= M_BIT;
|
|
|
|
|
|
|
|
skb_queue_tail(&sk->sk_write_queue, skbn); /* Throw it on the queue */
|
|
|
|
}
|
|
|
|
|
|
|
|
skb->free = 1;
|
|
|
|
kfree_skb(skb);
|
|
|
|
} else {
|
|
|
|
skb_queue_tail(&sk->sk_write_queue, skb); /* Throw it on the queue */
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
skb_queue_tail(&sk->sk_write_queue, skb); /* Shove it onto the queue */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
rose_kick(sk);
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-03-02 14:37:48 +07:00
|
|
|
static int rose_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
|
|
|
|
int flags)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct sock *sk = sock->sk;
|
|
|
|
struct rose_sock *rose = rose_sk(sk);
|
|
|
|
size_t copied;
|
|
|
|
unsigned char *asmptr;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
int n, er, qbit;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This works for seqpacket too. The receiver has ordered the queue for
|
|
|
|
* us! We do one quick check first though
|
|
|
|
*/
|
|
|
|
if (sk->sk_state != TCP_ESTABLISHED)
|
|
|
|
return -ENOTCONN;
|
|
|
|
|
|
|
|
/* Now we can treat all alike */
|
|
|
|
if ((skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, flags & MSG_DONTWAIT, &er)) == NULL)
|
|
|
|
return er;
|
|
|
|
|
|
|
|
qbit = (skb->data[0] & ROSE_Q_BIT) == ROSE_Q_BIT;
|
|
|
|
|
|
|
|
skb_pull(skb, ROSE_MIN_LEN);
|
|
|
|
|
|
|
|
if (rose->qbitincl) {
|
|
|
|
asmptr = skb_push(skb, 1);
|
|
|
|
*asmptr = qbit;
|
|
|
|
}
|
|
|
|
|
2007-03-13 23:06:52 +07:00
|
|
|
skb_reset_transport_header(skb);
|
2005-04-17 05:20:36 +07:00
|
|
|
copied = skb->len;
|
|
|
|
|
|
|
|
if (copied > size) {
|
|
|
|
copied = size;
|
|
|
|
msg->msg_flags |= MSG_TRUNC;
|
|
|
|
}
|
|
|
|
|
2014-11-06 04:46:40 +07:00
|
|
|
skb_copy_datagram_msg(skb, 0, msg, copied);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2013-11-21 09:14:22 +07:00
|
|
|
if (msg->msg_name) {
|
|
|
|
struct sockaddr_rose *srose;
|
2014-01-18 04:53:15 +07:00
|
|
|
DECLARE_SOCKADDR(struct full_sockaddr_rose *, full_srose,
|
|
|
|
msg->msg_name);
|
2013-11-21 09:14:22 +07:00
|
|
|
|
|
|
|
memset(msg->msg_name, 0, sizeof(struct full_sockaddr_rose));
|
|
|
|
srose = msg->msg_name;
|
2005-04-17 05:20:36 +07:00
|
|
|
srose->srose_family = AF_ROSE;
|
|
|
|
srose->srose_addr = rose->dest_addr;
|
|
|
|
srose->srose_call = rose->dest_call;
|
|
|
|
srose->srose_ndigis = rose->dest_ndigis;
|
2013-12-23 06:32:31 +07:00
|
|
|
for (n = 0 ; n < rose->dest_ndigis ; n++)
|
|
|
|
full_srose->srose_digis[n] = rose->dest_digis[n];
|
|
|
|
msg->msg_namelen = sizeof(struct full_sockaddr_rose);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
skb_free_datagram(sk, skb);
|
|
|
|
|
|
|
|
return copied;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int rose_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
|
|
|
struct sock *sk = sock->sk;
|
|
|
|
struct rose_sock *rose = rose_sk(sk);
|
|
|
|
void __user *argp = (void __user *)arg;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case TIOCOUTQ: {
|
|
|
|
long amount;
|
2009-06-18 09:05:41 +07:00
|
|
|
|
|
|
|
amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (amount < 0)
|
|
|
|
amount = 0;
|
2005-09-13 04:24:55 +07:00
|
|
|
return put_user(amount, (unsigned int __user *) argp);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
case TIOCINQ: {
|
|
|
|
struct sk_buff *skb;
|
|
|
|
long amount = 0L;
|
|
|
|
/* These two are safe on a single CPU system as only user tasks fiddle here */
|
|
|
|
if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
|
|
|
|
amount = skb->len;
|
2005-09-13 04:24:55 +07:00
|
|
|
return put_user(amount, (unsigned int __user *) argp);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
case SIOCGSTAMP:
|
2005-09-13 04:24:55 +07:00
|
|
|
return sock_get_timestamp(sk, (struct timeval __user *) argp);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-03-19 07:33:16 +07:00
|
|
|
case SIOCGSTAMPNS:
|
|
|
|
return sock_get_timestampns(sk, (struct timespec __user *) argp);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
case SIOCGIFADDR:
|
|
|
|
case SIOCSIFADDR:
|
|
|
|
case SIOCGIFDSTADDR:
|
|
|
|
case SIOCSIFDSTADDR:
|
|
|
|
case SIOCGIFBRDADDR:
|
|
|
|
case SIOCSIFBRDADDR:
|
|
|
|
case SIOCGIFNETMASK:
|
|
|
|
case SIOCSIFNETMASK:
|
|
|
|
case SIOCGIFMETRIC:
|
|
|
|
case SIOCSIFMETRIC:
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
case SIOCADDRT:
|
|
|
|
case SIOCDELRT:
|
|
|
|
case SIOCRSCLRRT:
|
|
|
|
if (!capable(CAP_NET_ADMIN))
|
|
|
|
return -EPERM;
|
|
|
|
return rose_rt_ioctl(cmd, argp);
|
|
|
|
|
|
|
|
case SIOCRSGCAUSE: {
|
|
|
|
struct rose_cause_struct rose_cause;
|
|
|
|
rose_cause.cause = rose->cause;
|
|
|
|
rose_cause.diagnostic = rose->diagnostic;
|
|
|
|
return copy_to_user(argp, &rose_cause, sizeof(struct rose_cause_struct)) ? -EFAULT : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
case SIOCRSSCAUSE: {
|
|
|
|
struct rose_cause_struct rose_cause;
|
|
|
|
if (copy_from_user(&rose_cause, argp, sizeof(struct rose_cause_struct)))
|
|
|
|
return -EFAULT;
|
|
|
|
rose->cause = rose_cause.cause;
|
|
|
|
rose->diagnostic = rose_cause.diagnostic;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
case SIOCRSSL2CALL:
|
|
|
|
if (!capable(CAP_NET_ADMIN)) return -EPERM;
|
|
|
|
if (ax25cmp(&rose_callsign, &null_ax25_address) != 0)
|
|
|
|
ax25_listen_release(&rose_callsign, NULL);
|
|
|
|
if (copy_from_user(&rose_callsign, argp, sizeof(ax25_address)))
|
|
|
|
return -EFAULT;
|
|
|
|
if (ax25cmp(&rose_callsign, &null_ax25_address) != 0)
|
2006-12-15 06:50:34 +07:00
|
|
|
return ax25_listen_register(&rose_callsign, NULL);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
case SIOCRSGL2CALL:
|
|
|
|
return copy_to_user(argp, &rose_callsign, sizeof(ax25_address)) ? -EFAULT : 0;
|
|
|
|
|
|
|
|
case SIOCRSACCEPT:
|
|
|
|
if (rose->state == ROSE_STATE_5) {
|
|
|
|
rose_write_internal(sk, ROSE_CALL_ACCEPTED);
|
|
|
|
rose_start_idletimer(sk);
|
|
|
|
rose->condition = 0x00;
|
|
|
|
rose->vs = 0;
|
|
|
|
rose->va = 0;
|
|
|
|
rose->vr = 0;
|
|
|
|
rose->vl = 0;
|
|
|
|
rose->state = ROSE_STATE_3;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
default:
|
2006-01-04 05:18:33 +07:00
|
|
|
return -ENOIOCTLCMD;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
static void *rose_info_start(struct seq_file *seq, loff_t *pos)
|
2008-01-15 18:30:35 +07:00
|
|
|
__acquires(rose_list_lock)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
spin_lock_bh(&rose_list_lock);
|
2010-02-09 06:19:17 +07:00
|
|
|
return seq_hlist_start_head(&rose_list, *pos);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *rose_info_next(struct seq_file *seq, void *v, loff_t *pos)
|
|
|
|
{
|
2010-02-09 06:19:17 +07:00
|
|
|
return seq_hlist_next(v, &rose_list, pos);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2007-02-09 21:25:12 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static void rose_info_stop(struct seq_file *seq, void *v)
|
2008-01-15 18:30:35 +07:00
|
|
|
__releases(rose_list_lock)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
spin_unlock_bh(&rose_list_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rose_info_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
2009-07-27 09:11:14 +07:00
|
|
|
char buf[11], rsbuf[11];
|
2005-09-07 05:49:39 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (v == SEQ_START_TOKEN)
|
2007-02-09 21:25:12 +07:00
|
|
|
seq_puts(seq,
|
2005-04-17 05:20:36 +07:00
|
|
|
"dest_addr dest_call src_addr src_call dev lci neigh st vs vr va t t1 t2 t3 hb idle Snd-Q Rcv-Q inode\n");
|
|
|
|
|
|
|
|
else {
|
2010-02-09 06:19:17 +07:00
|
|
|
struct sock *s = sk_entry(v);
|
2005-04-17 05:20:36 +07:00
|
|
|
struct rose_sock *rose = rose_sk(s);
|
|
|
|
const char *devname, *callsign;
|
|
|
|
const struct net_device *dev = rose->device;
|
|
|
|
|
|
|
|
if (!dev)
|
|
|
|
devname = "???";
|
|
|
|
else
|
|
|
|
devname = dev->name;
|
2007-02-09 21:25:12 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
seq_printf(seq, "%-10s %-9s ",
|
2009-07-27 09:11:14 +07:00
|
|
|
rose2asc(rsbuf, &rose->dest_addr),
|
|
|
|
ax2asc(buf, &rose->dest_call));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (ax25cmp(&rose->source_call, &null_ax25_address) == 0)
|
|
|
|
callsign = "??????-?";
|
|
|
|
else
|
2005-09-07 05:49:39 +07:00
|
|
|
callsign = ax2asc(buf, &rose->source_call);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
seq_printf(seq,
|
|
|
|
"%-10s %-9s %-5s %3.3X %05d %d %d %d %d %3lu %3lu %3lu %3lu %3lu %3lu/%03lu %5d %5d %ld\n",
|
2009-07-27 09:11:14 +07:00
|
|
|
rose2asc(rsbuf, &rose->source_addr),
|
2005-04-17 05:20:36 +07:00
|
|
|
callsign,
|
|
|
|
devname,
|
|
|
|
rose->lci & 0x0FFF,
|
|
|
|
(rose->neighbour) ? rose->neighbour->number : 0,
|
|
|
|
rose->state,
|
|
|
|
rose->vs,
|
|
|
|
rose->vr,
|
|
|
|
rose->va,
|
|
|
|
ax25_display_timer(&rose->timer) / HZ,
|
|
|
|
rose->t1 / HZ,
|
|
|
|
rose->t2 / HZ,
|
|
|
|
rose->t3 / HZ,
|
|
|
|
rose->hb / HZ,
|
|
|
|
ax25_display_timer(&rose->idletimer) / (60 * HZ),
|
|
|
|
rose->idle / (60 * HZ),
|
2009-06-18 09:05:41 +07:00
|
|
|
sk_wmem_alloc_get(s),
|
|
|
|
sk_rmem_alloc_get(s),
|
2005-04-17 05:20:36 +07:00
|
|
|
s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0L);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-11 13:07:31 +07:00
|
|
|
static const struct seq_operations rose_info_seqops = {
|
2005-04-17 05:20:36 +07:00
|
|
|
.start = rose_info_start,
|
|
|
|
.next = rose_info_next,
|
|
|
|
.stop = rose_info_stop,
|
|
|
|
.show = rose_info_show,
|
|
|
|
};
|
|
|
|
#endif /* CONFIG_PROC_FS */
|
|
|
|
|
2009-10-05 12:58:39 +07:00
|
|
|
static const struct net_proto_family rose_family_ops = {
|
2005-04-17 05:20:36 +07:00
|
|
|
.family = PF_ROSE,
|
|
|
|
.create = rose_create,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
2009-09-14 19:23:23 +07:00
|
|
|
static const struct proto_ops rose_proto_ops = {
|
2005-04-17 05:20:36 +07:00
|
|
|
.family = PF_ROSE,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.release = rose_release,
|
|
|
|
.bind = rose_bind,
|
|
|
|
.connect = rose_connect,
|
|
|
|
.socketpair = sock_no_socketpair,
|
|
|
|
.accept = rose_accept,
|
|
|
|
.getname = rose_getname,
|
2018-06-28 23:43:44 +07:00
|
|
|
.poll = datagram_poll,
|
2005-04-17 05:20:36 +07:00
|
|
|
.ioctl = rose_ioctl,
|
|
|
|
.listen = rose_listen,
|
|
|
|
.shutdown = sock_no_shutdown,
|
|
|
|
.setsockopt = rose_setsockopt,
|
|
|
|
.getsockopt = rose_getsockopt,
|
|
|
|
.sendmsg = rose_sendmsg,
|
|
|
|
.recvmsg = rose_recvmsg,
|
|
|
|
.mmap = sock_no_mmap,
|
|
|
|
.sendpage = sock_no_sendpage,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct notifier_block rose_dev_notifier = {
|
|
|
|
.notifier_call = rose_device_event,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct net_device **dev_rose;
|
|
|
|
|
2006-12-15 06:50:01 +07:00
|
|
|
static struct ax25_protocol rose_pid = {
|
|
|
|
.pid = AX25_P_ROSE,
|
|
|
|
.func = rose_route_frame
|
|
|
|
};
|
|
|
|
|
2006-12-15 06:51:23 +07:00
|
|
|
static struct ax25_linkfail rose_linkfail_notifier = {
|
|
|
|
.func = rose_link_failed
|
|
|
|
};
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static int __init rose_proto_init(void)
|
|
|
|
{
|
|
|
|
int i;
|
2005-09-28 05:44:36 +07:00
|
|
|
int rc;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-09-28 05:44:36 +07:00
|
|
|
if (rose_ndevs > 0x7FFFFFFF/sizeof(struct net_device *)) {
|
|
|
|
printk(KERN_ERR "ROSE: rose_proto_init - rose_ndevs parameter to large\n");
|
|
|
|
rc = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = proto_register(&rose_proto, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (rc != 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
rose_callsign = null_ax25_address;
|
|
|
|
|
treewide: kzalloc() -> kcalloc()
The kzalloc() function has a 2-factor argument form, kcalloc(). This
patch replaces cases of:
kzalloc(a * b, gfp)
with:
kcalloc(a * b, gfp)
as well as handling cases of:
kzalloc(a * b * c, gfp)
with:
kzalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kzalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kzalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kzalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kzalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kzalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kzalloc
+ kcalloc
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kzalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kzalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kzalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kzalloc(sizeof(THING) * C2, ...)
|
kzalloc(sizeof(TYPE) * C2, ...)
|
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(C1 * C2, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * E2
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-13 04:03:40 +07:00
|
|
|
dev_rose = kcalloc(rose_ndevs, sizeof(struct net_device *),
|
|
|
|
GFP_KERNEL);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (dev_rose == NULL) {
|
|
|
|
printk(KERN_ERR "ROSE: rose_proto_init - unable to allocate device structure\n");
|
2005-09-28 05:44:36 +07:00
|
|
|
rc = -ENOMEM;
|
|
|
|
goto out_proto_unregister;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < rose_ndevs; i++) {
|
|
|
|
struct net_device *dev;
|
|
|
|
char name[IFNAMSIZ];
|
|
|
|
|
|
|
|
sprintf(name, "rose%d", i);
|
net: set name_assign_type in alloc_netdev()
Extend alloc_netdev{,_mq{,s}}() to take name_assign_type as argument, and convert
all users to pass NET_NAME_UNKNOWN.
Coccinelle patch:
@@
expression sizeof_priv, name, setup, txqs, rxqs, count;
@@
(
-alloc_netdev_mqs(sizeof_priv, name, setup, txqs, rxqs)
+alloc_netdev_mqs(sizeof_priv, name, NET_NAME_UNKNOWN, setup, txqs, rxqs)
|
-alloc_netdev_mq(sizeof_priv, name, setup, count)
+alloc_netdev_mq(sizeof_priv, name, NET_NAME_UNKNOWN, setup, count)
|
-alloc_netdev(sizeof_priv, name, setup)
+alloc_netdev(sizeof_priv, name, NET_NAME_UNKNOWN, setup)
)
v9: move comments here from the wrong commit
Signed-off-by: Tom Gundersen <teg@jklm.no>
Reviewed-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-07-14 21:37:24 +07:00
|
|
|
dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, rose_setup);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!dev) {
|
|
|
|
printk(KERN_ERR "ROSE: rose_proto_init - unable to allocate memory\n");
|
2005-09-28 05:43:46 +07:00
|
|
|
rc = -ENOMEM;
|
2005-04-17 05:20:36 +07:00
|
|
|
goto fail;
|
|
|
|
}
|
2005-09-28 05:43:46 +07:00
|
|
|
rc = register_netdev(dev);
|
|
|
|
if (rc) {
|
2005-09-28 05:45:15 +07:00
|
|
|
printk(KERN_ERR "ROSE: netdevice registration failed\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
free_netdev(dev);
|
|
|
|
goto fail;
|
|
|
|
}
|
2008-07-09 13:13:53 +07:00
|
|
|
rose_set_lockdep_key(dev);
|
2005-04-17 05:20:36 +07:00
|
|
|
dev_rose[i] = dev;
|
|
|
|
}
|
|
|
|
|
|
|
|
sock_register(&rose_family_ops);
|
|
|
|
register_netdevice_notifier(&rose_dev_notifier);
|
|
|
|
|
2006-12-15 06:50:01 +07:00
|
|
|
ax25_register_pid(&rose_pid);
|
2006-12-15 06:51:23 +07:00
|
|
|
ax25_linkfail_register(&rose_linkfail_notifier);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_SYSCTL
|
|
|
|
rose_register_sysctl();
|
|
|
|
#endif
|
|
|
|
rose_loopback_init();
|
|
|
|
|
|
|
|
rose_add_loopback_neigh();
|
|
|
|
|
2018-04-14 00:44:18 +07:00
|
|
|
proc_create_seq("rose", 0444, init_net.proc_net, &rose_info_seqops);
|
|
|
|
proc_create_seq("rose_neigh", 0444, init_net.proc_net,
|
|
|
|
&rose_neigh_seqops);
|
|
|
|
proc_create_seq("rose_nodes", 0444, init_net.proc_net,
|
|
|
|
&rose_node_seqops);
|
|
|
|
proc_create_seq("rose_routes", 0444, init_net.proc_net,
|
|
|
|
&rose_route_seqops);
|
2005-04-17 05:20:36 +07:00
|
|
|
out:
|
|
|
|
return rc;
|
|
|
|
fail:
|
|
|
|
while (--i >= 0) {
|
|
|
|
unregister_netdev(dev_rose[i]);
|
|
|
|
free_netdev(dev_rose[i]);
|
|
|
|
}
|
|
|
|
kfree(dev_rose);
|
2005-09-28 05:44:36 +07:00
|
|
|
out_proto_unregister:
|
2005-04-17 05:20:36 +07:00
|
|
|
proto_unregister(&rose_proto);
|
2005-09-28 05:43:46 +07:00
|
|
|
goto out;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
module_init(rose_proto_init);
|
|
|
|
|
|
|
|
module_param(rose_ndevs, int, 0);
|
|
|
|
MODULE_PARM_DESC(rose_ndevs, "number of ROSE devices");
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
|
|
|
|
MODULE_DESCRIPTION("The amateur radio ROSE network layer protocol");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_ALIAS_NETPROTO(PF_ROSE);
|
|
|
|
|
|
|
|
static void __exit rose_exit(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2013-02-18 08:34:56 +07:00
|
|
|
remove_proc_entry("rose", init_net.proc_net);
|
|
|
|
remove_proc_entry("rose_neigh", init_net.proc_net);
|
|
|
|
remove_proc_entry("rose_nodes", init_net.proc_net);
|
|
|
|
remove_proc_entry("rose_routes", init_net.proc_net);
|
2005-04-17 05:20:36 +07:00
|
|
|
rose_loopback_clear();
|
|
|
|
|
|
|
|
rose_rt_free();
|
|
|
|
|
|
|
|
ax25_protocol_release(AX25_P_ROSE);
|
2006-12-15 06:51:23 +07:00
|
|
|
ax25_linkfail_release(&rose_linkfail_notifier);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (ax25cmp(&rose_callsign, &null_ax25_address) != 0)
|
|
|
|
ax25_listen_release(&rose_callsign, NULL);
|
|
|
|
|
|
|
|
#ifdef CONFIG_SYSCTL
|
|
|
|
rose_unregister_sysctl();
|
|
|
|
#endif
|
|
|
|
unregister_netdevice_notifier(&rose_dev_notifier);
|
|
|
|
|
|
|
|
sock_unregister(PF_ROSE);
|
|
|
|
|
|
|
|
for (i = 0; i < rose_ndevs; i++) {
|
|
|
|
struct net_device *dev = dev_rose[i];
|
|
|
|
|
|
|
|
if (dev) {
|
|
|
|
unregister_netdev(dev);
|
|
|
|
free_netdev(dev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(dev_rose);
|
|
|
|
proto_unregister(&rose_proto);
|
|
|
|
}
|
|
|
|
|
|
|
|
module_exit(rose_exit);
|