416 lines
10 KiB
C
416 lines
10 KiB
C
/* AF_RXRPC local endpoint management
|
|
*
|
|
* Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
|
|
* Written by David Howells (dhowells@redhat.com)
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/net.h>
|
|
#include <linux/skbuff.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/udp.h>
|
|
#include <linux/ip.h>
|
|
#include <net/sock.h>
|
|
#include <net/af_rxrpc.h>
|
|
#include <generated/utsrelease.h>
|
|
#include "ar-internal.h"
|
|
|
|
static const char rxrpc_version_string[65] = "linux-" UTS_RELEASE " AF_RXRPC";
|
|
|
|
static LIST_HEAD(rxrpc_locals);
|
|
DEFINE_RWLOCK(rxrpc_local_lock);
|
|
static DECLARE_RWSEM(rxrpc_local_sem);
|
|
static DECLARE_WAIT_QUEUE_HEAD(rxrpc_local_wq);
|
|
|
|
static void rxrpc_destroy_local(struct work_struct *work);
|
|
static void rxrpc_process_local_events(struct work_struct *work);
|
|
|
|
/*
|
|
* allocate a new local
|
|
*/
|
|
static
|
|
struct rxrpc_local *rxrpc_alloc_local(struct sockaddr_rxrpc *srx)
|
|
{
|
|
struct rxrpc_local *local;
|
|
|
|
local = kzalloc(sizeof(struct rxrpc_local), GFP_KERNEL);
|
|
if (local) {
|
|
INIT_WORK(&local->destroyer, &rxrpc_destroy_local);
|
|
INIT_WORK(&local->acceptor, &rxrpc_accept_incoming_calls);
|
|
INIT_WORK(&local->rejecter, &rxrpc_reject_packets);
|
|
INIT_WORK(&local->event_processor, &rxrpc_process_local_events);
|
|
INIT_LIST_HEAD(&local->services);
|
|
INIT_LIST_HEAD(&local->link);
|
|
init_rwsem(&local->defrag_sem);
|
|
skb_queue_head_init(&local->accept_queue);
|
|
skb_queue_head_init(&local->reject_queue);
|
|
skb_queue_head_init(&local->event_queue);
|
|
spin_lock_init(&local->lock);
|
|
rwlock_init(&local->services_lock);
|
|
atomic_set(&local->usage, 1);
|
|
local->debug_id = atomic_inc_return(&rxrpc_debug_id);
|
|
memcpy(&local->srx, srx, sizeof(*srx));
|
|
}
|
|
|
|
_leave(" = %p", local);
|
|
return local;
|
|
}
|
|
|
|
/*
|
|
* create the local socket
|
|
* - must be called with rxrpc_local_sem writelocked
|
|
*/
|
|
static int rxrpc_create_local(struct rxrpc_local *local)
|
|
{
|
|
struct sock *sock;
|
|
int ret, opt;
|
|
|
|
_enter("%p{%d}", local, local->srx.transport_type);
|
|
|
|
/* create a socket to represent the local endpoint */
|
|
ret = sock_create_kern(&init_net, PF_INET, local->srx.transport_type,
|
|
IPPROTO_UDP, &local->socket);
|
|
if (ret < 0) {
|
|
_leave(" = %d [socket]", ret);
|
|
return ret;
|
|
}
|
|
|
|
/* if a local address was supplied then bind it */
|
|
if (local->srx.transport_len > sizeof(sa_family_t)) {
|
|
_debug("bind");
|
|
ret = kernel_bind(local->socket,
|
|
(struct sockaddr *) &local->srx.transport,
|
|
local->srx.transport_len);
|
|
if (ret < 0) {
|
|
_debug("bind failed");
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
/* we want to receive ICMP errors */
|
|
opt = 1;
|
|
ret = kernel_setsockopt(local->socket, SOL_IP, IP_RECVERR,
|
|
(char *) &opt, sizeof(opt));
|
|
if (ret < 0) {
|
|
_debug("setsockopt failed");
|
|
goto error;
|
|
}
|
|
|
|
/* we want to set the don't fragment bit */
|
|
opt = IP_PMTUDISC_DO;
|
|
ret = kernel_setsockopt(local->socket, SOL_IP, IP_MTU_DISCOVER,
|
|
(char *) &opt, sizeof(opt));
|
|
if (ret < 0) {
|
|
_debug("setsockopt failed");
|
|
goto error;
|
|
}
|
|
|
|
write_lock_bh(&rxrpc_local_lock);
|
|
list_add(&local->link, &rxrpc_locals);
|
|
write_unlock_bh(&rxrpc_local_lock);
|
|
|
|
/* set the socket up */
|
|
sock = local->socket->sk;
|
|
sock->sk_user_data = local;
|
|
sock->sk_data_ready = rxrpc_data_ready;
|
|
sock->sk_error_report = rxrpc_UDP_error_report;
|
|
_leave(" = 0");
|
|
return 0;
|
|
|
|
error:
|
|
kernel_sock_shutdown(local->socket, SHUT_RDWR);
|
|
local->socket->sk->sk_user_data = NULL;
|
|
sock_release(local->socket);
|
|
local->socket = NULL;
|
|
|
|
_leave(" = %d", ret);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* create a new local endpoint using the specified UDP address
|
|
*/
|
|
struct rxrpc_local *rxrpc_lookup_local(struct sockaddr_rxrpc *srx)
|
|
{
|
|
struct rxrpc_local *local;
|
|
int ret;
|
|
|
|
_enter("{%d,%u,%pI4+%hu}",
|
|
srx->transport_type,
|
|
srx->transport.family,
|
|
&srx->transport.sin.sin_addr,
|
|
ntohs(srx->transport.sin.sin_port));
|
|
|
|
down_write(&rxrpc_local_sem);
|
|
|
|
/* see if we have a suitable local local endpoint already */
|
|
read_lock_bh(&rxrpc_local_lock);
|
|
|
|
list_for_each_entry(local, &rxrpc_locals, link) {
|
|
_debug("CMP {%d,%u,%pI4+%hu}",
|
|
local->srx.transport_type,
|
|
local->srx.transport.family,
|
|
&local->srx.transport.sin.sin_addr,
|
|
ntohs(local->srx.transport.sin.sin_port));
|
|
|
|
if (local->srx.transport_type != srx->transport_type ||
|
|
local->srx.transport.family != srx->transport.family)
|
|
continue;
|
|
|
|
switch (srx->transport.family) {
|
|
case AF_INET:
|
|
if (local->srx.transport.sin.sin_port !=
|
|
srx->transport.sin.sin_port)
|
|
continue;
|
|
if (memcmp(&local->srx.transport.sin.sin_addr,
|
|
&srx->transport.sin.sin_addr,
|
|
sizeof(struct in_addr)) != 0)
|
|
continue;
|
|
goto found_local;
|
|
|
|
default:
|
|
BUG();
|
|
}
|
|
}
|
|
|
|
read_unlock_bh(&rxrpc_local_lock);
|
|
|
|
/* we didn't find one, so we need to create one */
|
|
local = rxrpc_alloc_local(srx);
|
|
if (!local) {
|
|
up_write(&rxrpc_local_sem);
|
|
return ERR_PTR(-ENOMEM);
|
|
}
|
|
|
|
ret = rxrpc_create_local(local);
|
|
if (ret < 0) {
|
|
up_write(&rxrpc_local_sem);
|
|
kfree(local);
|
|
_leave(" = %d", ret);
|
|
return ERR_PTR(ret);
|
|
}
|
|
|
|
up_write(&rxrpc_local_sem);
|
|
|
|
_net("LOCAL new %d {%d,%u,%pI4+%hu}",
|
|
local->debug_id,
|
|
local->srx.transport_type,
|
|
local->srx.transport.family,
|
|
&local->srx.transport.sin.sin_addr,
|
|
ntohs(local->srx.transport.sin.sin_port));
|
|
|
|
_leave(" = %p [new]", local);
|
|
return local;
|
|
|
|
found_local:
|
|
rxrpc_get_local(local);
|
|
read_unlock_bh(&rxrpc_local_lock);
|
|
up_write(&rxrpc_local_sem);
|
|
|
|
_net("LOCAL old %d {%d,%u,%pI4+%hu}",
|
|
local->debug_id,
|
|
local->srx.transport_type,
|
|
local->srx.transport.family,
|
|
&local->srx.transport.sin.sin_addr,
|
|
ntohs(local->srx.transport.sin.sin_port));
|
|
|
|
_leave(" = %p [reuse]", local);
|
|
return local;
|
|
}
|
|
|
|
/*
|
|
* release a local endpoint
|
|
*/
|
|
void rxrpc_put_local(struct rxrpc_local *local)
|
|
{
|
|
_enter("%p{u=%d}", local, atomic_read(&local->usage));
|
|
|
|
ASSERTCMP(atomic_read(&local->usage), >, 0);
|
|
|
|
/* to prevent a race, the decrement and the dequeue must be effectively
|
|
* atomic */
|
|
write_lock_bh(&rxrpc_local_lock);
|
|
if (unlikely(atomic_dec_and_test(&local->usage))) {
|
|
_debug("destroy local");
|
|
rxrpc_queue_work(&local->destroyer);
|
|
}
|
|
write_unlock_bh(&rxrpc_local_lock);
|
|
_leave("");
|
|
}
|
|
|
|
/*
|
|
* destroy a local endpoint
|
|
*/
|
|
static void rxrpc_destroy_local(struct work_struct *work)
|
|
{
|
|
struct rxrpc_local *local =
|
|
container_of(work, struct rxrpc_local, destroyer);
|
|
|
|
_enter("%p{%d}", local, atomic_read(&local->usage));
|
|
|
|
down_write(&rxrpc_local_sem);
|
|
|
|
write_lock_bh(&rxrpc_local_lock);
|
|
if (atomic_read(&local->usage) > 0) {
|
|
write_unlock_bh(&rxrpc_local_lock);
|
|
up_read(&rxrpc_local_sem);
|
|
_leave(" [resurrected]");
|
|
return;
|
|
}
|
|
|
|
list_del(&local->link);
|
|
local->socket->sk->sk_user_data = NULL;
|
|
write_unlock_bh(&rxrpc_local_lock);
|
|
|
|
downgrade_write(&rxrpc_local_sem);
|
|
|
|
ASSERT(list_empty(&local->services));
|
|
ASSERT(!work_pending(&local->acceptor));
|
|
ASSERT(!work_pending(&local->rejecter));
|
|
ASSERT(!work_pending(&local->event_processor));
|
|
|
|
/* finish cleaning up the local descriptor */
|
|
rxrpc_purge_queue(&local->accept_queue);
|
|
rxrpc_purge_queue(&local->reject_queue);
|
|
rxrpc_purge_queue(&local->event_queue);
|
|
kernel_sock_shutdown(local->socket, SHUT_RDWR);
|
|
sock_release(local->socket);
|
|
|
|
up_read(&rxrpc_local_sem);
|
|
|
|
_net("DESTROY LOCAL %d", local->debug_id);
|
|
kfree(local);
|
|
|
|
if (list_empty(&rxrpc_locals))
|
|
wake_up_all(&rxrpc_local_wq);
|
|
|
|
_leave("");
|
|
}
|
|
|
|
/*
|
|
* preemptively destroy all local local endpoint rather than waiting for
|
|
* them to be destroyed
|
|
*/
|
|
void __exit rxrpc_destroy_all_locals(void)
|
|
{
|
|
DECLARE_WAITQUEUE(myself,current);
|
|
|
|
_enter("");
|
|
|
|
/* we simply have to wait for them to go away */
|
|
if (!list_empty(&rxrpc_locals)) {
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
add_wait_queue(&rxrpc_local_wq, &myself);
|
|
|
|
while (!list_empty(&rxrpc_locals)) {
|
|
schedule();
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
}
|
|
|
|
remove_wait_queue(&rxrpc_local_wq, &myself);
|
|
set_current_state(TASK_RUNNING);
|
|
}
|
|
|
|
_leave("");
|
|
}
|
|
|
|
/*
|
|
* Reply to a version request
|
|
*/
|
|
static void rxrpc_send_version_request(struct rxrpc_local *local,
|
|
struct rxrpc_host_header *hdr,
|
|
struct sk_buff *skb)
|
|
{
|
|
struct rxrpc_wire_header whdr;
|
|
struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
|
|
struct sockaddr_in sin;
|
|
struct msghdr msg;
|
|
struct kvec iov[2];
|
|
size_t len;
|
|
int ret;
|
|
|
|
_enter("");
|
|
|
|
sin.sin_family = AF_INET;
|
|
sin.sin_port = udp_hdr(skb)->source;
|
|
sin.sin_addr.s_addr = ip_hdr(skb)->saddr;
|
|
|
|
msg.msg_name = &sin;
|
|
msg.msg_namelen = sizeof(sin);
|
|
msg.msg_control = NULL;
|
|
msg.msg_controllen = 0;
|
|
msg.msg_flags = 0;
|
|
|
|
whdr.epoch = htonl(sp->hdr.epoch);
|
|
whdr.cid = htonl(sp->hdr.cid);
|
|
whdr.callNumber = htonl(sp->hdr.callNumber);
|
|
whdr.seq = 0;
|
|
whdr.serial = 0;
|
|
whdr.type = RXRPC_PACKET_TYPE_VERSION;
|
|
whdr.flags = RXRPC_LAST_PACKET | (~hdr->flags & RXRPC_CLIENT_INITIATED);
|
|
whdr.userStatus = 0;
|
|
whdr.securityIndex = 0;
|
|
whdr._rsvd = 0;
|
|
whdr.serviceId = htons(sp->hdr.serviceId);
|
|
|
|
iov[0].iov_base = &whdr;
|
|
iov[0].iov_len = sizeof(whdr);
|
|
iov[1].iov_base = (char *)rxrpc_version_string;
|
|
iov[1].iov_len = sizeof(rxrpc_version_string);
|
|
|
|
len = iov[0].iov_len + iov[1].iov_len;
|
|
|
|
_proto("Tx VERSION (reply)");
|
|
|
|
ret = kernel_sendmsg(local->socket, &msg, iov, 2, len);
|
|
if (ret < 0)
|
|
_debug("sendmsg failed: %d", ret);
|
|
|
|
_leave("");
|
|
}
|
|
|
|
/*
|
|
* Process event packets targetted at a local endpoint.
|
|
*/
|
|
static void rxrpc_process_local_events(struct work_struct *work)
|
|
{
|
|
struct rxrpc_local *local = container_of(work, struct rxrpc_local, event_processor);
|
|
struct sk_buff *skb;
|
|
char v;
|
|
|
|
_enter("");
|
|
|
|
atomic_inc(&local->usage);
|
|
|
|
while ((skb = skb_dequeue(&local->event_queue))) {
|
|
struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
|
|
|
|
_debug("{%d},{%u}", local->debug_id, sp->hdr.type);
|
|
|
|
switch (sp->hdr.type) {
|
|
case RXRPC_PACKET_TYPE_VERSION:
|
|
if (skb_copy_bits(skb, 0, &v, 1) < 0)
|
|
return;
|
|
_proto("Rx VERSION { %02x }", v);
|
|
if (v == 0)
|
|
rxrpc_send_version_request(local, &sp->hdr, skb);
|
|
break;
|
|
|
|
default:
|
|
/* Just ignore anything we don't understand */
|
|
break;
|
|
}
|
|
|
|
rxrpc_put_local(local);
|
|
rxrpc_free_skb(skb);
|
|
}
|
|
|
|
rxrpc_put_local(local);
|
|
_leave("");
|
|
}
|