/*      $NetBSD: can.c,v 1.14 2024/07/05 04:31:54 rin 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.c,v 1.14 2024/07/05 04:31:54 rin Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/mbuf.h>
#include <sys/ioctl.h>
#include <sys/domain.h>
#include <sys/protosw.h>
#include <sys/errno.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/proc.h>
#include <sys/kauth.h>

#include <net/if.h>
#include <net/if_types.h>
#include <net/pktqueue.h>
#include <net/route.h>
#include <net/bpf.h> 

#include <netcan/can.h>
#include <netcan/can_pcb.h>
#include <netcan/can_var.h>

struct canpcb canpcb;
#if 0
struct canpcb canrawpcb;
#endif

struct  canpcbtable cbtable;

pktqueue_t *            can_pktq                __read_mostly;
int     canqmaxlen = IFQ_MAXLEN;

int can_copy_output = 0;
int can_output_cnt = 0;
struct mbuf *can_lastout;

int     can_sendspace = 4096;           /* really max datagram size */
int     can_recvspace = 40 * (1024 + sizeof(struct sockaddr_can));
                                        /* 40 1K datagrams */
#ifndef CANHASHSIZE
#define CANHASHSIZE     128
#endif
int     canhashsize = CANHASHSIZE;

#ifdef MBUFTRACE
static struct mowner can_mowner = MOWNER_INIT("can", "");
static struct mowner can_rx_mowner = MOWNER_INIT("can", "rx");
static struct mowner can_tx_mowner = MOWNER_INIT("can", "tx");
#endif

static int can_output(struct mbuf *, struct canpcb *);

static int can_control(struct socket *, u_long, void *, struct ifnet *);

static void canintr(void *);

void
can_init(void)
{
        can_pktq = pktq_create(canqmaxlen, canintr, NULL);
        KASSERT(can_pktq != NULL);

        can_pcbinit(&cbtable, canhashsize, canhashsize);
}

/*
 * Generic control operations (ioctl's).
 */
static int
can_get_netlink(struct ifnet *ifp, struct ifdrv *ifd)
{
        struct canif_softc *csc = ifp->if_softc;

        if (ifp->if_dlt != DLT_CAN_SOCKETCAN || csc == NULL)
                return EOPNOTSUPP;

        switch(ifd->ifd_cmd) {
        case CANGLINKTIMECAP:
                if (ifd->ifd_len != sizeof(struct can_link_timecaps))
                        return EINVAL;
                return copyout(&csc->csc_timecaps, ifd->ifd_data, ifd->ifd_len);
        case CANGLINKTIMINGS:
                if (ifd->ifd_len != sizeof(struct can_link_timings))
                        return EINVAL;
                return copyout(&csc->csc_timings, ifd->ifd_data, ifd->ifd_len);
        case CANGLINKMODE:
                if (ifd->ifd_len != sizeof(uint32_t))
                        return EINVAL;
                return copyout(&csc->csc_linkmodes, ifd->ifd_data, ifd->ifd_len);
        }
        return EOPNOTSUPP;
}

static int
can_set_netlink(struct ifnet *ifp, struct ifdrv *ifd)
{
        struct canif_softc *csc = ifp->if_softc;
        uint32_t mode;
        int error;

        if (ifp->if_dlt != DLT_CAN_SOCKETCAN || csc == NULL)
                return EOPNOTSUPP;

        error = kauth_authorize_network(kauth_cred_get(),
            KAUTH_NETWORK_INTERFACE,
            KAUTH_REQ_NETWORK_INTERFACE_SETPRIV, ifp,
            (void *)SIOCSDRVSPEC, NULL);
        if (error != 0)
                return error;

        if ((ifp->if_flags & IFF_UP) != 0) {
                return EBUSY;
        }

        switch(ifd->ifd_cmd) {
        case CANSLINKTIMINGS:
                if (ifd->ifd_len != sizeof(struct can_link_timings))
                        return EINVAL;
                return copyin(ifd->ifd_data, &csc->csc_timings, ifd->ifd_len);

        case CANSLINKMODE:
        case CANCLINKMODE:
                if (ifd->ifd_len != sizeof(uint32_t))
                        return EINVAL;
                error = copyin(ifd->ifd_data, &mode, ifd->ifd_len);
                if (error)
                        return error;
                if ((mode & csc->csc_timecaps.cltc_linkmode_caps) != mode)
                        return EINVAL;
                /* XXX locking */
                if (ifd->ifd_cmd == CANSLINKMODE)
                        csc->csc_linkmodes |= mode;
                else
                        csc->csc_linkmodes &= ~mode;
                return 0;
        }
        return EOPNOTSUPP;
}

