xref: /src/sys/netcan/can_pcb.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;
}