Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sys/netccitt/pk_usrreq.c

672 lines
17 KiB
C
Raw Blame History

/* $NetBSD: pk_usrreq.c,v 1.27 2005/12/11 12:24:54 christos Exp $ */
/*
* Copyright (c) 1991, 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This code is derived from software contributed to Berkeley by the
* Laboratory for Computation Vision and the Computer Science Department
* of the University of British Columbia and the Computer Science
* Department (IV) of the University of Erlangen-Nuremberg, Germany.
*
* 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. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*
* @(#)pk_usrreq.c 8.2 (Berkeley) 1/9/95
*/
/*
* Copyright (c) 1984 University of British Columbia.
* Copyright (c) 1992 Computer Science Department IV,
* University of Erlangen-Nuremberg, Germany.
*
* This code is derived from software contributed to Berkeley by the
* Laboratory for Computation Vision and the Computer Science Department
* of the University of British Columbia and the Computer Science
* Department (IV) of the University of Erlangen-Nuremberg, Germany.
*
* 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 the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*
* @(#)pk_usrreq.c 8.2 (Berkeley) 1/9/95
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: pk_usrreq.c,v 1.27 2005/12/11 12:24:54 christos Exp $");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/protosw.h>
#include <sys/errno.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/proc.h>
#include <net/if.h>
#include <net/if_types.h>
#include <net/route.h>
#include <netccitt/x25.h>
#include <netccitt/pk.h>
#include <netccitt/pk_var.h>
#include <netccitt/pk_extern.h>
static void pk_setsockaddr __P((struct pklcd *, struct mbuf *));
static void pk_setpeeraddr __P((struct pklcd *, struct mbuf *));
static void old_to_new __P((struct mbuf *));
static void new_to_old __P((struct mbuf *));
static void
pk_setsockaddr(lcp, nam)
struct pklcd *lcp;
struct mbuf *nam;
{
nam->m_len = sizeof(struct sockaddr_x25);
bcopy(lcp->lcd_ceaddr, mtod(nam, caddr_t), (size_t)nam->m_len);
if (lcp->lcd_flags & X25_OLDSOCKADDR)
new_to_old(nam);
}
static void
pk_setpeeraddr(lcp, nam)
struct pklcd *lcp;
struct mbuf *nam;
{
nam->m_len = sizeof(struct sockaddr_x25);
bcopy(lcp->lcd_craddr, mtod(nam, caddr_t), (size_t)nam->m_len);
if (lcp->lcd_flags & X25_OLDSOCKADDR)
new_to_old(nam);
}
/*
*
* X.25 Packet level protocol interface to socket abstraction.
*
* Process an X.25 user request on a logical channel. If this is a send
* request then m is the mbuf chain of the send data. If this is a timer
* expiration (called from the software clock routine) them timertype is
* the particular timer.
*
*/
int
pk_usrreq(so, req, m, nam, control, l)
struct socket *so;
int req;
struct mbuf *m, *nam, *control;
struct lwp *l;
{
struct proc *p;
struct pklcd *lcp;
int s;
int error = 0;
p = l ? l->l_proc : NULL;
if (req == PRU_CONTROL)
return (pk_control(so, (long)m, (caddr_t)nam,
(struct ifnet *)control, p));
s = splsoftnet();
lcp = (struct pklcd *)so->so_pcb;
#ifdef DIAGNOSTIC
if (req != PRU_SEND && req != PRU_SENDOOB && control)
panic("pk_usrreq: unexpected control mbuf");
#endif
if (lcp == 0 && req != PRU_ATTACH) {
error = EINVAL;
goto release;
}
/*
pk_trace (pkcbhead, TR_USER, (struct pklcd *)0,
req, (struct x25_packet *)0);
*/
switch (req) {
/*
* X.25 attaches to socket via PRU_ATTACH and allocates a
* logical channel descriptor. If the socket is to receive
* connections, then the LISTEN state is entered.
*/
case PRU_ATTACH:
if (lcp != 0) {
error = EISCONN;
break;
}
lcp = pk_attach(so);
if (lcp == 0)
error = ENOBUFS;
break;
/*
* Detach a logical channel from the socket. If the state of
* the channel is embryonic, simply discard it. Otherwise we
* have to initiate a PRU_DISCONNECT which will finish later.
*/
case PRU_DETACH:
pk_disconnect(lcp);
break;
/*
* Give the socket an address.
*/
case PRU_BIND:
if (nam->m_len == sizeof(struct x25_sockaddr))
old_to_new(nam);
error = pk_bind(lcp, nam);
break;
/*
* Prepare to accept connections.
*/
case PRU_LISTEN:
error = pk_listen(lcp);
break;
/*
* Initiate a CALL REQUEST to peer entity. Enter state
* SENT_CALL and mark the socket as connecting. Set timer
* waiting for CALL ACCEPT or CLEAR.
*/
case PRU_CONNECT:
if (nam->m_len == sizeof(struct x25_sockaddr))
old_to_new(nam);
if (pk_checksockaddr(nam)) {
error = EINVAL;
break;
}
error = pk_connect(lcp, mtod(nam, struct sockaddr_x25 *));
break;
case PRU_CONNECT2:
error = EOPNOTSUPP;
break;
/*
* Initiate a disconnect to peer entity via a CLEAR REQUEST
* packet. The socket will be disconnected when we receive a
* confirmation or a clear collision.
*/
case PRU_DISCONNECT:
pk_disconnect(lcp);
break;
/*
* Accept an INCOMING CALL. Most of the work has already been
* done by pk_input. Just return the callers address to the
* user.
*/
case PRU_ACCEPT:
if (lcp->lcd_craddr == NULL)
break;
pk_setpeeraddr(lcp, nam);
break;
case PRU_SHUTDOWN:
socantsendmore(so);
break;
/*
* After a receive, we should send a RR.
*/
case PRU_RCVD:
pk_flowcontrol(lcp, /* sbspace (&so -> so_rcv) <= */ 0, 1);
break;
/*
* Do send by placing data on the socket output queue.
*/
case PRU_SEND:
if (control) {
struct cmsghdr *ch = mtod(m, struct cmsghdr *);
control->m_len -= sizeof(*ch);
control->m_data += sizeof(*ch);
error = pk_ctloutput(PRCO_SETOPT, so, ch->cmsg_level,
ch->cmsg_type, &control);
if (error)
break;
}
if (m)
error = pk_send(m, lcp);
break;
/*
* Abort a virtual circuit. For example all completed calls
* waiting acceptance.
*/
case PRU_ABORT:
pk_disconnect(lcp);
break;
case PRU_SENSE:
/*
* stat: don't bother with a blocksize.
*/
splx(s);
return (0);
/*
* Receive INTERRUPT packet.
*/
case PRU_RCVOOB:
if (so->so_options & SO_OOBINLINE) {
struct mbuf *n = so->so_rcv.sb_mb;
if (n && n->m_type == MT_OOBDATA) {
unsigned len = n->m_pkthdr.len;
so->so_rcv.sb_mb = n->m_nextpkt;
SB_EMPTY_FIXUP(&so->so_rcv);
if (len != n->m_len &&
(n = m_pullup(n, len)) == 0)
break;
m->m_len = len;
bcopy(mtod(m, caddr_t), mtod(n, caddr_t), len);
m_freem(n);
}
break;
}
m->m_len = 1;
*mtod(m, char *) = lcp->lcd_intrdata;
break;
/*
* Send INTERRUPT packet.
*/
case PRU_SENDOOB:
if (control) {
struct cmsghdr *ch = mtod(m, struct cmsghdr *);
control->m_len -= sizeof(*ch);
control->m_data += sizeof(*ch);
error = pk_ctloutput(PRCO_SETOPT, so, ch->cmsg_level,
ch->cmsg_type, &control);
if (error)
break;
}
if (m) {
MCHTYPE(m, MT_OOBDATA);
error = pk_send(m, lcp);
}
break;
case PRU_SOCKADDR:
if (lcp->lcd_ceaddr == 0) {
error = EADDRNOTAVAIL;
break;
}
pk_setsockaddr(lcp, nam);
break;
case PRU_PEERADDR:
if (lcp->lcd_state != DATA_TRANSFER) {
error = ENOTCONN;
break;
}
pk_setpeeraddr(lcp, nam);
break;
default:
panic("pk_usrreq");
}
release:
splx(s);
return (error);
}
/*
* If you want to use UBC X.25 level 3 in conjunction with some other X.25
* level 2 driver, have the ifp -> if_ioctl routine assign pk_start to ia ->
* ia_start when called with SIOCSIFCONF_X25.
*/
/* ARGSUSED */
int
pk_start(lcp)
struct pklcd *lcp;
{
pk_output(lcp);
return (0); /* XXX pk_output should return a value */
}
struct sockaddr_x25 pk_sockmask = {
offsetof(struct sockaddr_x25, x25_addr[0]), /* x25_len */
0, /* x25_family */
-1, /* x25_net id */
};
/* ARGSUSED */
int
pk_control(so, cmd, data, ifp, p)
struct socket *so;
u_long cmd;
caddr_t data;
struct ifnet *ifp;
struct proc *p;
{
struct ifreq_x25 *ifr = (struct ifreq_x25 *) data;
struct ifaddr *ifa = 0;
struct x25_ifaddr *ia = 0;
int error = 0, s, old_maxlcn;
/*
* Find address for this interface, if it exists.
*/
if (ifp)
for (ifa = ifp->if_addrlist.tqh_first; ifa != 0;
ifa = ifa->ifa_list.tqe_next)
if (ifa->ifa_addr->sa_family == AF_CCITT)
break;
ia = (struct x25_ifaddr *) ifa;
switch (cmd) {
case SIOCGIFCONF_X25:
if (ifa == 0)
return (EADDRNOTAVAIL);
ifr->ifr_xc = ia->ia_xc;
return (0);
case SIOCSIFCONF_X25:
if (p == 0 || (error = suser(p->p_ucred, &p->p_acflag)))
return (EPERM);
if (ifp == 0)
panic("pk_control");
if (ifa == (struct ifaddr *) 0) {
MALLOC(ia, struct x25_ifaddr *, sizeof(*ia),
M_IFADDR, M_WAITOK);
if (ia == 0)
return (ENOBUFS);
bzero((caddr_t) ia, sizeof(*ia));
TAILQ_INSERT_TAIL(&ifp->if_addrlist, &ia->ia_ifa,
ifa_list);
ifa = &ia->ia_ifa;
IFAREF(ifa);
ifa->ifa_netmask = (struct sockaddr *) & pk_sockmask;
ifa->ifa_addr = (struct sockaddr *) & ia->ia_xc.xc_addr;
ifa->ifa_dstaddr = (struct sockaddr *) & ia->ia_dstaddr; /* XXX */
ia->ia_ifp = ifp;
ia->ia_dstaddr.x25_family = AF_CCITT;
ia->ia_dstaddr.x25_len = pk_sockmask.x25_len;
} else if (ISISO8802(ifp) == 0) {
rtinit(ifa, (int) RTM_DELETE, 0);
}
old_maxlcn = ia->ia_maxlcn;
ia->ia_xc = ifr->ifr_xc;
ia->ia_dstaddr.x25_net = ia->ia_xc.xc_addr.x25_net;
if (ia->ia_maxlcn != old_maxlcn && old_maxlcn != 0) {
/* VERY messy XXX */
struct pkcb *pkp;
FOR_ALL_PKCBS(pkp)
if (pkp->pk_ia == ia)
pk_resize(pkp);
}
/*
* Give the interface a chance to initialize if this
p * is its first address, and to validate the address.
*/
ia->ia_start = pk_start;
s = splnet();
if (ifp->if_ioctl)
error = (*ifp->if_ioctl) (ifp, SIOCSIFCONF_X25,
(caddr_t) ifa);
if (error)
ifp->if_flags &= ~IFF_UP;
else if (ISISO8802(ifp) == 0)
error = rtinit(ifa, (int) RTM_ADD, RTF_UP);
splx(s);
return (error);
default:
if (ifp == 0 || ifp->if_ioctl == 0)
return (EOPNOTSUPP);
return ((*ifp->if_ioctl) (ifp, cmd, data));
}
}
int
pk_ctloutput(cmd, so, level, optname, mp)
struct socket *so;
struct mbuf **mp;
int cmd, level, optname;
{
struct proc *p = curproc; /* XXX */
struct mbuf *m = *mp;
struct pklcd *lcp = (struct pklcd *) so->so_pcb;
int error = EOPNOTSUPP;
if (m == 0)
return (EINVAL);
if (cmd == PRCO_SETOPT)
switch (optname) {
case PK_FACILITIES:
if (m == 0)
return (EINVAL);
lcp->lcd_facilities = m;
*mp = 0;
return (0);
case PK_ACCTFILE:
if (p == 0 || (error = suser(p->p_ucred, &p->p_acflag)))
error = EPERM;
else if (m->m_len)
error = pk_accton(mtod(m, char *));
else
error = pk_accton((char *) 0);
break;
case PK_RTATTACH:
error = pk_rtattach(so, m);
break;
case PK_PRLISTEN:
error = pk_user_protolisten(mtod(m, u_char *));
}
if (*mp) {
(void) m_freem(*mp);
*mp = 0;
}
return (error);
}
/*
* Do an in-place conversion of an "old style"
* socket address to the new style
*/
static void
old_to_new(m)
struct mbuf *m;
{
struct x25_sockaddr *oldp;
struct sockaddr_x25 *newp;
char *ocp, *ncp;
struct sockaddr_x25 new;
oldp = mtod(m, struct x25_sockaddr *);
newp = &new;
bzero((caddr_t) newp, sizeof(*newp));
newp->x25_family = AF_CCITT;
newp->x25_len = sizeof(*newp);
newp->x25_opts.op_flags = (oldp->xaddr_facilities & X25_REVERSE_CHARGE)
| X25_MQBIT | X25_OLDSOCKADDR;
if (oldp->xaddr_facilities & XS_HIPRIO) /* Datapac specific */
newp->x25_opts.op_psize = X25_PS128;
bcopy((caddr_t) oldp->xaddr_addr, newp->x25_addr,
(unsigned) min(oldp->xaddr_len, sizeof(newp->x25_addr) - 1));
if (bcmp((caddr_t) oldp->xaddr_proto, newp->x25_udata, 4) != 0) {
bcopy((caddr_t) oldp->xaddr_proto, newp->x25_udata, 4);
newp->x25_udlen = 4;
}
ocp = (caddr_t) oldp->xaddr_userdata;
ncp = newp->x25_udata + 4;
while (*ocp && ocp < (caddr_t) oldp->xaddr_userdata + 12) {
if (newp->x25_udlen == 0)
newp->x25_udlen = 4;
*ncp++ = *ocp++;
newp->x25_udlen++;
}
bcopy((caddr_t) newp, mtod(m, char *), sizeof(*newp));
m->m_len = sizeof(*newp);
}
/*
* Do an in-place conversion of a new style
* socket address to the old style
*/
static void
new_to_old(m)
struct mbuf *m;
{
struct x25_sockaddr *oldp;
struct sockaddr_x25 *newp;
char *ocp, *ncp;
struct x25_sockaddr old;
oldp = &old;
newp = mtod(m, struct sockaddr_x25 *);
bzero((caddr_t) oldp, sizeof(*oldp));
oldp->xaddr_facilities = newp->x25_opts.op_flags & X25_REVERSE_CHARGE;
if (newp->x25_opts.op_psize == X25_PS128)
oldp->xaddr_facilities |= XS_HIPRIO; /* Datapac specific */
ocp = (char *) oldp->xaddr_addr;
ncp = newp->x25_addr;
while (*ncp) {
*ocp++ = *ncp++;
oldp->xaddr_len++;
}
bcopy(newp->x25_udata, (caddr_t) oldp->xaddr_proto, 4);
if (newp->x25_udlen > 4)
bcopy(newp->x25_udata + 4, (caddr_t) oldp->xaddr_userdata,
(unsigned) (newp->x25_udlen - 4));
bcopy((caddr_t) oldp, mtod(m, char *), sizeof(*oldp));
m->m_len = sizeof(*oldp);
}
int
pk_checksockaddr(m)
struct mbuf *m;
{
struct sockaddr_x25 *sa = mtod(m, struct sockaddr_x25 *);
char *cp;
if (m->m_len != sizeof(struct sockaddr_x25))
return (1);
if (sa->x25_family != AF_CCITT ||
sa->x25_udlen > sizeof(sa->x25_udata))
return (1);
for (cp = sa->x25_addr; *cp; cp++) {
if (*cp < '0' || *cp > '9' ||
cp >= &sa->x25_addr[sizeof(sa->x25_addr) - 1])
return (1);
}
return (0);
}
int
pk_send(m, v)
struct mbuf *m;
void *v;
{
struct pklcd *lcp = v;
int mqbit = 0, error = 0;
struct x25_packet *xp;
struct socket *so;
if (m->m_type == MT_OOBDATA) {
if (lcp->lcd_intrconf_pending)
error = ETOOMANYREFS;
if (m->m_pkthdr.len > 32)
error = EMSGSIZE;
M_PREPEND(m, PKHEADERLN, M_WAITOK);
if (m == 0 || error)
goto bad;
*(mtod(m, octet *)) = 0;
xp = mtod(m, struct x25_packet *);
X25SBITS(xp->bits, fmt_identifier, 1);
xp->packet_type = X25_INTERRUPT;
SET_LCN(xp, lcp->lcd_lcn);
sbinsertoob((so = lcp->lcd_so) ?
&so->so_snd : &lcp->lcd_sb, m);
goto send;
}
/*
* Application has elected (at call setup time) to prepend
* a control byte to each packet written indicating m-bit
* and q-bit status. Examine and then discard this byte.
*/
if (lcp->lcd_flags & X25_MQBIT) {
if (m->m_len < 1) {
m_freem(m);
return (EMSGSIZE);
}
mqbit = *(mtod(m, u_char *));
m->m_len--;
m->m_data++;
m->m_pkthdr.len--;
}
error = pk_fragment(lcp, m, mqbit & 0x80, mqbit & 0x40, 1);
send:
if (error == 0 && lcp->lcd_state == DATA_TRANSFER)
lcp->lcd_send(lcp); /* XXXXXXXXX fix pk_output!!! */
return (error);
bad:
if (m)
m_freem(m);
return (error);
}
Reference in New Issue View Git Blame Copy Permalink