/* ARGSUSED */
static int
can_control(struct socket *so, u_long cmd, void *data, struct ifnet *ifp)
{
#if 0
        struct can_ifreq *cfr = (struct can_ifreq *)data;
        int error = 0;
#endif
        if (ifp == NULL)
                return (EOPNOTSUPP);

        switch (cmd) {
        case SIOCGDRVSPEC:
                return can_get_netlink(ifp, (struct ifdrv *) data);
        case SIOCSDRVSPEC:
                return can_set_netlink(ifp, (struct ifdrv *) data);
        default:
                if (ifp->if_ioctl == 0)
                        return (EOPNOTSUPP);
                return (if_ioctl(ifp, cmd, data));
        }
        return (0);
}

static int
can_purgeif(struct socket *so, struct ifnet *ifp)
{
        return 0;
}

void
can_ifattach(struct ifnet *ifp)
{
        if_attach(ifp);
        ifp->if_mtu = sizeof(struct can_frame);
        ifp->if_type = IFT_OTHER;
        ifp->if_hdrlen = 0;
        ifp->if_addrlen = 0;
        ifp->if_dlt = DLT_CAN_SOCKETCAN;
        ifp->if_output = NULL; /* unused */
        IFQ_SET_READY(&ifp->if_snd);
        if_alloc_sadl(ifp);
        bpf_attach(ifp, DLT_CAN_SOCKETCAN, 0);
}

void
can_ifdetach(struct ifnet *ifp)
{
        bpf_detach(ifp);
        if_detach(ifp);
}

void
can_ifinit_timings(struct canif_softc *csc)
{
        /* uninitialized parameters is all-one */
        memset(&csc->csc_timings, 0xff, sizeof(struct can_link_timings));
}

static int
can_output(struct mbuf *m, struct canpcb *canp)
{
        struct ifnet *ifp;
        struct m_tag *sotag;
        struct canif_softc *csc;

        if (canp == NULL) {
                printf("can_output: no pcb\n");
                return EINVAL;
        }
        ifp = canp->canp_ifp;
        if (ifp == 0) {
                return EDESTADDRREQ;
        }
        csc = ifp->if_softc;
        if (csc && (csc->csc_linkmodes & CAN_LINKMODE_LISTENONLY)) {
                return ENETUNREACH;
        }
                
        sotag = m_tag_get(PACKET_TAG_SO, sizeof(struct socket *), PR_NOWAIT);
        if (sotag == NULL) {
                if_statinc(ifp, if_oerrors);
                return ENOMEM;
        }
        mutex_enter(&canp->canp_mtx);
        canp_ref(canp);
        mutex_exit(&canp->canp_mtx);
        *(struct canpcb **)(sotag + 1) = canp;
        m_tag_prepend(m, sotag);

        if (m->m_len <= ifp->if_mtu) {
                can_output_cnt++;
                return ifq_enqueue(ifp, m);
        } else
                return EMSGSIZE;
}

/*
 * cleanup mbuf tag, keeping the PACKET_TAG_SO tag
 */
void
can_mbuf_tag_clean(struct mbuf *m)
{
        struct m_tag *sotag;

        sotag = m_tag_find(m, PACKET_TAG_SO);
        if (sotag)
                m_tag_unlink(m, sotag);

        m_tag_delete_chain(m);
        if (sotag)
                m_tag_prepend(m, sotag);
}

