xref: /src/sys/netcan/can_pcb.c

/*	$NetBSD: can_pcb.c,v 1.1.2.1 2017/01/15 20:27:33 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.1.2.1 2017/01/15 20:27:33 bouyer Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/malloc.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;
	int s;

	s = splnet();
	canp = pool_get(&canpcb_pool, PR_NOWAIT);
	splx(s);
	if (canp == NULL)
		return (ENOBUFS);
	memset(canp, 0, sizeof(*canp));
	canp->canp_table = table;
	canp->canp_socket = so;

	so->so_pcb = canp;
	s = splnet();
	TAILQ_INSERT_HEAD(&table->canpt_queue, canp, canp_queue);
	can_pcbstate(canp, CANP_ATTACHED);
	splx(s);
	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_ifindex != 0) {
		canp->canp_ifp = if_byindex(scan->can_ifindex);
		if (canp->canp_ifp == NULL)
			return (EADDRNOTAVAIL);
		soisconnected(canp->canp_socket);
	} else {
		canp->canp_ifp = NULL;
		canp->canp_socket->so_state &= ~SS_ISCONNECTED;	/* XXX */
	}
	can_pcbstate(canp, CANP_BOUND);
	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 0
	memcpy(&canp->canp_dst, scan, sizeof(struct sockaddr_can));
	can_pcbstate(canp, CANP_CONNECTED);
	return 0;
#endif
	return EOPNOTSUPP;
}

void
can_pcbdisconnect(void *v)
{
	struct canpcb *canp = v;

	can_pcbstate(canp, CANP_BOUND);
	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;
	int s;

	KASSERT(mutex_owned(softnet_lock));
	so->so_pcb = NULL;
	s =  splnet();
	can_pcbstate(canp, CANP_ATTACHED);
	TAILQ_REMOVE(&canp->canp_table->canpt_queue, canp, canp_queue);
	splx(s);
	sofree(so); /* sofree drops the lock */
	pool_put(&canpcb_pool, canp);
	mutex_enter(softnet_lock);
}

void
can_setsockaddr(struct canpcb *canp, struct sockaddr_can *scan)
{

	memset(scan, 0, sizeof (*scan));
	scan->can_family = AF_CAN;
	scan->can_len = sizeof(*scan);
	scan->can_ifindex = canp->canp_ifp->if_index;
}

#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;

	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;
}