/* $NetBSD: natm.c,v 1.5 1996/11/09 03:26:26 chuck Exp $ */ /* $FreeBSD: src/sys/netnatm/natm.c,v 1.12 2000/02/13 03:32:03 peter Exp $ */ /* $DragonFly: src/sys/netproto/natm/natm.c,v 1.31 2008/09/24 14:26:39 sephe Exp $ */ /* * * Copyright (c) 1996 Charles D. Cranor and Washington University. * All rights reserved. * * 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. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Charles D. Cranor and * Washington University. * 4. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. */ /* * natm.c: native mode ATM access (both aal0 and aal5). */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "natm.h" static u_long natm5_sendspace = 16*1024; static u_long natm5_recvspace = 16*1024; static u_long natm0_sendspace = 16*1024; static u_long natm0_recvspace = 16*1024; /* * user requests */ #ifdef FREEBSD_USRREQS /* * FreeBSD new usrreqs supersedes pr_usrreq. */ static int natm_usr_attach (struct socket *, int, struct pru_attach_info *); static int natm_usr_detach (struct socket *); static int natm_usr_connect (struct socket *, struct sockaddr *, struct thread *); static int natm_usr_disconnect (struct socket *); static int natm_usr_shutdown (struct socket *); static int natm_usr_send (struct socket *, int, struct mbuf *, struct sockaddr *, struct mbuf *, struct thread *); static int natm_usr_peeraddr (struct socket *, struct sockaddr **); static int natm_usr_control (struct socket *, u_long, caddr_t, struct ifnet *, struct thread *); static int natm_usr_abort (struct socket *); static int natm_usr_bind (struct socket *, struct sockaddr *, struct thread *); static int natm_usr_sockaddr (struct socket *, struct sockaddr **); static int natm_usr_attach(struct socket *so, int proto, struct pru_attach_info *ai) { struct natmpcb *npcb; int error = 0; crit_enter(); npcb = (struct natmpcb *) so->so_pcb; if (npcb) { error = EISCONN; goto out; } if (so->so_snd.ssb_hiwat == 0 || so->so_rcv.ssb_hiwat == 0) { if (proto == PROTO_NATMAAL5) error = soreserve(so, natm5_sendspace, natm5_recvspace, ai->sb_rlimit); else error = soreserve(so, natm0_sendspace, natm0_recvspace, ai->sb_rlimit); if (error) goto out; } so->so_pcb = (caddr_t) (npcb = npcb_alloc(M_WAITOK)); npcb->npcb_socket = so; out: crit_exit(); return (error); } static int natm_usr_detach(struct socket *so) { struct natmpcb *npcb; int error = 0; crit_enter(); npcb = (struct natmpcb *) so->so_pcb; if (npcb == NULL) { error = EINVAL; goto out; } /* * we turn on 'drain' *before* we sofree. */ npcb_free(npcb, NPCB_DESTROY); /* drain */ so->so_pcb = NULL; sofree(so); out: crit_exit(); return (error); } static int natm_usr_connect(struct socket *so, struct sockaddr *nam, struct thread *td) { struct natmpcb *npcb; struct sockaddr_natm *snatm; struct atm_pseudoioctl api; struct ifnet *ifp; int error = 0; int proto; crit_enter(); proto = so->so_proto->pr_protocol; npcb = (struct natmpcb *) so->so_pcb; if (npcb == NULL) { error = EINVAL; goto out; } /* * validate nam and npcb */ snatm = (struct sockaddr_natm *)nam; if (snatm->snatm_len != sizeof(*snatm) || (npcb->npcb_flags & NPCB_FREE) == 0) { error = EINVAL; goto out; } if (snatm->snatm_family != AF_NATM) { error = EAFNOSUPPORT; goto out; } snatm->snatm_if[IFNAMSIZ-1] = '\0'; /* XXX ensure null termination since ifunit() uses strcmp */ /* * convert interface string to ifp, validate. */ ifp = ifunit(snatm->snatm_if); if (ifp == NULL || (ifp->if_flags & IFF_RUNNING) == 0) { error = ENXIO; goto out; } if (ifp->if_output != atm_output) { error = EAFNOSUPPORT; goto out; } /* * register us with the NATM PCB layer */ if (npcb_add(npcb, ifp, snatm->snatm_vci, snatm->snatm_vpi) != npcb) { error = EADDRINUSE; goto out; } /* * enable rx */ ATM_PH_FLAGS(&api.aph) = (proto == PROTO_NATMAAL5) ? ATM_PH_AAL5 : 0; ATM_PH_VPI(&api.aph) = npcb->npcb_vpi; ATM_PH_SETVCI(&api.aph, npcb->npcb_vci); api.rxhand = npcb; lwkt_serialize_enter(ifp->if_serializer); if (ifp->if_ioctl == NULL || ifp->if_ioctl(ifp, SIOCATMENA, (caddr_t) &api, td->td_proc->p_ucred) != 0) { lwkt_serialize_exit(ifp->if_serializer); npcb_free(npcb, NPCB_REMOVE); error = EIO; goto out; } lwkt_serialize_exit(ifp->if_serializer); soisconnected(so); out: crit_exit(); return (error); } static int natm_usr_disconnect(struct socket *so) { struct natmpcb *npcb; struct atm_pseudoioctl api; struct ifnet *ifp; int error = 0; crit_enter(); npcb = (struct natmpcb *) so->so_pcb; if (npcb == NULL) { error = EINVAL; goto out; } if ((npcb->npcb_flags & NPCB_CONNECTED) == 0) { kprintf("natm: disconnected check\n"); error = EIO; goto out; } ifp = npcb->npcb_ifp; /* * disable rx */ ATM_PH_FLAGS(&api.aph) = ATM_PH_AAL5; ATM_PH_VPI(&api.aph) = npcb->npcb_vpi; ATM_PH_SETVCI(&api.aph, npcb->npcb_vci); api.rxhand = npcb; if (ifp->if_ioctl != NULL) { lwkt_serialize_enter(ifp->if_serializer); ifp->if_ioctl(ifp, SIOCATMDIS, (caddr_t) &api, (struct ucred *)NULL); lwkt_serialize_exit(ifp->if_serializer); } npcb_free(npcb, NPCB_REMOVE); soisdisconnected(so); out: crit_exit(); return (error); } static int natm_usr_shutdown(struct socket *so) { socantsendmore(so); return 0; } static int natm_usr_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam, struct mbuf *control, struct thread *td) { struct natmpcb *npcb; struct atm_pseudohdr *aph; int error = 0; int proto = so->so_proto->pr_protocol; crit_enter(); npcb = (struct natmpcb *) so->so_pcb; if (npcb == NULL) { error = EINVAL; goto out; } if (control && control->m_len) { m_freem(control); m_freem(m); error = EINVAL; goto out; } /* * send the data. we must put an atm_pseudohdr on first */ M_PREPEND(m, sizeof(*aph), M_WAITOK); if (m == NULL) { error = ENOBUFS; goto out; } aph = mtod(m, struct atm_pseudohdr *); ATM_PH_VPI(aph) = npcb->npcb_vpi; ATM_PH_SETVCI(aph, npcb->npcb_vci); ATM_PH_FLAGS(aph) = (proto == PROTO_NATMAAL5) ? ATM_PH_AAL5 : 0; error = atm_output(npcb->npcb_ifp, m, NULL, NULL); out: crit_exit(); return (error); } static int natm_usr_peeraddr(struct socket *so, struct sockaddr **nam) { struct natmpcb *npcb; struct sockaddr_natm *snatm, ssnatm; int error = 0; crit_enter(); npcb = (struct natmpcb *) so->so_pcb; if (npcb == NULL) { error = EINVAL; goto out; } snatm = &ssnatm; bzero(snatm, sizeof(*snatm)); snatm->snatm_len = sizeof(*snatm); snatm->snatm_family = AF_NATM; strlcpy(snatm->snatm_if, npcb->npcb_ifp->if_xname, sizeof(snatm->snatm_if)); snatm->snatm_vci = npcb->npcb_vci; snatm->snatm_vpi = npcb->npcb_vpi; *nam = dup_sockaddr((struct sockaddr *)snatm); out: crit_exit(); return (error); } static int natm_usr_control(struct socket *so, u_long cmd, caddr_t arg, struct ifnet *ifp, struct thread *td) { struct natmpcb *npcb; struct atm_rawioctl ario; int error = 0; npcb = (struct natmpcb *) so->so_pcb; if (npcb == NULL) { error = EINVAL; goto out; } /* * raw atm ioctl. comes in as a SIOCRAWATM. we convert it to * SIOCXRAWATM and pass it to the driver. */ if (cmd == SIOCRAWATM) { if (npcb->npcb_ifp == NULL) { error = ENOTCONN; goto out; } ario.npcb = npcb; ario.rawvalue = *((int *)arg); lwkt_serialize_enter(ifp->if_serializer); error = npcb->npcb_ifp->if_ioctl(npcb->npcb_ifp, SIOCXRAWATM, (caddr_t) &ario, td->td_proc->p_ucred); lwkt_serialize_exit(ifp->if_serializer); if (!error) { if (ario.rawvalue) npcb->npcb_flags |= NPCB_RAW; else npcb->npcb_flags &= ~(NPCB_RAW); } } else error = EOPNOTSUPP; out: return (error); } static int natm_usr_abort(struct socket *so) { return natm_usr_shutdown(so); } static int natm_usr_bind(struct socket *so, struct sockaddr *nam, struct thread *td) { return EOPNOTSUPP; } static int natm_usr_sockaddr(struct socket *so, struct sockaddr **nam) { return EOPNOTSUPP; } /* xxx - should be const */ struct pr_usrreqs natm_usrreqs = { .pru_abort = natm_usr_abort, .pru_accept = pru_accept_notsupp, .pru_attach = natm_usr_attach, .pru_bind = natm_usr_bind, .pru_connect = natm_usr_connect, .pru_connect2 = pru_connect2_notsupp, .pru_control = natm_usr_control, .pru_detach = natm_usr_detach, .pru_disconnect = natm_usr_disconnect, .pru_listen = pru_listen_notsupp, .pru_peeraddr = natm_usr_peeraddr, .pru_rcvd = pru_rcvd_notsupp, .pru_rcvoob = pru_rcvoob_notsupp, .pru_send = natm_usr_send, .pru_sense = pru_sense_null, .pru_shutdown = natm_usr_shutdown, .pru_sockaddr = natm_usr_sockaddr, .pru_sosend = sosend, .pru_soreceive = soreceive, .pru_sopoll = sopoll }; #else /* !FREEBSD_USRREQS */ #if defined(__NetBSD__) || defined(__OpenBSD__) int natm_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam, struct mbuf *control, struct proc *p) #elif defined(__DragonFly__) int natm_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam, struct mbuf *control) #endif { int error = 0; struct natmpcb *npcb; struct sockaddr_natm *snatm; struct atm_pseudoioctl api; struct atm_pseudohdr *aph; struct atm_rawioctl ario; struct ifnet *ifp; int proto = so->so_proto->pr_protocol; crit_enter(); npcb = (struct natmpcb *) so->so_pcb; if (npcb == NULL && req != PRU_ATTACH) { error = EINVAL; goto done; } switch (req) { case PRU_ATTACH: /* attach protocol to up */ if (npcb) { error = EISCONN; break; } if (so->so_snd.ssb_hiwat == 0 || so->so_rcv.ssb_hiwat == 0) { if (proto == PROTO_NATMAAL5) error = soreserve(so, natm5_sendspace, natm5_recvspace); else error = soreserve(so, natm0_sendspace, natm0_recvspace); if (error) break; } so->so_pcb = (caddr_t) (npcb = npcb_alloc(M_WAITOK)); npcb->npcb_socket = so; break; case PRU_DETACH: /* detach protocol from up */ /* * we turn on 'drain' *before* we sofree. */ npcb_free(npcb, NPCB_DESTROY); /* drain */ so->so_pcb = NULL; sofree(so); break; case PRU_CONNECT: /* establish connection to peer */ /* * validate nam and npcb */ if (nam->m_len != sizeof(*snatm)) { error = EINVAL; break; } snatm = mtod(nam, struct sockaddr_natm *); if (snatm->snatm_len != sizeof(*snatm) || (npcb->npcb_flags & NPCB_FREE) == 0) { error = EINVAL; break; } if (snatm->snatm_family != AF_NATM) { error = EAFNOSUPPORT; break; } snatm->snatm_if[IFNAMSIZ-1] = '\0'; /* XXX ensure null termination since ifunit() uses strcmp */ /* * convert interface string to ifp, validate. */ ifp = ifunit(snatm->snatm_if); if (ifp == NULL || (ifp->if_flags & IFF_RUNNING) == 0) { error = ENXIO; break; } if (ifp->if_output != atm_output) { error = EAFNOSUPPORT; break; } /* * register us with the NATM PCB layer */ if (npcb_add(npcb, ifp, snatm->snatm_vci, snatm->snatm_vpi) != npcb) { error = EADDRINUSE; break; } /* * enable rx */ ATM_PH_FLAGS(&api.aph) = (proto == PROTO_NATMAAL5) ? ATM_PH_AAL5 : 0; ATM_PH_VPI(&api.aph) = npcb->npcb_vpi; ATM_PH_SETVCI(&api.aph, npcb->npcb_vci); api.rxhand = npcb; lwkt_serialize_enter(ifp->if_serializer); if (ifp->if_ioctl == NULL || ifp->if_ioctl(ifp, SIOCATMENA, (caddr_t) &api, (struct ucred *)NULL) != 0) { lwkt_serialize_exit(ifp->if_serializer); npcb_free(npcb, NPCB_REMOVE); error = EIO; break; } lwkt_serialize_exit(ifp->if_serializer); soisconnected(so); break; case PRU_DISCONNECT: /* disconnect from peer */ if ((npcb->npcb_flags & NPCB_CONNECTED) == 0) { kprintf("natm: disconnected check\n"); error = EIO; break; } ifp = npcb->npcb_ifp; /* * disable rx */ ATM_PH_FLAGS(&api.aph) = ATM_PH_AAL5; ATM_PH_VPI(&api.aph) = npcb->npcb_vpi; ATM_PH_SETVCI(&api.aph, npcb->npcb_vci); api.rxhand = npcb; lwkt_serialize_enter(ifp->if_serializer); if (ifp->if_ioctl != NULL) ifp->if_ioctl(ifp, SIOCATMDIS, (caddr_t) &api, (struct ucred *)NULL); lwkt_serialize_exit(ifp->if_serializer); npcb_free(npcb, NPCB_REMOVE); soisdisconnected(so); break; case PRU_SHUTDOWN: /* won't send any more data */ socantsendmore(so); break; case PRU_SEND: /* send this data */ if (control && control->m_len) { m_freem(control); m_freem(m); error = EINVAL; break; } /* * send the data. we must put an atm_pseudohdr on first */ M_PREPEND(m, sizeof(*aph), M_WAITOK); if (m == NULL) { error = ENOBUFS; break; } aph = mtod(m, struct atm_pseudohdr *); ATM_PH_VPI(aph) = npcb->npcb_vpi; ATM_PH_SETVCI(aph, npcb->npcb_vci); ATM_PH_FLAGS(aph) = (proto == PROTO_NATMAAL5) ? ATM_PH_AAL5 : 0; error = atm_output(npcb->npcb_ifp, m, NULL, NULL); break; case PRU_SENSE: /* return status into m */ /* return zero? */ break; case PRU_PEERADDR: /* fetch peer's address */ snatm = mtod(nam, struct sockaddr_natm *); bzero(snatm, sizeof(*snatm)); nam->m_len = snatm->snatm_len = sizeof(*snatm); snatm->snatm_family = AF_NATM; #if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) bcopy(npcb->npcb_ifp->if_xname, snatm->snatm_if, sizeof(snatm->snatm_if)); #elif defined(__DragonFly__) ksnprintf(snatm->snatm_if, sizeof(snatm->snatm_if), "%s%d", npcb->npcb_ifp->if_name, npcb->npcb_ifp->if_unit); #endif snatm->snatm_vci = npcb->npcb_vci; snatm->snatm_vpi = npcb->npcb_vpi; break; case PRU_CONTROL: /* control operations on protocol */ /* * raw atm ioctl. comes in as a SIOCRAWATM. we convert it to * SIOCXRAWATM and pass it to the driver. */ if ((u_long)m == SIOCRAWATM) { if (npcb->npcb_ifp == NULL) { error = ENOTCONN; break; } ario.npcb = npcb; ario.rawvalue = *((int *)nam); lwkt_serialize_enter(npcb->npcb_ifp->if_serializer); error = npcb->npcb_ifp->if_ioctl(npcb->npcb_ifp, SIOCXRAWATM, (caddr_t) &ario, (struct ucred *)NULL); lwkt_serialize_exit(npcb->npcb_ifp->if_serializer); if (!error) { if (ario.rawvalue) npcb->npcb_flags |= NPCB_RAW; else npcb->npcb_flags &= ~(NPCB_RAW); } break; } error = EOPNOTSUPP; break; case PRU_BIND: /* bind socket to address */ case PRU_LISTEN: /* listen for connection */ case PRU_ACCEPT: /* accept connection from peer */ case PRU_CONNECT2: /* connect two sockets */ case PRU_ABORT: /* abort (fast DISCONNECT, DETATCH) */ /* (only happens if LISTEN socket) */ case PRU_RCVD: /* have taken data; more room now */ case PRU_FASTTIMO: /* 200ms timeout */ case PRU_SLOWTIMO: /* 500ms timeout */ case PRU_RCVOOB: /* retrieve out of band data */ case PRU_SENDOOB: /* send out of band data */ case PRU_PROTORCV: /* receive from below */ case PRU_PROTOSEND: /* send to below */ case PRU_SOCKADDR: /* fetch socket's address */ #ifdef DIAGNOSTIC kprintf("natm: PRU #%d unsupported\n", req); #endif error = EOPNOTSUPP; break; default: panic("natm usrreq"); } done: crit_exit(); return(error); } #endif /* !FREEBSD_USRREQS */ /* * natm0_sysctl: not used, but here in case we want to add something * later... */ int natm0_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) { /* All sysctl names at this level are terminal. */ if (namelen != 1) return (ENOTDIR); return (ENOPROTOOPT); } /* * natm5_sysctl: not used, but here in case we want to add something * later... */ int natm5_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) { /* All sysctl names at this level are terminal. */ if (namelen != 1) return (ENOTDIR); return (ENOPROTOOPT); } static void natmintr(struct netmsg *); #if defined(__DragonFly__) static void netisr_natm_setup(void *dummy __unused) { netisr_register(NETISR_NATM, cpu0_portfn, natmintr, NETISR_FLAG_NOTMPSAFE); } SYSINIT(natm_setup, SI_BOOT2_KLD, SI_ORDER_ANY, netisr_natm_setup, NULL); #endif void natm_init(void) { LIST_INIT(&natm_pcbs); netisr_register(NETISR_NATM, cpu0_portfn, natmintr, 0); } /* * natmintr: software interrupt * * note: we expect a socket pointer in rcvif rather than an interface * pointer. we can get the interface pointer from the so's PCB if * we really need it. */ static void natmintr(struct netmsg *msg) { struct mbuf *m = ((struct netmsg_packet *)msg)->nm_packet; struct socket *so; struct natmpcb *npcb; #ifdef DIAGNOSTIC if ((m->m_flags & M_PKTHDR) == 0) panic("natmintr no HDR"); #endif npcb = (struct natmpcb *) m->m_pkthdr.rcvif; /* XXX: overloaded */ so = npcb->npcb_socket; crit_enter(); npcb->npcb_inq--; crit_exit(); if (npcb->npcb_flags & NPCB_DRAIN) { m_freem(m); if (npcb->npcb_inq == 0) FREE(npcb, M_PCB); /* done! */ goto out; } if (npcb->npcb_flags & NPCB_FREE) { m_freem(m); /* drop */ goto out; } #ifdef NEED_TO_RESTORE_IFP m->m_pkthdr.rcvif = npcb->npcb_ifp; #else #ifdef DIAGNOSTIC m->m_pkthdr.rcvif = NULL; /* null it out to be safe */ #endif #endif if (ssb_space(&so->so_rcv) > m->m_pkthdr.len || ((npcb->npcb_flags & NPCB_RAW) != 0 && so->so_rcv.ssb_cc < NPCB_RAWCC) ) { #ifdef NATM_STAT natm_sookcnt++; natm_sookbytes += m->m_pkthdr.len; #endif sbappendrecord(&so->so_rcv.sb, m); sorwakeup(so); } else { #ifdef NATM_STAT natm_sodropcnt++; natm_sodropbytes += m->m_pkthdr.len; #endif m_freem(m); } out: ; /* msg was embedded in the mbuf, do not reply! */ }