/*
 * Process a received CAN frame
 * the packet is in the mbuf chain m with
 * the CAN header.
 */
void
can_input(struct ifnet *ifp, struct mbuf *m)
{
        if ((ifp->if_flags & IFF_UP) == 0) {
                m_freem(m);
                return;
        }

        const int pktlen = m->m_pkthdr.len;
        if (__predict_false(!pktq_enqueue(can_pktq, m, 0))) {
                m_freem(m);
        } else {
                if_statadd2(ifp, if_ipackets, 1, if_ibytes, pktlen);
        }
}

static void
canintr(void *arg __unused)
{
        int             rcv_ifindex;
        struct mbuf    *m;

        struct sockaddr_can from;
        struct canpcb   *canp;
        struct m_tag    *sotag;
        struct canpcb   *sender_canp;

        mutex_enter(softnet_lock);
        while ((m = pktq_dequeue(can_pktq)) != NULL) {
#if 0
                m_claim(m, &can_rx_mowner);
#endif
                sotag = m_tag_find(m, PACKET_TAG_SO);
                if (sotag) {
                        sender_canp = *(struct canpcb **)(sotag + 1);
                        m_tag_delete(m, sotag);
                        KASSERT(sender_canp != NULL);
                        /* if the sender doesn't want loopback, don't do it */
                        if ((sender_canp->canp_flags & CANP_NO_LOOPBACK) != 0) {
                                m_freem(m);
                                canp_unref(sender_canp);
                                continue;
                        }
                } else {
                        sender_canp = NULL;
                }
                memset(&from, 0, sizeof(struct sockaddr_can));
                rcv_ifindex = m->m_pkthdr.rcvif_index;
                from.can_ifindex = rcv_ifindex;
                from.can_len = sizeof(struct sockaddr_can);
                from.can_family = AF_CAN;

                TAILQ_FOREACH(canp, &cbtable.canpt_queue, canp_queue) {
                        struct mbuf *mc;

                        mutex_enter(&canp->canp_mtx);
                        /* skip if we're detached */
                        if (canp->canp_state == CANP_DETACHED) {
                                mutex_exit(&canp->canp_mtx);
                                continue;
                        }

                        /* don't loop back to sockets on other interfaces */
                        if (canp->canp_ifp != NULL &&
                            canp->canp_ifp->if_index != rcv_ifindex) {
                                mutex_exit(&canp->canp_mtx);
                                continue;
                        }
                        /* don't loop back to myself if I don't want it */
                        if (canp == sender_canp &&
                            (canp->canp_flags & CANP_RECEIVE_OWN) == 0) {
                                mutex_exit(&canp->canp_mtx);
                                continue;
                        }

                        /* skip if the accept filter doen't match this pkt */
                        if (!can_pcbfilter(canp, m)) {
                                mutex_exit(&canp->canp_mtx);
                                continue;
                        }

                        if (TAILQ_NEXT(canp, canp_queue) != NULL) {
                                /*
                                 * we can't be sure we won't need 
                                 * the original mbuf later so copy 
                                 */
                                mc = m_copypacket(m, M_NOWAIT);
                                if (mc == NULL) {
                                        /* deliver this mbuf and abort */
                                        mc = m;
                                        m = NULL;
                                }
                        } else {
                                mc = m;
                                m = NULL;
                        }
                        if (sbappendaddr(&canp->canp_socket->so_rcv,
                                         (struct sockaddr *) &from, mc,
                                         (struct mbuf *) 0) == 0) {
                                soroverflow(canp->canp_socket);
                                m_freem(mc);
                        } else
                                sorwakeup(canp->canp_socket);
                        mutex_exit(&canp->canp_mtx);
                        if (m == NULL)
                                break;
                }
                if (sender_canp) {
                        canp_unref(sender_canp);
                }
                /* If it didn't go anywhere just delete it */
                m_freem(m);
        }
        mutex_exit(softnet_lock);
}

