mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 10:49:33 +00:00
![Xie He](/assets/img/avatar_default.png)
1. When the x25 module gets loaded, layer 2 may already be running and
connected. In this case, although we are in X25_LINK_STATE_0, we still
need to handle the Restart Request received, rather than ignore it.
2. When we are in X25_LINK_STATE_2, we have already sent a Restart Request
and is waiting for the Restart Confirmation with t20timer. t20timer will
restart itself repeatedly forever so it will always be there, as long as we
are in State 2. So we don't need to check x25_t20timer_pending again.
Fixes: d023b2b9cc
("net/x25: fix restart request/confirm handling")
Cc: Martin Schiller <ms@dev.tdt.de>
Signed-off-by: Xie He <xie.he.0141@gmail.com>
Acked-by: Martin Schiller <ms@dev.tdt.de>
Signed-off-by: David S. Miller <davem@davemloft.net>
424 lines
9.1 KiB
C
424 lines
9.1 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* X.25 Packet Layer release 002
|
|
*
|
|
* This is ALPHA test software. This code may break your machine,
|
|
* randomly fail to work with new releases, misbehave and/or generally
|
|
* screw up. It might even work.
|
|
*
|
|
* This code REQUIRES 2.1.15 or higher
|
|
*
|
|
* History
|
|
* X.25 001 Jonathan Naylor Started coding.
|
|
* X.25 002 Jonathan Naylor New timer architecture.
|
|
* mar/20/00 Daniela Squassoni Disabling/enabling of facilities
|
|
* negotiation.
|
|
* 2000-09-04 Henner Eisen dev_hold() / dev_put() for x25_neigh.
|
|
*/
|
|
|
|
#define pr_fmt(fmt) "X25: " fmt
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/jiffies.h>
|
|
#include <linux/timer.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/skbuff.h>
|
|
#include <linux/uaccess.h>
|
|
#include <linux/init.h>
|
|
#include <net/x25.h>
|
|
|
|
LIST_HEAD(x25_neigh_list);
|
|
DEFINE_RWLOCK(x25_neigh_list_lock);
|
|
|
|
static void x25_t20timer_expiry(struct timer_list *);
|
|
|
|
static void x25_transmit_restart_confirmation(struct x25_neigh *nb);
|
|
static void x25_transmit_restart_request(struct x25_neigh *nb);
|
|
|
|
/*
|
|
* Linux set/reset timer routines
|
|
*/
|
|
static inline void x25_start_t20timer(struct x25_neigh *nb)
|
|
{
|
|
mod_timer(&nb->t20timer, jiffies + nb->t20);
|
|
}
|
|
|
|
static void x25_t20timer_expiry(struct timer_list *t)
|
|
{
|
|
struct x25_neigh *nb = from_timer(nb, t, t20timer);
|
|
|
|
x25_transmit_restart_request(nb);
|
|
|
|
x25_start_t20timer(nb);
|
|
}
|
|
|
|
static inline void x25_stop_t20timer(struct x25_neigh *nb)
|
|
{
|
|
del_timer(&nb->t20timer);
|
|
}
|
|
|
|
/*
|
|
* This handles all restart and diagnostic frames.
|
|
*/
|
|
void x25_link_control(struct sk_buff *skb, struct x25_neigh *nb,
|
|
unsigned short frametype)
|
|
{
|
|
struct sk_buff *skbn;
|
|
|
|
switch (frametype) {
|
|
case X25_RESTART_REQUEST:
|
|
switch (nb->state) {
|
|
case X25_LINK_STATE_0:
|
|
/* This can happen when the x25 module just gets loaded
|
|
* and doesn't know layer 2 has already connected
|
|
*/
|
|
nb->state = X25_LINK_STATE_3;
|
|
x25_transmit_restart_confirmation(nb);
|
|
break;
|
|
case X25_LINK_STATE_2:
|
|
x25_stop_t20timer(nb);
|
|
nb->state = X25_LINK_STATE_3;
|
|
break;
|
|
case X25_LINK_STATE_3:
|
|
/* clear existing virtual calls */
|
|
x25_kill_by_neigh(nb);
|
|
|
|
x25_transmit_restart_confirmation(nb);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case X25_RESTART_CONFIRMATION:
|
|
switch (nb->state) {
|
|
case X25_LINK_STATE_2:
|
|
x25_stop_t20timer(nb);
|
|
nb->state = X25_LINK_STATE_3;
|
|
break;
|
|
case X25_LINK_STATE_3:
|
|
/* clear existing virtual calls */
|
|
x25_kill_by_neigh(nb);
|
|
|
|
x25_transmit_restart_request(nb);
|
|
nb->state = X25_LINK_STATE_2;
|
|
x25_start_t20timer(nb);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case X25_DIAGNOSTIC:
|
|
if (!pskb_may_pull(skb, X25_STD_MIN_LEN + 4))
|
|
break;
|
|
|
|
pr_warn("diagnostic #%d - %02X %02X %02X\n",
|
|
skb->data[3], skb->data[4],
|
|
skb->data[5], skb->data[6]);
|
|
break;
|
|
|
|
default:
|
|
pr_warn("received unknown %02X with LCI 000\n",
|
|
frametype);
|
|
break;
|
|
}
|
|
|
|
if (nb->state == X25_LINK_STATE_3)
|
|
while ((skbn = skb_dequeue(&nb->queue)) != NULL)
|
|
x25_send_frame(skbn, nb);
|
|
}
|
|
|
|
/*
|
|
* This routine is called when a Restart Request is needed
|
|
*/
|
|
static void x25_transmit_restart_request(struct x25_neigh *nb)
|
|
{
|
|
unsigned char *dptr;
|
|
int len = X25_MAX_L2_LEN + X25_STD_MIN_LEN + 2;
|
|
struct sk_buff *skb = alloc_skb(len, GFP_ATOMIC);
|
|
|
|
if (!skb)
|
|
return;
|
|
|
|
skb_reserve(skb, X25_MAX_L2_LEN);
|
|
|
|
dptr = skb_put(skb, X25_STD_MIN_LEN + 2);
|
|
|
|
*dptr++ = nb->extended ? X25_GFI_EXTSEQ : X25_GFI_STDSEQ;
|
|
*dptr++ = 0x00;
|
|
*dptr++ = X25_RESTART_REQUEST;
|
|
*dptr++ = 0x00;
|
|
*dptr++ = 0;
|
|
|
|
skb->sk = NULL;
|
|
|
|
x25_send_frame(skb, nb);
|
|
}
|
|
|
|
/*
|
|
* This routine is called when a Restart Confirmation is needed
|
|
*/
|
|
static void x25_transmit_restart_confirmation(struct x25_neigh *nb)
|
|
{
|
|
unsigned char *dptr;
|
|
int len = X25_MAX_L2_LEN + X25_STD_MIN_LEN;
|
|
struct sk_buff *skb = alloc_skb(len, GFP_ATOMIC);
|
|
|
|
if (!skb)
|
|
return;
|
|
|
|
skb_reserve(skb, X25_MAX_L2_LEN);
|
|
|
|
dptr = skb_put(skb, X25_STD_MIN_LEN);
|
|
|
|
*dptr++ = nb->extended ? X25_GFI_EXTSEQ : X25_GFI_STDSEQ;
|
|
*dptr++ = 0x00;
|
|
*dptr++ = X25_RESTART_CONFIRMATION;
|
|
|
|
skb->sk = NULL;
|
|
|
|
x25_send_frame(skb, nb);
|
|
}
|
|
|
|
/*
|
|
* This routine is called when a Clear Request is needed outside of the context
|
|
* of a connected socket.
|
|
*/
|
|
void x25_transmit_clear_request(struct x25_neigh *nb, unsigned int lci,
|
|
unsigned char cause)
|
|
{
|
|
unsigned char *dptr;
|
|
int len = X25_MAX_L2_LEN + X25_STD_MIN_LEN + 2;
|
|
struct sk_buff *skb = alloc_skb(len, GFP_ATOMIC);
|
|
|
|
if (!skb)
|
|
return;
|
|
|
|
skb_reserve(skb, X25_MAX_L2_LEN);
|
|
|
|
dptr = skb_put(skb, X25_STD_MIN_LEN + 2);
|
|
|
|
*dptr++ = ((lci >> 8) & 0x0F) | (nb->extended ?
|
|
X25_GFI_EXTSEQ :
|
|
X25_GFI_STDSEQ);
|
|
*dptr++ = (lci >> 0) & 0xFF;
|
|
*dptr++ = X25_CLEAR_REQUEST;
|
|
*dptr++ = cause;
|
|
*dptr++ = 0x00;
|
|
|
|
skb->sk = NULL;
|
|
|
|
x25_send_frame(skb, nb);
|
|
}
|
|
|
|
void x25_transmit_link(struct sk_buff *skb, struct x25_neigh *nb)
|
|
{
|
|
switch (nb->state) {
|
|
case X25_LINK_STATE_0:
|
|
skb_queue_tail(&nb->queue, skb);
|
|
nb->state = X25_LINK_STATE_1;
|
|
x25_establish_link(nb);
|
|
break;
|
|
case X25_LINK_STATE_1:
|
|
case X25_LINK_STATE_2:
|
|
skb_queue_tail(&nb->queue, skb);
|
|
break;
|
|
case X25_LINK_STATE_3:
|
|
x25_send_frame(skb, nb);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Called when the link layer has become established.
|
|
*/
|
|
void x25_link_established(struct x25_neigh *nb)
|
|
{
|
|
switch (nb->state) {
|
|
case X25_LINK_STATE_0:
|
|
case X25_LINK_STATE_1:
|
|
x25_transmit_restart_request(nb);
|
|
nb->state = X25_LINK_STATE_2;
|
|
x25_start_t20timer(nb);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Called when the link layer has terminated, or an establishment
|
|
* request has failed.
|
|
*/
|
|
|
|
void x25_link_terminated(struct x25_neigh *nb)
|
|
{
|
|
nb->state = X25_LINK_STATE_0;
|
|
skb_queue_purge(&nb->queue);
|
|
x25_stop_t20timer(nb);
|
|
|
|
/* Out of order: clear existing virtual calls (X.25 03/93 4.6.3) */
|
|
x25_kill_by_neigh(nb);
|
|
}
|
|
|
|
/*
|
|
* Add a new device.
|
|
*/
|
|
void x25_link_device_up(struct net_device *dev)
|
|
{
|
|
struct x25_neigh *nb = kmalloc(sizeof(*nb), GFP_ATOMIC);
|
|
|
|
if (!nb)
|
|
return;
|
|
|
|
skb_queue_head_init(&nb->queue);
|
|
timer_setup(&nb->t20timer, x25_t20timer_expiry, 0);
|
|
|
|
dev_hold(dev);
|
|
nb->dev = dev;
|
|
nb->state = X25_LINK_STATE_0;
|
|
nb->extended = 0;
|
|
/*
|
|
* Enables negotiation
|
|
*/
|
|
nb->global_facil_mask = X25_MASK_REVERSE |
|
|
X25_MASK_THROUGHPUT |
|
|
X25_MASK_PACKET_SIZE |
|
|
X25_MASK_WINDOW_SIZE;
|
|
nb->t20 = sysctl_x25_restart_request_timeout;
|
|
refcount_set(&nb->refcnt, 1);
|
|
|
|
write_lock_bh(&x25_neigh_list_lock);
|
|
list_add(&nb->node, &x25_neigh_list);
|
|
write_unlock_bh(&x25_neigh_list_lock);
|
|
}
|
|
|
|
/**
|
|
* __x25_remove_neigh - remove neighbour from x25_neigh_list
|
|
* @nb: - neigh to remove
|
|
*
|
|
* Remove neighbour from x25_neigh_list. If it was there.
|
|
* Caller must hold x25_neigh_list_lock.
|
|
*/
|
|
static void __x25_remove_neigh(struct x25_neigh *nb)
|
|
{
|
|
if (nb->node.next) {
|
|
list_del(&nb->node);
|
|
x25_neigh_put(nb);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* A device has been removed, remove its links.
|
|
*/
|
|
void x25_link_device_down(struct net_device *dev)
|
|
{
|
|
struct x25_neigh *nb;
|
|
struct list_head *entry, *tmp;
|
|
|
|
write_lock_bh(&x25_neigh_list_lock);
|
|
|
|
list_for_each_safe(entry, tmp, &x25_neigh_list) {
|
|
nb = list_entry(entry, struct x25_neigh, node);
|
|
|
|
if (nb->dev == dev) {
|
|
__x25_remove_neigh(nb);
|
|
dev_put(dev);
|
|
}
|
|
}
|
|
|
|
write_unlock_bh(&x25_neigh_list_lock);
|
|
}
|
|
|
|
/*
|
|
* Given a device, return the neighbour address.
|
|
*/
|
|
struct x25_neigh *x25_get_neigh(struct net_device *dev)
|
|
{
|
|
struct x25_neigh *nb, *use = NULL;
|
|
struct list_head *entry;
|
|
|
|
read_lock_bh(&x25_neigh_list_lock);
|
|
list_for_each(entry, &x25_neigh_list) {
|
|
nb = list_entry(entry, struct x25_neigh, node);
|
|
|
|
if (nb->dev == dev) {
|
|
use = nb;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (use)
|
|
x25_neigh_hold(use);
|
|
read_unlock_bh(&x25_neigh_list_lock);
|
|
return use;
|
|
}
|
|
|
|
/*
|
|
* Handle the ioctls that control the subscription functions.
|
|
*/
|
|
int x25_subscr_ioctl(unsigned int cmd, void __user *arg)
|
|
{
|
|
struct x25_subscrip_struct x25_subscr;
|
|
struct x25_neigh *nb;
|
|
struct net_device *dev;
|
|
int rc = -EINVAL;
|
|
|
|
if (cmd != SIOCX25GSUBSCRIP && cmd != SIOCX25SSUBSCRIP)
|
|
goto out;
|
|
|
|
rc = -EFAULT;
|
|
if (copy_from_user(&x25_subscr, arg, sizeof(x25_subscr)))
|
|
goto out;
|
|
|
|
rc = -EINVAL;
|
|
if ((dev = x25_dev_get(x25_subscr.device)) == NULL)
|
|
goto out;
|
|
|
|
if ((nb = x25_get_neigh(dev)) == NULL)
|
|
goto out_dev_put;
|
|
|
|
dev_put(dev);
|
|
|
|
if (cmd == SIOCX25GSUBSCRIP) {
|
|
read_lock_bh(&x25_neigh_list_lock);
|
|
x25_subscr.extended = nb->extended;
|
|
x25_subscr.global_facil_mask = nb->global_facil_mask;
|
|
read_unlock_bh(&x25_neigh_list_lock);
|
|
rc = copy_to_user(arg, &x25_subscr,
|
|
sizeof(x25_subscr)) ? -EFAULT : 0;
|
|
} else {
|
|
rc = -EINVAL;
|
|
if (!(x25_subscr.extended && x25_subscr.extended != 1)) {
|
|
rc = 0;
|
|
write_lock_bh(&x25_neigh_list_lock);
|
|
nb->extended = x25_subscr.extended;
|
|
nb->global_facil_mask = x25_subscr.global_facil_mask;
|
|
write_unlock_bh(&x25_neigh_list_lock);
|
|
}
|
|
}
|
|
x25_neigh_put(nb);
|
|
out:
|
|
return rc;
|
|
out_dev_put:
|
|
dev_put(dev);
|
|
goto out;
|
|
}
|
|
|
|
|
|
/*
|
|
* Release all memory associated with X.25 neighbour structures.
|
|
*/
|
|
void __exit x25_link_free(void)
|
|
{
|
|
struct x25_neigh *nb;
|
|
struct list_head *entry, *tmp;
|
|
|
|
write_lock_bh(&x25_neigh_list_lock);
|
|
|
|
list_for_each_safe(entry, tmp, &x25_neigh_list) {
|
|
struct net_device *dev;
|
|
|
|
nb = list_entry(entry, struct x25_neigh, node);
|
|
dev = nb->dev;
|
|
__x25_remove_neigh(nb);
|
|
dev_put(dev);
|
|
}
|
|
write_unlock_bh(&x25_neigh_list_lock);
|
|
}
|