mirror of
https://github.com/torvalds/linux.git
synced 2024-11-21 19:46:16 +00:00
97b1d320f4
We will remove this restriction in llc_rcv() in the following patch,
which means that the protocol handler must be aware of netns.
if (!net_eq(dev_net(dev), &init_net))
goto drop;
llc_rcv() fetches llc_type_handlers[llc_pdu_type(skb) - 1] and calls it
if not NULL.
If the PDU type is LLC_DEST_CONN, llc_conn_handler() is called to pass
skb to corresponding sockets. Then, we must look up a proper socket in
the same netns with skb->dev.
llc_conn_handler() calls __llc_lookup() to look up a established or
litening socket by __llc_lookup_established() and llc_lookup_listener().
Both functions iterate on a list and call llc_estab_match() or
llc_listener_match() to check if the socket is the correct destination.
However, these functions do not check netns.
Also, bind() and connect() call llc_establish_connection(), which
finally calls __llc_lookup_established(), to check if there is a
conflicting socket.
Let's test netns in llc_estab_match() and llc_listener_match().
Signed-off-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Signed-off-by: Paolo Abeni <pabeni@redhat.com>
158 lines
4.6 KiB
C
158 lines
4.6 KiB
C
/*
|
|
* llc_if.c - Defines LLC interface to upper layer
|
|
*
|
|
* Copyright (c) 1997 by Procom Technology, Inc.
|
|
* 2001-2003 by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
|
|
*
|
|
* This program can be redistributed or modified under the terms of the
|
|
* GNU General Public License as published by the Free Software Foundation.
|
|
* This program is distributed without any warranty or implied warranty
|
|
* of merchantability or fitness for a particular purpose.
|
|
*
|
|
* See the GNU General Public License for more details.
|
|
*/
|
|
#include <linux/gfp.h>
|
|
#include <linux/module.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/errno.h>
|
|
#include <net/llc_if.h>
|
|
#include <net/llc_sap.h>
|
|
#include <net/llc_s_ev.h>
|
|
#include <net/llc_conn.h>
|
|
#include <net/sock.h>
|
|
#include <net/llc_c_ev.h>
|
|
#include <net/llc_c_ac.h>
|
|
#include <net/llc_c_st.h>
|
|
#include <net/tcp_states.h>
|
|
|
|
/**
|
|
* llc_build_and_send_pkt - Connection data sending for upper layers.
|
|
* @sk: connection
|
|
* @skb: packet to send
|
|
*
|
|
* This function is called when upper layer wants to send data using
|
|
* connection oriented communication mode. During sending data, connection
|
|
* will be locked and received frames and expired timers will be queued.
|
|
* Returns 0 for success, -ECONNABORTED when the connection already
|
|
* closed and -EBUSY when sending data is not permitted in this state or
|
|
* LLC has send an I pdu with p bit set to 1 and is waiting for it's
|
|
* response.
|
|
*
|
|
* This function always consumes a reference to the skb.
|
|
*/
|
|
int llc_build_and_send_pkt(struct sock *sk, struct sk_buff *skb)
|
|
{
|
|
struct llc_conn_state_ev *ev;
|
|
int rc = -ECONNABORTED;
|
|
struct llc_sock *llc = llc_sk(sk);
|
|
|
|
if (unlikely(llc->state == LLC_CONN_STATE_ADM))
|
|
goto out_free;
|
|
rc = -EBUSY;
|
|
if (unlikely(llc_data_accept_state(llc->state) || /* data_conn_refuse */
|
|
llc->p_flag)) {
|
|
llc->failed_data_req = 1;
|
|
goto out_free;
|
|
}
|
|
ev = llc_conn_ev(skb);
|
|
ev->type = LLC_CONN_EV_TYPE_PRIM;
|
|
ev->prim = LLC_DATA_PRIM;
|
|
ev->prim_type = LLC_PRIM_TYPE_REQ;
|
|
skb->dev = llc->dev;
|
|
return llc_conn_state_process(sk, skb);
|
|
|
|
out_free:
|
|
kfree_skb(skb);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* llc_establish_connection - Called by upper layer to establish a conn
|
|
* @sk: connection
|
|
* @lmac: local mac address
|
|
* @dmac: destination mac address
|
|
* @dsap: destination sap
|
|
*
|
|
* Upper layer calls this to establish an LLC connection with a remote
|
|
* machine. This function packages a proper event and sends it connection
|
|
* component state machine. Success or failure of connection
|
|
* establishment will inform to upper layer via calling it's confirm
|
|
* function and passing proper information.
|
|
*/
|
|
int llc_establish_connection(struct sock *sk, const u8 *lmac, u8 *dmac, u8 dsap)
|
|
{
|
|
int rc = -EISCONN;
|
|
struct llc_addr laddr, daddr;
|
|
struct sk_buff *skb;
|
|
struct llc_sock *llc = llc_sk(sk);
|
|
struct sock *existing;
|
|
|
|
laddr.lsap = llc->sap->laddr.lsap;
|
|
daddr.lsap = dsap;
|
|
memcpy(daddr.mac, dmac, sizeof(daddr.mac));
|
|
memcpy(laddr.mac, lmac, sizeof(laddr.mac));
|
|
existing = llc_lookup_established(llc->sap, &daddr, &laddr, sock_net(sk));
|
|
if (existing) {
|
|
if (existing->sk_state == TCP_ESTABLISHED) {
|
|
sk = existing;
|
|
goto out_put;
|
|
} else
|
|
sock_put(existing);
|
|
}
|
|
sock_hold(sk);
|
|
rc = -ENOMEM;
|
|
skb = alloc_skb(0, GFP_ATOMIC);
|
|
if (skb) {
|
|
struct llc_conn_state_ev *ev = llc_conn_ev(skb);
|
|
|
|
ev->type = LLC_CONN_EV_TYPE_PRIM;
|
|
ev->prim = LLC_CONN_PRIM;
|
|
ev->prim_type = LLC_PRIM_TYPE_REQ;
|
|
skb_set_owner_w(skb, sk);
|
|
rc = llc_conn_state_process(sk, skb);
|
|
}
|
|
out_put:
|
|
sock_put(sk);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* llc_send_disc - Called by upper layer to close a connection
|
|
* @sk: connection to be closed
|
|
*
|
|
* Upper layer calls this when it wants to close an established LLC
|
|
* connection with a remote machine. This function packages a proper event
|
|
* and sends it to connection component state machine. Returns 0 for
|
|
* success, 1 otherwise.
|
|
*/
|
|
int llc_send_disc(struct sock *sk)
|
|
{
|
|
u16 rc = 1;
|
|
struct llc_conn_state_ev *ev;
|
|
struct sk_buff *skb;
|
|
|
|
sock_hold(sk);
|
|
if (sk->sk_type != SOCK_STREAM || sk->sk_state != TCP_ESTABLISHED ||
|
|
llc_sk(sk)->state == LLC_CONN_STATE_ADM ||
|
|
llc_sk(sk)->state == LLC_CONN_OUT_OF_SVC)
|
|
goto out;
|
|
/*
|
|
* Postpone unassigning the connection from its SAP and returning the
|
|
* connection until all ACTIONs have been completely executed
|
|
*/
|
|
skb = alloc_skb(0, GFP_ATOMIC);
|
|
if (!skb)
|
|
goto out;
|
|
skb_set_owner_w(skb, sk);
|
|
sk->sk_state = TCP_CLOSING;
|
|
ev = llc_conn_ev(skb);
|
|
ev->type = LLC_CONN_EV_TYPE_PRIM;
|
|
ev->prim = LLC_DISC_PRIM;
|
|
ev->prim_type = LLC_PRIM_TYPE_REQ;
|
|
rc = llc_conn_state_process(sk, skb);
|
|
out:
|
|
sock_put(sk);
|
|
return rc;
|
|
}
|