void
can_bpf_mtap(struct ifnet *ifp, struct mbuf *m, bool do_softint)
{
        /* bpf wants the CAN id in network byte order */
        struct can_frame *cf;
        canid_t oid;

        cf = mtod(m, struct can_frame *);
        oid = cf->can_id;
        cf->can_id = htonl(oid);
        /* Assume the direction is input when do_softint is set. */
        if (do_softint)
                bpf_mtap_softint(ifp, m);
        else
                bpf_mtap(ifp, m, BPF_D_OUT);
        cf->can_id = oid;
}

static int
can_attach(struct socket *so, int proto)
{
        int error;

        KASSERT(sotocanpcb(so) == NULL);

        /* Assign the lock (must happen even if we will error out). */
        sosetlock(so);

#ifdef MBUFTRACE
        so->so_mowner = &can_mowner;
        so->so_rcv.sb_mowner = &can_rx_mowner;
        so->so_snd.sb_mowner = &can_tx_mowner;
#endif
        if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
                error = soreserve(so, can_sendspace, can_recvspace);
                if (error) {
                        return error;
                }
        }

        error = can_pcballoc(so, &cbtable);
        if (error) {
                return error;
        }
        KASSERT(solocked(so));

        return error;
}

static void
can_detach(struct socket *so)
{
        struct canpcb *canp;

        KASSERT(solocked(so));
        canp = sotocanpcb(so);
        can_pcbdetach(canp);
}

static int
can_accept(struct socket *so, struct sockaddr *nam)
{
        KASSERT(solocked(so));

        panic("can_accept");

        return EOPNOTSUPP;
}

static int
can_bind(struct socket *so, struct sockaddr *nam, struct lwp *l)
{
        struct canpcb *canp = sotocanpcb(so);
        struct sockaddr_can *scan = (struct sockaddr_can *)nam;

        KASSERT(solocked(so));
        KASSERT(nam != NULL);

        return can_pcbbind(canp, scan, l);
}

static int
can_listen(struct socket *so, struct lwp *l)
{
        KASSERT(solocked(so));

        return EOPNOTSUPP;
}

static int
can_connect(struct socket *so, struct sockaddr *nam, struct lwp *l)
{
        struct canpcb *canp = sotocanpcb(so);
        int error = 0;

        KASSERT(solocked(so));
        KASSERT(canp != NULL);
        KASSERT(nam != NULL);

        error = can_pcbconnect(canp, (struct sockaddr_can *)nam);
        if (! error)
                soisconnected(so);
        return error;
}

static int
can_connect2(struct socket *so, struct socket *so2)
{
        KASSERT(solocked(so));

        return EOPNOTSUPP;
}

static int
can_disconnect(struct socket *so)
{
        struct canpcb *canp = sotocanpcb(so);

        KASSERT(solocked(so));
        KASSERT(canp != NULL);

        /*soisdisconnected(so);*/
        so->so_state &= ~SS_ISCONNECTED;        /* XXX */
        can_pcbdisconnect(canp);
        return 0;
}

static int
can_shutdown(struct socket *so)
{
        KASSERT(solocked(so));

        socantsendmore(so);
        return 0;
}

static int
can_abort(struct socket *so)
{
        KASSERT(solocked(so));

        panic("can_abort");

        return EOPNOTSUPP;
}

static int
can_ioctl(struct socket *so, u_long cmd, void *nam, struct ifnet *ifp)
{
        return can_control(so, cmd, nam, ifp);
}

static int
can_stat(struct socket *so, struct stat *ub)
{
        KASSERT(solocked(so));

        /* stat: don't bother with a blocksize. */
        return 0;
}

static int
can_peeraddr(struct socket *so, struct sockaddr *nam)
{
        KASSERT(solocked(so));
        KASSERT(sotocanpcb(so) != NULL);
        KASSERT(nam != NULL);

        return EOPNOTSUPP;
}

