ac45e92ff2
than an int, as an error here is not meaningful. Modify soabort() to unconditionally free the socket on the return of pru_abort(), and modify most protocols to no longer conditionally free the socket, since the caller will do this. This commit likely leaves parts of netinet and netinet6 in a situation where they may panic or leak memory, as they have not are not fully updated by this commit. This will be corrected shortly in followup commits to these components. MFC after: 3 months
453 lines
11 KiB
C
453 lines
11 KiB
C
/* $NetBSD: natm.c,v 1.5 1996/11/09 03:26:26 chuck Exp $ */
|
|
/*-
|
|
*
|
|
* Copyright (c) 1996 Charles D. Cranor and Washington University.
|
|
* Copyright (c) 2005-2006 Robert N. M. Watson
|
|
* 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 <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/conf.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/lock.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/mbuf.h>
|
|
#include <sys/protosw.h>
|
|
#include <sys/signalvar.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/socketvar.h>
|
|
#include <sys/sockio.h>
|
|
#include <sys/sx.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/sysctl.h>
|
|
|
|
#include <net/if.h>
|
|
#include <net/if_atm.h>
|
|
#include <net/netisr.h>
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <netnatm/natm.h>
|
|
|
|
static const u_long natm5_sendspace = 16*1024;
|
|
static const u_long natm5_recvspace = 16*1024;
|
|
|
|
static const u_long natm0_sendspace = 16*1024;
|
|
static const u_long natm0_recvspace = 16*1024;
|
|
|
|
struct mtx natm_mtx;
|
|
|
|
/*
|
|
* user requests
|
|
*/
|
|
static int natm_usr_attach(struct socket *, int, d_thread_t *);
|
|
static int natm_usr_detach(struct socket *);
|
|
static int natm_usr_connect(struct socket *, struct sockaddr *, d_thread_t *);
|
|
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 *, d_thread_t *);
|
|
static int natm_usr_peeraddr(struct socket *, struct sockaddr **);
|
|
static int natm_usr_control(struct socket *, u_long, caddr_t,
|
|
struct ifnet *, d_thread_t *);
|
|
static void natm_usr_abort(struct socket *);
|
|
static int natm_usr_bind(struct socket *, struct sockaddr *, d_thread_t *);
|
|
static int natm_usr_sockaddr(struct socket *, struct sockaddr **);
|
|
|
|
static int
|
|
natm_usr_attach(struct socket *so, int proto, d_thread_t *p)
|
|
{
|
|
struct natmpcb *npcb;
|
|
int error = 0;
|
|
|
|
npcb = (struct natmpcb *)so->so_pcb;
|
|
KASSERT(npcb == NULL, ("natm_usr_attach: so_pcb != NULL"));
|
|
|
|
if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
|
|
if (proto == PROTO_NATMAAL5)
|
|
error = soreserve(so, natm5_sendspace, natm5_recvspace);
|
|
else
|
|
error = soreserve(so, natm0_sendspace, natm0_recvspace);
|
|
if (error)
|
|
goto out;
|
|
}
|
|
|
|
so->so_pcb = (caddr_t) (npcb = npcb_alloc(M_WAITOK));
|
|
npcb->npcb_socket = so;
|
|
out:
|
|
return (error);
|
|
}
|
|
|
|
static int
|
|
natm_usr_detach(struct socket *so)
|
|
{
|
|
struct natmpcb *npcb;
|
|
|
|
NATM_LOCK();
|
|
npcb = (struct natmpcb *)so->so_pcb;
|
|
KASSERT(npcb != NULL, ("natm_usr_detach: npcb == NULL"));
|
|
npcb_free(npcb, NPCB_DESTROY); /* drain */
|
|
so->so_pcb = NULL;
|
|
NATM_UNLOCK();
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
natm_usr_connect(struct socket *so, struct sockaddr *nam, d_thread_t *p)
|
|
{
|
|
struct natmpcb *npcb;
|
|
struct sockaddr_natm *snatm;
|
|
struct atmio_openvcc op;
|
|
struct ifnet *ifp;
|
|
int error = 0;
|
|
int proto = so->so_proto->pr_protocol;
|
|
|
|
NATM_LOCK();
|
|
npcb = (struct natmpcb *)so->so_pcb;
|
|
KASSERT(npcb != NULL, ("natm_usr_connect: npcb == NULL"));
|
|
|
|
/*
|
|
* 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_drv_flags & IFF_DRV_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;
|
|
}
|
|
NATM_UNLOCK();
|
|
|
|
/*
|
|
* open the channel
|
|
*/
|
|
bzero(&op, sizeof(op));
|
|
op.rxhand = npcb;
|
|
op.param.flags = ATMIO_FLAG_PVC;
|
|
op.param.vpi = npcb->npcb_vpi;
|
|
op.param.vci = npcb->npcb_vci;
|
|
op.param.rmtu = op.param.tmtu = ifp->if_mtu;
|
|
op.param.aal = (proto == PROTO_NATMAAL5) ? ATMIO_AAL_5 : ATMIO_AAL_0;
|
|
op.param.traffic = ATMIO_TRAFFIC_UBR;
|
|
|
|
IFF_LOCKGIANT(ifp);
|
|
if (ifp->if_ioctl == NULL ||
|
|
ifp->if_ioctl(ifp, SIOCATMOPENVCC, (caddr_t)&op) != 0) {
|
|
IFF_UNLOCKGIANT(ifp);
|
|
error = EIO;
|
|
goto out;
|
|
}
|
|
IFF_UNLOCKGIANT(ifp);
|
|
|
|
soisconnected(so);
|
|
|
|
out:
|
|
return (error);
|
|
}
|
|
|
|
static int
|
|
natm_usr_disconnect(struct socket *so)
|
|
{
|
|
struct natmpcb *npcb;
|
|
struct atmio_closevcc cl;
|
|
struct ifnet *ifp;
|
|
int error = 0;
|
|
|
|
NATM_LOCK();
|
|
npcb = (struct natmpcb *)so->so_pcb;
|
|
KASSERT(npcb != NULL, ("natm_usr_disconnect: npcb == NULL"));
|
|
|
|
if ((npcb->npcb_flags & NPCB_CONNECTED) == 0) {
|
|
printf("natm: disconnected check\n");
|
|
error = EIO;
|
|
goto out;
|
|
}
|
|
ifp = npcb->npcb_ifp;
|
|
|
|
/*
|
|
* disable rx
|
|
*/
|
|
cl.vpi = npcb->npcb_vpi;
|
|
cl.vci = npcb->npcb_vci;
|
|
NATM_UNLOCK();
|
|
if (ifp->if_ioctl != NULL) {
|
|
IFF_LOCKGIANT(ifp);
|
|
ifp->if_ioctl(ifp, SIOCATMCLOSEVCC, (caddr_t)&cl);
|
|
IFF_UNLOCKGIANT(ifp);
|
|
}
|
|
NATM_LOCK();
|
|
|
|
soisdisconnected(so);
|
|
|
|
out:
|
|
NATM_UNLOCK();
|
|
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, d_thread_t *p)
|
|
{
|
|
struct natmpcb *npcb;
|
|
struct atm_pseudohdr *aph;
|
|
int error = 0;
|
|
int proto = so->so_proto->pr_protocol;
|
|
|
|
NATM_LOCK();
|
|
npcb = (struct natmpcb *)so->so_pcb;
|
|
KASSERT(npcb != NULL, ("natm_usr_send: npcb == NULL"));
|
|
|
|
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_DONTWAIT);
|
|
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:
|
|
NATM_UNLOCK();
|
|
return (error);
|
|
}
|
|
|
|
static int
|
|
natm_usr_peeraddr(struct socket *so, struct sockaddr **nam)
|
|
{
|
|
struct natmpcb *npcb;
|
|
struct sockaddr_natm *snatm, ssnatm;
|
|
|
|
NATM_LOCK();
|
|
npcb = (struct natmpcb *)so->so_pcb;
|
|
KASSERT(npcb != NULL, ("natm_usr_peeraddr: npcb == NULL"));
|
|
|
|
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;
|
|
NATM_UNLOCK();
|
|
*nam = sodupsockaddr((struct sockaddr *)snatm, M_WAITOK);
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
natm_usr_control(struct socket *so, u_long cmd, caddr_t arg,
|
|
struct ifnet *ifp, d_thread_t *p)
|
|
{
|
|
struct natmpcb *npcb;
|
|
int error;
|
|
|
|
npcb = (struct natmpcb *)so->so_pcb;
|
|
KASSERT(npcb != NULL, ("natm_usr_control: npcb == NULL"));
|
|
|
|
if (ifp == NULL || ifp->if_ioctl == NULL)
|
|
return (EOPNOTSUPP);
|
|
|
|
IFF_LOCKGIANT(ifp);
|
|
error = ((*ifp->if_ioctl)(ifp, cmd, arg));
|
|
IFF_UNLOCKGIANT(ifp);
|
|
return (error);
|
|
}
|
|
|
|
static void
|
|
natm_usr_abort(struct socket *so)
|
|
{
|
|
natm_usr_shutdown(so);
|
|
}
|
|
|
|
static int
|
|
natm_usr_bind(struct socket *so, struct sockaddr *nam, d_thread_t *p)
|
|
{
|
|
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_attach = natm_usr_attach,
|
|
.pru_bind = natm_usr_bind,
|
|
.pru_connect = natm_usr_connect,
|
|
.pru_control = natm_usr_control,
|
|
.pru_detach = natm_usr_detach,
|
|
.pru_disconnect = natm_usr_disconnect,
|
|
.pru_peeraddr = natm_usr_peeraddr,
|
|
.pru_send = natm_usr_send,
|
|
.pru_shutdown = natm_usr_shutdown,
|
|
.pru_sockaddr = natm_usr_sockaddr,
|
|
};
|
|
|
|
/*
|
|
* natmintr: 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.
|
|
*/
|
|
void
|
|
natmintr(struct mbuf *m)
|
|
{
|
|
struct socket *so;
|
|
struct natmpcb *npcb;
|
|
|
|
#ifdef DIAGNOSTIC
|
|
M_ASSERTPKTHDR(m);
|
|
#endif
|
|
|
|
NATM_LOCK();
|
|
npcb = (struct natmpcb *)m->m_pkthdr.rcvif; /* XXX: overloaded */
|
|
so = npcb->npcb_socket;
|
|
|
|
npcb->npcb_inq--;
|
|
|
|
if (npcb->npcb_flags & NPCB_DRAIN) {
|
|
if (npcb->npcb_inq == 0)
|
|
FREE(npcb, M_PCB); /* done! */
|
|
NATM_UNLOCK();
|
|
m_freem(m);
|
|
return;
|
|
}
|
|
|
|
if (npcb->npcb_flags & NPCB_FREE) {
|
|
NATM_UNLOCK();
|
|
m_freem(m); /* drop */
|
|
return;
|
|
}
|
|
|
|
#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 (sbspace(&so->so_rcv) > m->m_pkthdr.len) {
|
|
#ifdef NATM_STAT
|
|
natm_sookcnt++;
|
|
natm_sookbytes += m->m_pkthdr.len;
|
|
#endif
|
|
sbappendrecord(&so->so_rcv, m);
|
|
sorwakeup(so);
|
|
NATM_UNLOCK();
|
|
} else {
|
|
#ifdef NATM_STAT
|
|
natm_sodropcnt++;
|
|
natm_sodropbytes += m->m_pkthdr.len;
|
|
#endif
|
|
NATM_UNLOCK();
|
|
m_freem(m);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* natm0_sysctl: not used, but here in case we want to add something
|
|
* later...
|
|
*/
|
|
int
|
|
natm0_sysctl(SYSCTL_HANDLER_ARGS)
|
|
{
|
|
/* All sysctl names at this level are terminal. */
|
|
return (ENOENT);
|
|
}
|
|
|
|
/*
|
|
* natm5_sysctl: not used, but here in case we want to add something
|
|
* later...
|
|
*/
|
|
int
|
|
natm5_sysctl(SYSCTL_HANDLER_ARGS)
|
|
{
|
|
/* All sysctl names at this level are terminal. */
|
|
return (ENOENT);
|
|
}
|