403 lines
9.9 KiB
C
403 lines
9.9 KiB
C
/* $NetBSD: can_pcb.c,v 1.8 2019/07/20 15:34:41 bouyer Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 2003, 2017 The NetBSD Foundation, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to The NetBSD Foundation
|
|
* by Robert Swindells and Manuel Bouyer
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__KERNEL_RCSID(0, "$NetBSD: can_pcb.c,v 1.8 2019/07/20 15:34:41 bouyer Exp $");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/kmem.h>
|
|
#include <sys/mbuf.h>
|
|
#include <sys/protosw.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/socketvar.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/errno.h>
|
|
#include <sys/time.h>
|
|
#include <sys/pool.h>
|
|
#include <sys/proc.h>
|
|
|
|
#include <net/if.h>
|
|
#include <net/route.h>
|
|
|
|
#include <netcan/can.h>
|
|
#include <netcan/can_var.h>
|
|
#include <netcan/can_pcb.h>
|
|
|
|
#define CANPCBHASH_BIND(table, ifindex) \
|
|
&(table)->canpt_bindhashtbl[ \
|
|
(ifindex) & (table)->canpt_bindhash]
|
|
#define CANPCBHASH_CONNECT(table, ifindex) \
|
|
&(table)->canpt_connecthashtbl[ \
|
|
(ifindex) & (table)->canpt_bindhash]
|
|
|
|
struct pool canpcb_pool;
|
|
|
|
void
|
|
can_pcbinit(struct canpcbtable *table, int bindhashsize, int connecthashsize)
|
|
{
|
|
static int canpcb_pool_initialized;
|
|
|
|
if (canpcb_pool_initialized == 0) {
|
|
pool_init(&canpcb_pool, sizeof(struct canpcb), 0, 0, 0,
|
|
"canpcbpl", NULL, IPL_SOFTNET);
|
|
canpcb_pool_initialized = 1;
|
|
}
|
|
|
|
TAILQ_INIT(&table->canpt_queue);
|
|
table->canpt_bindhashtbl = hashinit(bindhashsize, HASH_LIST, true,
|
|
&table->canpt_bindhash);
|
|
table->canpt_connecthashtbl = hashinit(connecthashsize, HASH_LIST,
|
|
true, &table->canpt_connecthash);
|
|
}
|
|
|
|
int
|
|
can_pcballoc(struct socket *so, void *v)
|
|
{
|
|
struct canpcbtable *table = v;
|
|
struct canpcb *canp;
|
|
struct can_filter *can_init_filter;
|
|
int s;
|
|
|
|
can_init_filter = kmem_alloc(sizeof(struct can_filter), KM_NOSLEEP);
|
|
if (can_init_filter == NULL)
|
|
return (ENOBUFS);
|
|
can_init_filter->can_id = 0;
|
|
can_init_filter->can_mask = 0; /* accept all by default */
|
|
|
|
s = splnet();
|
|
canp = pool_get(&canpcb_pool, PR_NOWAIT);
|
|
splx(s);
|
|
if (canp == NULL) {
|
|
kmem_free(can_init_filter, sizeof(struct can_filter));
|
|
return (ENOBUFS);
|
|
}
|
|
memset(canp, 0, sizeof(*canp));
|
|
canp->canp_table = table;
|
|
canp->canp_socket = so;
|
|
canp->canp_filters = can_init_filter;
|
|
canp->canp_nfilters = 1;
|
|
mutex_init(&canp->canp_mtx, MUTEX_DEFAULT, IPL_NET);
|
|
canp->canp_refcount = 1;
|
|
|
|
so->so_pcb = canp;
|
|
mutex_enter(&canp->canp_mtx);
|
|
TAILQ_INSERT_HEAD(&table->canpt_queue, canp, canp_queue);
|
|
can_pcbstate(canp, CANP_ATTACHED);
|
|
mutex_exit(&canp->canp_mtx);
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
can_pcbbind(void *v, struct sockaddr_can *scan, struct lwp *l)
|
|
{
|
|
struct canpcb *canp = v;
|
|
|
|
if (scan->can_family != AF_CAN)
|
|
return (EAFNOSUPPORT);
|
|
if (scan->can_len != sizeof(*scan))
|
|
return EINVAL;
|
|
mutex_enter(&canp->canp_mtx);
|
|
if (scan->can_ifindex != 0) {
|
|
canp->canp_ifp = if_byindex(scan->can_ifindex);
|
|
if (canp->canp_ifp == NULL ||
|
|
canp->canp_ifp->if_dlt != DLT_CAN_SOCKETCAN) {
|
|
canp->canp_ifp = NULL;
|
|
mutex_exit(&canp->canp_mtx);
|
|
return (EADDRNOTAVAIL);
|
|
}
|
|
soisconnected(canp->canp_socket);
|
|
} else {
|
|
canp->canp_ifp = NULL;
|
|
canp->canp_socket->so_state &= ~SS_ISCONNECTED; /* XXX */
|
|
}
|
|
can_pcbstate(canp, CANP_BOUND);
|
|
mutex_exit(&canp->canp_mtx);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Connect from a socket to a specified address.
|
|
*/
|
|
int
|
|
can_pcbconnect(void *v, struct sockaddr_can *scan)
|
|
{
|
|
#if 0
|
|
struct canpcb *canp = v;
|
|
struct sockaddr_can *ifaddr = NULL;
|
|
int error;
|
|
#endif
|
|
|
|
if (scan->can_family != AF_CAN)
|
|
return (EAFNOSUPPORT);
|
|
if (scan->can_len != sizeof(*scan))
|
|
return EINVAL;
|
|
#if 0
|
|
mutex_enter(&canp->canp_mtx);
|
|
memcpy(&canp->canp_dst, scan, sizeof(struct sockaddr_can));
|
|
can_pcbstate(canp, CANP_CONNECTED);
|
|
mutex_exit(&canp->canp_mtx);
|
|
return 0;
|
|
#endif
|
|
return EOPNOTSUPP;
|
|
}
|
|
|
|
void
|
|
can_pcbdisconnect(void *v)
|
|
{
|
|
struct canpcb *canp = v;
|
|
|
|
mutex_enter(&canp->canp_mtx);
|
|
can_pcbstate(canp, CANP_DETACHED);
|
|
mutex_exit(&canp->canp_mtx);
|
|
if (canp->canp_socket->so_state & SS_NOFDREF)
|
|
can_pcbdetach(canp);
|
|
}
|
|
|
|
void
|
|
can_pcbdetach(void *v)
|
|
{
|
|
struct canpcb *canp = v;
|
|
struct socket *so = canp->canp_socket;
|
|
|
|
KASSERT(mutex_owned(softnet_lock));
|
|
so->so_pcb = NULL;
|
|
mutex_enter(&canp->canp_mtx);
|
|
can_pcbstate(canp, CANP_DETACHED);
|
|
mutex_exit(&canp->canp_mtx);
|
|
can_pcbsetfilter(canp, NULL, 0);
|
|
TAILQ_REMOVE(&canp->canp_table->canpt_queue, canp, canp_queue);
|
|
sofree(so); /* sofree drops the softnet_lock */
|
|
canp_unref(canp);
|
|
mutex_enter(softnet_lock);
|
|
}
|
|
|
|
void
|
|
canp_ref(struct canpcb *canp)
|
|
{
|
|
KASSERT(mutex_owned(&canp->canp_mtx));
|
|
canp->canp_refcount++;
|
|
}
|
|
|
|
void
|
|
canp_unref(struct canpcb *canp)
|
|
{
|
|
mutex_enter(&canp->canp_mtx);
|
|
canp->canp_refcount--;
|
|
KASSERT(canp->canp_refcount >= 0);
|
|
if (canp->canp_refcount > 0) {
|
|
mutex_exit(&canp->canp_mtx);
|
|
return;
|
|
}
|
|
mutex_exit(&canp->canp_mtx);
|
|
mutex_destroy(&canp->canp_mtx);
|
|
pool_put(&canpcb_pool, canp);
|
|
}
|
|
|
|
void
|
|
can_setsockaddr(struct canpcb *canp, struct sockaddr_can *scan)
|
|
{
|
|
|
|
mutex_enter(&canp->canp_mtx);
|
|
memset(scan, 0, sizeof (*scan));
|
|
scan->can_family = AF_CAN;
|
|
scan->can_len = sizeof(*scan);
|
|
if (canp->canp_ifp)
|
|
scan->can_ifindex = canp->canp_ifp->if_index;
|
|
else
|
|
scan->can_ifindex = 0;
|
|
mutex_exit(&canp->canp_mtx);
|
|
}
|
|
|
|
int
|
|
can_pcbsetfilter(struct canpcb *canp, struct can_filter *fp, int nfilters)
|
|
{
|
|
|
|
struct can_filter *newf;
|
|
struct can_filter *oldf;
|
|
int oldnf;
|
|
int error = 0;
|
|
|
|
if (nfilters > 0) {
|
|
newf =
|
|
kmem_alloc(sizeof(struct can_filter) * nfilters, KM_SLEEP);
|
|
memcpy(newf, fp, sizeof(struct can_filter) * nfilters);
|
|
} else {
|
|
newf = NULL;
|
|
}
|
|
mutex_enter(&canp->canp_mtx);
|
|
oldf = canp->canp_filters;
|
|
oldnf = canp->canp_nfilters;
|
|
if (newf != NULL && canp->canp_state == CANP_DETACHED) {
|
|
error = ECONNRESET;
|
|
} else {
|
|
canp->canp_filters = newf;
|
|
canp->canp_nfilters = nfilters;
|
|
newf = NULL;
|
|
}
|
|
mutex_exit(&canp->canp_mtx);
|
|
if (oldf != NULL) {
|
|
kmem_free(oldf, sizeof(struct can_filter) * oldnf);
|
|
}
|
|
if (newf != NULL) {
|
|
kmem_free(newf, sizeof(struct can_filter) * nfilters);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
/*
|
|
* Pass some notification to all connections of a protocol
|
|
* associated with address dst. The local address and/or port numbers
|
|
* may be specified to limit the search. The "usual action" will be
|
|
* taken, depending on the ctlinput cmd. The caller must filter any
|
|
* cmds that are uninteresting (e.g., no error in the map).
|
|
* Call the protocol specific routine (if any) to report
|
|
* any errors for each matching socket.
|
|
*
|
|
* Must be called at splsoftnet.
|
|
*/
|
|
int
|
|
can_pcbnotify(struct canpcbtable *table, u_int32_t faddr, u_int32_t laddr,
|
|
int errno, void (*notify)(struct canpcb *, int))
|
|
{
|
|
struct canpcbhead *head;
|
|
struct canpcb *canp, *ncanp;
|
|
int nmatch;
|
|
|
|
if (faddr == 0 || notify == 0)
|
|
return (0);
|
|
|
|
nmatch = 0;
|
|
head = CANPCBHASH_CONNECT(table, faddr, laddr);
|
|
for (canp = LIST_FIRST(head); canp != NULL; canp = ncanp) {
|
|
ncanp = LIST_NEXT(canp, canp_hash);
|
|
if (canp->canp_faddr == faddr &&
|
|
canp->canp_laddr == laddr) {
|
|
(*notify)(canp, errno);
|
|
nmatch++;
|
|
}
|
|
}
|
|
return (nmatch);
|
|
}
|
|
|
|
void
|
|
can_pcbnotifyall(struct canpcbtable *table, u_int32_t faddr, int errno,
|
|
void (*notify)(struct canpcb *, int))
|
|
{
|
|
struct canpcb *canp, *ncanp;
|
|
|
|
if (faddr == 0 || notify == 0)
|
|
return;
|
|
|
|
TAILQ_FOREACH_SAFE(canp, &table->canpt_queue, canp_queue, ncanp) {
|
|
if (canp->canp_faddr == faddr)
|
|
(*notify)(canp, errno);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
void
|
|
can_pcbpurgeif0(struct canpcbtable *table, struct ifnet *ifp)
|
|
{
|
|
struct canpcb *canp, *ncanp;
|
|
struct ip_moptions *imo;
|
|
int i, gap;
|
|
|
|
}
|
|
|
|
void
|
|
can_pcbpurgeif(struct canpcbtable *table, struct ifnet *ifp)
|
|
{
|
|
struct canpcb *canp, *ncanp;
|
|
|
|
for (canp = CIRCLEQ_FIRST(&table->canpt_queue);
|
|
canp != (void *)&table->canpt_queue;
|
|
canp = ncanp) {
|
|
ncanp = CIRCLEQ_NEXT(canp, canp_queue);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
void
|
|
can_pcbstate(struct canpcb *canp, int state)
|
|
{
|
|
int ifindex = canp->canp_ifp ? canp->canp_ifp->if_index : 0;
|
|
KASSERT(mutex_owned(&canp->canp_mtx));
|
|
|
|
if (canp->canp_state > CANP_ATTACHED)
|
|
LIST_REMOVE(canp, canp_hash);
|
|
|
|
switch (state) {
|
|
case CANP_BOUND:
|
|
LIST_INSERT_HEAD(CANPCBHASH_BIND(canp->canp_table,
|
|
ifindex), canp, canp_hash);
|
|
break;
|
|
case CANP_CONNECTED:
|
|
LIST_INSERT_HEAD(CANPCBHASH_CONNECT(canp->canp_table,
|
|
ifindex), canp, canp_hash);
|
|
break;
|
|
}
|
|
|
|
canp->canp_state = state;
|
|
}
|
|
|
|
/*
|
|
* check mbuf against socket accept filter.
|
|
* returns true if mbuf is accepted, false otherwise
|
|
*/
|
|
bool
|
|
can_pcbfilter(struct canpcb *canp, struct mbuf *m)
|
|
{
|
|
int i;
|
|
struct can_frame *fmp;
|
|
struct can_filter *fip;
|
|
|
|
KASSERT(mutex_owned(&canp->canp_mtx));
|
|
KASSERT((m->m_flags & M_PKTHDR) != 0);
|
|
KASSERT(m->m_len == m->m_pkthdr.len);
|
|
|
|
fmp = mtod(m, struct can_frame *);
|
|
for (i = 0; i < canp->canp_nfilters; i++) {
|
|
fip = &canp->canp_filters[i];
|
|
if ((fmp->can_id & fip->can_mask) == fip->can_id)
|
|
return true;
|
|
}
|
|
/* no match */
|
|
return false;
|
|
}
|