static int
can_sockaddr(struct socket *so, struct sockaddr *nam)
{
        KASSERT(solocked(so));
        KASSERT(sotocanpcb(so) != NULL);
        KASSERT(nam != NULL);

        can_setsockaddr(sotocanpcb(so), (struct sockaddr_can *)nam);

        return 0;
}

static int
can_rcvd(struct socket *so, int flags, struct lwp *l)
{
        KASSERT(solocked(so));

        return EOPNOTSUPP;
}

static int
can_recvoob(struct socket *so, struct mbuf *m, int flags)
{
        KASSERT(solocked(so));

        return EOPNOTSUPP;
}

static int
can_send(struct socket *so, struct mbuf *m, struct sockaddr *nam,
    struct mbuf *control, struct lwp *l)
{
        struct canpcb *canp = sotocanpcb(so);
        int error = 0;
        int s;

        if (control && control->m_len) {
                m_freem(control);
                error = EINVAL;
                goto err;
        }
        if (m->m_len > sizeof(struct can_frame) ||
           m->m_len < offsetof(struct can_frame, can_dlc)) {
                error = EINVAL;
                goto err;
        }

        /* we expect all data in the first mbuf */
        KASSERT((m->m_flags & M_PKTHDR) != 0);
        KASSERT(m->m_len == m->m_pkthdr.len);

        if (nam) {
                if ((so->so_state & SS_ISCONNECTED) != 0) {
                        error = EISCONN;
                        goto err;
                }
                s = splnet();
                error = can_pcbbind(canp, (struct sockaddr_can *)nam, l);
                if (error) {
                        splx(s);
                        goto err;
                }
        } else {
                if ((so->so_state & SS_ISCONNECTED) == 0) {
                        error =  EDESTADDRREQ;
                        goto err;
                }
        }
        error = can_output(m, canp);
        if (nam) {
                struct sockaddr_can lscan;
                memset(&lscan, 0, sizeof(lscan));
                lscan.can_family = AF_CAN;
                lscan.can_len = sizeof(lscan);
                can_pcbbind(canp, &lscan, l);
        }
        if (error)
                goto err;
        return 0;

err:
        m_freem(m);
        return error;
}

static int
can_sendoob(struct socket *so, struct mbuf *m, struct mbuf *control)
{
        KASSERT(solocked(so));

        m_freem(m);
        m_freem(control);

        return EOPNOTSUPP;
}

#if 0
int
can_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,
           struct mbuf *control, struct lwp *l)
{
        struct canpcb *canp;
        int s;
        int error = 0;

        if (req == PRU_CONTROL)
                 return (can_control(so, (long)m, nam,
                     (struct ifnet *)control));

        if (req == PRU_PURGEIF) {
#if 0
                can_pcbpurgeif0(&udbtable, (struct ifnet *)control);
                can_purgeif((struct ifnet *)control);
                can_pcbpurgeif(&udbtable, (struct ifnet *)control);
#endif
                return (0);
        }

        s = splsoftnet();
        canp = sotocanpcb(so);
#ifdef DIAGNOSTIC
        if (req != PRU_SEND && req != PRU_SENDOOB && control)
                panic("can_usrreq: unexpected control mbuf");
#endif
        if (canp == 0 && req != PRU_ATTACH) {
                printf("can_usrreq: no pcb %p %d\n", canp, req);
                error = EINVAL;
                goto release;
        }

        /*
         * Note: need to block can_input while changing
         * the can pcb queue and/or pcb addresses.
         */
        switch (req) {

          case PRU_ATTACH:
              if (canp != 0) {
                         error = EISCONN;
                         break;
                 }
#ifdef MBUFTRACE
                so->so_mowner = &can_mowner;
                so->so_rcv.sb_mowner = &can_rx_mowner;
                so->so_snd.sb_mowner = &can_tx_mowner;
#endif
                if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
                        error = soreserve(so, can_sendspace, can_recvspace);
                        if (error)
                                break;
                }
                error = can_pcballoc(so, &cbtable);
                if (error)
                        break;
                canp = sotocanpcb(so);
#if 0
                inp->inp_ip.ip_ttl = ip_defttl;
#endif
                break;

        case PRU_DETACH:
                can_pcbdetach(canp);
                break;

        case PRU_BIND:
                error = can_pcbbind(canp, nam, l);
                break;

        case PRU_LISTEN:
                error = EOPNOTSUPP;
                break;

        case PRU_CONNECT:
                error = can_pcbconnect(canp, nam);
                if (error)
                        break;
                soisconnected(so);
                break;

        case PRU_CONNECT2:
                error = EOPNOTSUPP;
                break;

        case PRU_DISCONNECT:
                /*soisdisconnected(so);*/
                so->so_state &= ~SS_ISCONNECTED;        /* XXX */
                can_pcbdisconnect(canp);
                can_pcbstate(canp, CANP_BOUND);         /* XXX */
                break;

        case PRU_SHUTDOWN:
                socantsendmore(so);
                break;

        case PRU_RCVD:
                error = EOPNOTSUPP;
                break;

        case PRU_SEND:
                break;

        case PRU_SENSE:
                /*
                 * stat: don't bother with a blocksize.
                 */
                splx(s);
                return (0);

        case PRU_RCVOOB:
                error =  EOPNOTSUPP;
                break;

        case PRU_SENDOOB:
                m_freem(control);
                m_freem(m);
                error =  EOPNOTSUPP;
                break;

        case PRU_SOCKADDR:

                break;

        case PRU_PEERADDR:
                error =  EOPNOTSUPP;
                break;

        default:
                panic("can_usrreq");
        }

release:
        splx(s);
        return (error);
}
#endif

#if 0
static void
can_notify(struct canpcb *canp, int errno)
{

        canp->canp_socket->so_error = errno;
        sorwakeup(canp->canp_socket);
        sowwakeup(canp->canp_socket);
}

void *
can_ctlinput(int cmd, struct sockaddr *sa, void *v)
{
        struct ip *ip = v;
        struct canhdr *uh;
        void (*notify) __P((struct inpcb *, int)) = can_notify;
        int errno;

        if (sa->sa_family != AF_CAN
         || sa->sa_len != sizeof(struct sockaddr_can))
                return NULL;
        if ((unsigned)cmd >= PRC_NCMDS)
                return NULL;
        errno = inetctlerrmap[cmd];
        if (PRC_IS_REDIRECT(cmd))
                notify = inpcb_rtchange, ip = 0;
        else if (cmd == PRC_HOSTDEAD)
                ip = 0;
        else if (errno == 0)
                return NULL;
        if (ip) {
                uh = (struct canhdr *)((caddr_t)ip + (ip->ip_hl << 2));
                inpcb_notify(&udbtable, satosin(sa)->sin_addr, uh->uh_dport,
                    ip->ip_src, uh->uh_sport, errno, notify);

                /* XXX mapped address case */
        } else
                can_pcbnotifyall(&cbtable, satoscan(sa)->scan_addr, errno,
                    notify);
        return NULL;
}
#endif

static int
can_raw_getop(struct canpcb *canp, struct sockopt *sopt)
{
        int optval = 0;
        int error;

        switch (sopt->sopt_name) {
        case CAN_RAW_LOOPBACK:
                optval = (canp->canp_flags & CANP_NO_LOOPBACK) ? 0 : 1;
                error = sockopt_set(sopt, &optval, sizeof(optval));
                break;
        case CAN_RAW_RECV_OWN_MSGS: 
                optval = (canp->canp_flags & CANP_RECEIVE_OWN) ? 1 : 0;
                error = sockopt_set(sopt, &optval, sizeof(optval));
                break;
        case CAN_RAW_FILTER:
                error = sockopt_set(sopt, canp->canp_filters,
                    sizeof(struct can_filter) * canp->canp_nfilters);
                break;
        default:
                error = ENOPROTOOPT;
                break;
        }
        return error;
}

static int
can_raw_setop(struct canpcb *canp, struct sockopt *sopt)
{
        int optval = 0;
        int error;

        switch (sopt->sopt_name) {
        case CAN_RAW_LOOPBACK:
                error = sockopt_getint(sopt, &optval);
                if (error == 0) {
                        if (optval) {
                                canp->canp_flags &= ~CANP_NO_LOOPBACK;
                        } else {
                                canp->canp_flags |= CANP_NO_LOOPBACK;
                        }
                }
                break;
        case CAN_RAW_RECV_OWN_MSGS: 
                error = sockopt_getint(sopt, &optval);
                if (error == 0) {
                        if (optval) {
                                canp->canp_flags |= CANP_RECEIVE_OWN;
                        } else {
                                canp->canp_flags &= ~CANP_RECEIVE_OWN;
                        }
                }
                break;
        case CAN_RAW_FILTER:
                {
                int nfilters = sopt->sopt_size / sizeof(struct can_filter);
                if (sopt->sopt_size % sizeof(struct can_filter) != 0)
                        return EINVAL;
                error = can_pcbsetfilter(canp, sopt->sopt_data, nfilters);
                break;
                }
        default:
                error = ENOPROTOOPT;
                break;
        }
        return error;
}

/*
 * Called by getsockopt and setsockopt.
 *
 */
int
can_ctloutput(int op, struct socket *so, struct sockopt *sopt)
{
        struct canpcb *canp;
        int error;
        int s;

        if (so->so_proto->pr_domain->dom_family != PF_CAN)      
                return EAFNOSUPPORT;

        if (sopt->sopt_level != SOL_CAN_RAW)
                return EINVAL;

        s = splsoftnet();
        canp = sotocanpcb(so);
        if (canp == NULL) {
                splx(s);
                return ECONNRESET;
        }

        if (op == PRCO_SETOPT) {
                error = can_raw_setop(canp, sopt);
        } else if (op ==  PRCO_GETOPT) {
                error = can_raw_getop(canp, sopt);
        } else {
                error = EINVAL;
        }
        splx(s);
        return error;
}

PR_WRAP_USRREQS(can)
#define can_attach      can_attach_wrapper
#define can_detach      can_detach_wrapper
#define can_accept      can_accept_wrapper
#define can_bind        can_bind_wrapper
#define can_listen      can_listen_wrapper
#define can_connect     can_connect_wrapper
#define can_connect2    can_connect2_wrapper
#define can_disconnect  can_disconnect_wrapper
#define can_shutdown    can_shutdown_wrapper
#define can_abort       can_abort_wrapper
#define can_ioctl       can_ioctl_wrapper
#define can_stat        can_stat_wrapper
#define can_peeraddr    can_peeraddr_wrapper
#define can_sockaddr    can_sockaddr_wrapper
#define can_rcvd        can_rcvd_wrapper
#define can_recvoob     can_recvoob_wrapper
#define can_send        can_send_wrapper
#define can_sendoob     can_sendoob_wrapper
#define can_purgeif     can_purgeif_wrapper

const struct pr_usrreqs can_usrreqs = {
        .pr_attach      = can_attach,
        .pr_detach      = can_detach,
        .pr_accept      = can_accept,
        .pr_bind        = can_bind,
        .pr_listen      = can_listen,
        .pr_connect     = can_connect,
        .pr_connect2    = can_connect2,
        .pr_disconnect  = can_disconnect,
        .pr_shutdown    = can_shutdown,
        .pr_abort       = can_abort,
        .pr_ioctl       = can_ioctl,
        .pr_stat        = can_stat,
        .pr_peeraddr    = can_peeraddr,
        .pr_sockaddr    = can_sockaddr,
        .pr_rcvd        = can_rcvd,
        .pr_recvoob     = can_recvoob,
        .pr_send        = can_send,
        .pr_sendoob     = can_sendoob,
        .pr_purgeif     = can_purgeif,
};