/* ARGSUSED */
static int
fifo_kqfilter(void *v)
{
struct vop_kqfilter_args /* {
struct vnode *a_vp;
struct knote *a_kn;
} */ *ap = v;
struct socket *so;
struct sockbuf *sb;
so = (struct socket *)ap->a_vp->v_fifoinfo->fi_readsock;
switch (ap->a_kn->kn_filter) {
case EVFILT_READ:
ap->a_kn->kn_fop = &fiforead_filtops;
sb = &so->so_rcv;
break;
case EVFILT_WRITE:
ap->a_kn->kn_fop = &fifowrite_filtops;
sb = &so->so_snd;
break;
default:
return (EINVAL);
}
ap->a_kn->kn_hook = so;
solock(so);
SLIST_INSERT_HEAD(&sb->sb_sel.sel_klist, ap->a_kn, kn_selnext);
sb->sb_flags |= SB_KNOTE;
sounlock(so);
return (0);
}
/*
* Get peer socket name.
*/
int
do_sys_getpeername(int fd, struct mbuf **nam)
{
struct socket *so;
struct mbuf *m;
int error;
if ((error = fd_getsock(fd, &so)) != 0)
return error;
m = m_getclr(M_WAIT, MT_SONAME);
MCLAIM(m, so->so_mowner);
solock(so);
if ((so->so_state & SS_ISCONNECTED) == 0)
error = ENOTCONN;
else {
*nam = m;
error = (*so->so_proto->pr_usrreqs->pr_peeraddr)(so, m);
}
sounlock(so);
if (error != 0)
m_free(m);
fd_putfile(fd);
return error;
}
static int
rfcomm_attach(struct socket *so, int proto)
{
int error;
KASSERT(so->so_pcb == NULL);
if (so->so_lock == NULL) {
mutex_obj_hold(bt_lock);
so->so_lock = bt_lock;
solock(so);
}
KASSERT(solocked(so));
/*
* Since we have nothing to add, we attach the DLC
* structure directly to our PCB pointer.
*/
error = soreserve(so, rfcomm_sendspace, rfcomm_recvspace);
if (error)
return error;
error = rfcomm_attach_pcb((struct rfcomm_dlc **)&so->so_pcb,
&rfcomm_proto, so);
if (error)
return error;
error = rfcomm_rcvd_pcb(so->so_pcb, sbspace(&so->so_rcv));
if (error) {
rfcomm_detach_pcb((struct rfcomm_dlc **)&so->so_pcb);
return error;
}
return 0;
}
int
sys_socketpair(struct lwp *l, const struct sys_socketpair_args *uap,
register_t *retval)
{
/* {
syscallarg(int) domain;
syscallarg(int) type;
syscallarg(int) protocol;
syscallarg(int *) rsv;
} */
file_t *fp1, *fp2;
struct socket *so1, *so2;
int fd, error, sv[2];
proc_t *p = curproc;
int flags = SCARG(uap, type) & SOCK_FLAGS_MASK;
int type = SCARG(uap, type) & ~SOCK_FLAGS_MASK;
int domain = SCARG(uap, domain);
int proto = SCARG(uap, protocol);
error = makesocket(l, &fp1, &fd, flags, type, domain, proto, NULL);
if (error)
return error;
so1 = fp1->f_socket;
sv[0] = fd;
error = makesocket(l, &fp2, &fd, flags, type, domain, proto, so1);
if (error)
goto out;
so2 = fp2->f_socket;
sv[1] = fd;
solock(so1);
error = soconnect2(so1, so2);
if (error == 0 && type == SOCK_DGRAM) {
/*
* Datagram socket connection is asymmetric.
*/
error = soconnect2(so2, so1);
}
sounlock(so1);
if (error == 0)
error = copyout(sv, SCARG(uap, rsv), sizeof(sv));
if (error == 0) {
fd_affix(p, fp2, sv[1]);
fd_affix(p, fp1, sv[0]);
return 0;
}
fd_abort(p, fp2, sv[1]);
(void)soclose(so2);
out:
fd_abort(p, fp1, sv[0]);
(void)soclose(so1);
return error;
}
int
do_sys_connect(struct lwp *l, int fd, struct mbuf *nam)
{
struct socket *so;
int error;
int interrupted = 0;
if ((error = fd_getsock(fd, &so)) != 0) {
m_freem(nam);
return (error);
}
solock(so);
MCLAIM(nam, so->so_mowner);
if ((so->so_state & SS_ISCONNECTING) != 0) {
error = EALREADY;
goto out;
}
error = soconnect(so, nam, l);
if (error)
goto bad;
if ((so->so_state & (SS_NBIO|SS_ISCONNECTING)) ==
(SS_NBIO|SS_ISCONNECTING)) {
error = EINPROGRESS;
goto out;
}
while ((so->so_state & SS_ISCONNECTING) != 0 && so->so_error == 0) {
error = sowait(so, true, 0);
if (__predict_false((so->so_state & SS_ISABORTING) != 0)) {
error = EPIPE;
interrupted = 1;
break;
}
if (error) {
if (error == EINTR || error == ERESTART)
interrupted = 1;
break;
}
}
if (error == 0) {
error = so->so_error;
so->so_error = 0;
}
bad:
if (!interrupted)
so->so_state &= ~SS_ISCONNECTING;
if (error == ERESTART)
error = EINTR;
out:
sounlock(so);
fd_putfile(fd);
m_freem(nam);
return error;
}
static void
filt_fifowdetach(struct knote *kn)
{
struct socket *so;
so = (struct socket *)kn->kn_hook;
solock(so);
SLIST_REMOVE(&so->so_snd.sb_sel.sel_klist, kn, knote, kn_selnext);
if (SLIST_EMPTY(&so->so_snd.sb_sel.sel_klist))
so->so_snd.sb_flags &= ~SB_KNOTE;
sounlock(so);
}
int
rump_netconfig_ipv6_gw(const char *gwaddr)
{
struct rt_msghdr rtm, *rtmp;
struct sockaddr_in6 sin6;
struct mbuf *m;
int off, rv;
CHECKDOMAIN(in6so);
memset(&rtm, 0, sizeof(rtm));
rtm.rtm_type = RTM_ADD;
rtm.rtm_flags = RTF_UP | RTF_STATIC | RTF_GATEWAY;
rtm.rtm_version = RTM_VERSION;
rtm.rtm_seq = 2;
rtm.rtm_addrs = RTA_DST | RTA_GATEWAY | RTA_NETMASK;
m = m_gethdr(M_WAIT, MT_DATA);
m->m_pkthdr.len = 0;
m_copyback(m, 0, sizeof(rtm), &rtm);
off = sizeof(rtm);
/* dest */
memset(&sin6, 0, sizeof(sin6));
sin6.sin6_family = AF_INET6;
sin6.sin6_len = sizeof(sin6);
m_copyback(m, off, sin6.sin6_len, &sin6);
RT_ADVANCE(off, (struct sockaddr *)&sin6);
/* gw */
netconfig_inet_pton6(gwaddr, &sin6.sin6_addr);
m_copyback(m, off, sin6.sin6_len, &sin6);
RT_ADVANCE(off, (struct sockaddr *)&sin6);
/* mask */
memset(&sin6.sin6_addr, 0, sizeof(sin6.sin6_addr));
m_copyback(m, off, sin6.sin6_len, &sin6);
off = m->m_pkthdr.len;
m = m_pullup(m, sizeof(*rtmp));
rtmp = mtod(m, struct rt_msghdr *);
rtmp->rtm_msglen = off;
solock(rtso);
#if __NetBSD_Prereq__(7,99,26)
rv = rtso->so_proto->pr_usrreqs->pr_send(rtso, m, NULL, NULL, curlwp);
#else
rv = rtso->so_proto->pr_output(m, rtso);
#endif
sounlock(rtso);
return rv;
}
int
pipe1(struct lwp *l, register_t *retval, int flags)
{
file_t *rf, *wf;
struct socket *rso, *wso;
int fd, error;
proc_t *p;
if (flags & ~(O_CLOEXEC|O_NONBLOCK|O_NOSIGPIPE))
return EINVAL;
p = curproc;
if ((error = socreate(AF_LOCAL, &rso, SOCK_STREAM, 0, l, NULL)) != 0)
return error;
if ((error = socreate(AF_LOCAL, &wso, SOCK_STREAM, 0, l, rso)) != 0)
goto free1;
/* remember this socket pair implements a pipe */
wso->so_state |= SS_ISAPIPE;
rso->so_state |= SS_ISAPIPE;
if ((error = fd_allocfile(&rf, &fd)) != 0)
goto free2;
retval[0] = fd;
rf->f_flag = FREAD | flags;
rf->f_type = DTYPE_SOCKET;
rf->f_ops = &socketops;
rf->f_socket = rso;
if ((error = fd_allocfile(&wf, &fd)) != 0)
goto free3;
wf->f_flag = FWRITE | flags;
wf->f_type = DTYPE_SOCKET;
wf->f_ops = &socketops;
wf->f_socket = wso;
retval[1] = fd;
solock(wso);
error = unp_connect2(wso, rso);
sounlock(wso);
if (error != 0)
goto free4;
fd_affix(p, wf, (int)retval[1]);
fd_affix(p, rf, (int)retval[0]);
return (0);
free4:
fd_abort(p, wf, (int)retval[1]);
free3:
fd_abort(p, rf, (int)retval[0]);
free2:
(void)soclose(wso);
free1:
(void)soclose(rso);
return error;
}
int
soo_stat(file_t *fp, struct stat *ub)
{
struct socket *so = fp->f_data;
int error;
memset(ub, 0, sizeof(*ub));
ub->st_mode = S_IFSOCK;
solock(so);
error = (*so->so_proto->pr_usrreq)(so, PRU_SENSE,
(struct mbuf *)ub, NULL, NULL, curlwp);
sounlock(so);
return error;
}
/* ARGSUSED */
static int
fifo_close(void *v)
{
struct vop_close_args /* {
struct vnode *a_vp;
int a_fflag;
kauth_cred_t a_cred;
struct lwp *a_l;
} */ *ap = v;
struct vnode *vp;
struct fifoinfo *fip;
struct socket *wso, *rso;
int isrevoke;
vp = ap->a_vp;
fip = vp->v_fifoinfo;
isrevoke = (ap->a_fflag & (FREAD | FWRITE | FNONBLOCK)) == FNONBLOCK;
wso = fip->fi_writesock;
rso = fip->fi_readsock;
solock(wso);
if (isrevoke) {
if (fip->fi_readers != 0) {
fip->fi_readers = 0;
socantsendmore(wso);
}
if (fip->fi_writers != 0) {
fip->fi_writers = 0;
socantrcvmore(rso);
}
} else {
if ((ap->a_fflag & FREAD) && --fip->fi_readers == 0)
socantsendmore(wso);
if ((ap->a_fflag & FWRITE) && --fip->fi_writers == 0)
socantrcvmore(rso);
}
if ((fip->fi_readers + fip->fi_writers) == 0) {
sounlock(wso);
(void) soclose(rso);
(void) soclose(wso);
cv_destroy(&fip->fi_rcv);
cv_destroy(&fip->fi_wcv);
kmem_free(fip, sizeof(*fip));
vp->v_fifoinfo = NULL;
} else
sounlock(wso);
return (0);
}
int
sys_shutdown(struct lwp *l, const struct sys_shutdown_args *uap,
register_t *retval)
{
/* {
syscallarg(int) s;
syscallarg(int) how;
} */
struct socket *so;
int error;
if ((error = fd_getsock(SCARG(uap, s), &so)) != 0)
return error;
solock(so);
error = soshutdown(so, SCARG(uap, how));
sounlock(so);
fd_putfile(SCARG(uap, s));
return error;
}
static int
sco_attach(struct socket *so, int proto)
{
int error;
KASSERT(so->so_pcb == NULL);
if (so->so_lock == NULL) {
mutex_obj_hold(bt_lock);
so->so_lock = bt_lock;
solock(so);
}
KASSERT(solocked(so));
error = soreserve(so, sco_sendspace, sco_recvspace);
if (error) {
return error;
}
return sco_attach_pcb((struct sco_pcb **)&so->so_pcb, &sco_proto, so);
}
static int
filt_fifowrite(struct knote *kn, long hint)
{
struct socket *so;
int rv;
so = (struct socket *)kn->kn_hook;
if (hint != NOTE_SUBMIT)
solock(so);
kn->kn_data = sbspace(&so->so_snd);
if (so->so_state & SS_CANTSENDMORE) {
kn->kn_flags |= EV_EOF;
rv = 1;
} else {
kn->kn_flags &= ~EV_EOF;
rv = (kn->kn_data >= so->so_snd.sb_lowat);
}
if (hint != NOTE_SUBMIT)
sounlock(so);
return rv;
}
static int
filt_fiforead(struct knote *kn, long hint)
{
struct socket *so;
int rv;
so = (struct socket *)kn->kn_hook;
if (hint != NOTE_SUBMIT)
solock(so);
kn->kn_data = so->so_rcv.sb_cc;
if (so->so_state & SS_CANTRCVMORE) {
kn->kn_flags |= EV_EOF;
rv = 1;
} else {
kn->kn_flags &= ~EV_EOF;
rv = (kn->kn_data > 0);
}
if (hint != NOTE_SUBMIT)
sounlock(so);
return rv;
}
/*
* Get local socket name.
*/
int
do_sys_getsockname(int fd, struct mbuf **nam)
{
struct socket *so;
struct mbuf *m;
int error;
if ((error = fd_getsock(fd, &so)) != 0)
return error;
m = m_getclr(M_WAIT, MT_SONAME);
MCLAIM(m, so->so_mowner);
*nam = m;
solock(so);
error = (*so->so_proto->pr_usrreqs->pr_sockaddr)(so, m);
sounlock(so);
if (error != 0)
m_free(m);
fd_putfile(fd);
return error;
}
int
do_sys_accept(struct lwp *l, int sock, struct mbuf **name,
register_t *new_sock, const sigset_t *mask, int flags, int clrflags)
{
file_t *fp, *fp2;
struct mbuf *nam;
int error, fd;
struct socket *so, *so2;
short wakeup_state = 0;
if ((fp = fd_getfile(sock)) == NULL)
return EBADF;
if (fp->f_type != DTYPE_SOCKET) {
fd_putfile(sock);
return ENOTSOCK;
}
if ((error = fd_allocfile(&fp2, &fd)) != 0) {
fd_putfile(sock);
return error;
}
nam = m_get(M_WAIT, MT_SONAME);
*new_sock = fd;
so = fp->f_socket;
solock(so);
if (__predict_false(mask))
sigsuspendsetup(l, mask);
if (!(so->so_proto->pr_flags & PR_LISTEN)) {
error = EOPNOTSUPP;
goto bad;
}
if ((so->so_options & SO_ACCEPTCONN) == 0) {
error = EINVAL;
goto bad;
}
if ((so->so_state & SS_NBIO) && so->so_qlen == 0) {
error = EWOULDBLOCK;
goto bad;
}
while (so->so_qlen == 0 && so->so_error == 0) {
if (so->so_state & SS_CANTRCVMORE) {
so->so_error = ECONNABORTED;
break;
}
if (wakeup_state & SS_RESTARTSYS) {
error = ERESTART;
goto bad;
}
error = sowait(so, true, 0);
if (error) {
goto bad;
}
wakeup_state = so->so_state;
}
if (so->so_error) {
error = so->so_error;
so->so_error = 0;
goto bad;
}
/* connection has been removed from the listen queue */
KNOTE(&so->so_rcv.sb_sel.sel_klist, NOTE_SUBMIT);
so2 = TAILQ_FIRST(&so->so_q);
if (soqremque(so2, 1) == 0)
panic("accept");
fp2->f_type = DTYPE_SOCKET;
fp2->f_flag = (fp->f_flag & ~clrflags) |
((flags & SOCK_NONBLOCK) ? FNONBLOCK : 0)|
((flags & SOCK_NOSIGPIPE) ? FNOSIGPIPE : 0);
fp2->f_ops = &socketops;
fp2->f_socket = so2;
if (fp2->f_flag & FNONBLOCK)
so2->so_state |= SS_NBIO;
else
so2->so_state &= ~SS_NBIO;
error = soaccept(so2, nam);
so2->so_cred = kauth_cred_dup(so->so_cred);
sounlock(so);
if (error) {
/* an error occurred, free the file descriptor and mbuf */
m_freem(nam);
mutex_enter(&fp2->f_lock);
fp2->f_count++;
mutex_exit(&fp2->f_lock);
closef(fp2);
fd_abort(curproc, NULL, fd);
} else {
fd_set_exclose(l, fd, (flags & SOCK_CLOEXEC) != 0);
fd_affix(curproc, fp2, fd);
*name = nam;
}
fd_putfile(sock);
if (__predict_false(mask))
sigsuspendteardown(l);
return error;
bad:
sounlock(so);
m_freem(nam);
fd_putfile(sock);
fd_abort(curproc, fp2, fd);
if (__predict_false(mask))
sigsuspendteardown(l);
return error;
}
/*
* User Request.
* up is socket
* m is either
* optional mbuf chain containing message
* ioctl command (PRU_CONTROL)
* nam is either
* optional mbuf chain containing an address
* ioctl data (PRU_CONTROL)
* optionally, protocol number (PRU_ATTACH)
* ctl is optional mbuf chain containing socket options
* l is pointer to process requesting action (if any)
*
* we are responsible for disposing of m and ctl if
* they are mbuf chains
*/
int
sco_usrreq(struct socket *up, int req, struct mbuf *m,
struct mbuf *nam, struct mbuf *ctl, struct lwp *l)
{
struct sco_pcb *pcb = (struct sco_pcb *)up->so_pcb;
struct sockaddr_bt *sa;
struct mbuf *m0;
int err = 0;
DPRINTFN(2, "%s\n", prurequests[req]);
switch(req) {
case PRU_CONTROL:
return EOPNOTSUPP;
case PRU_PURGEIF:
return EOPNOTSUPP;
case PRU_ATTACH:
if (up->so_lock == NULL) {
mutex_obj_hold(bt_lock);
up->so_lock = bt_lock;
solock(up);
}
KASSERT(solocked(up));
if (pcb)
return EINVAL;
err = soreserve(up, sco_sendspace, sco_recvspace);
if (err)
return err;
return sco_attach((struct sco_pcb **)&up->so_pcb,
&sco_proto, up);
}
/* anything after here *requires* a pcb */
if (pcb == NULL) {
err = EINVAL;
goto release;
}
switch(req) {
case PRU_DISCONNECT:
soisdisconnecting(up);
return sco_disconnect(pcb, up->so_linger);
case PRU_ABORT:
sco_disconnect(pcb, 0);
soisdisconnected(up);
/* fall through to */
case PRU_DETACH:
return sco_detach((struct sco_pcb **)&up->so_pcb);
case PRU_BIND:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
if (sa->bt_len != sizeof(struct sockaddr_bt))
return EINVAL;
if (sa->bt_family != AF_BLUETOOTH)
return EAFNOSUPPORT;
return sco_bind(pcb, sa);
case PRU_CONNECT:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
if (sa->bt_len != sizeof(struct sockaddr_bt))
return EINVAL;
if (sa->bt_family != AF_BLUETOOTH)
return EAFNOSUPPORT;
soisconnecting(up);
return sco_connect(pcb, sa);
case PRU_PEERADDR:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
nam->m_len = sizeof(struct sockaddr_bt);
return sco_peeraddr(pcb, sa);
case PRU_SOCKADDR:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
nam->m_len = sizeof(struct sockaddr_bt);
return sco_sockaddr(pcb, sa);
case PRU_SHUTDOWN:
socantsendmore(up);
break;
case PRU_SEND:
KASSERT(m != NULL);
if (m->m_pkthdr.len == 0)
break;
if (m->m_pkthdr.len > pcb->sp_mtu) {
err = EMSGSIZE;
break;
}
m0 = m_copypacket(m, M_DONTWAIT);
if (m0 == NULL) {
err = ENOMEM;
break;
}
if (ctl) /* no use for that */
m_freem(ctl);
sbappendrecord(&up->so_snd, m);
return sco_send(pcb, m0);
case PRU_SENSE:
return 0; /* (no sense - Doh!) */
case PRU_RCVD:
case PRU_RCVOOB:
return EOPNOTSUPP; /* (no release) */
case PRU_LISTEN:
return sco_listen(pcb);
case PRU_ACCEPT:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
nam->m_len = sizeof(struct sockaddr_bt);
return sco_peeraddr(pcb, sa);
case PRU_CONNECT2:
case PRU_SENDOOB:
case PRU_FASTTIMO:
case PRU_SLOWTIMO:
case PRU_PROTORCV:
case PRU_PROTOSEND:
err = EOPNOTSUPP;
break;
default:
UNKNOWN(req);
err = EOPNOTSUPP;
break;
}
release:
if (m) m_freem(m);
if (ctl) m_freem(ctl);
return err;
}
/*
* User Request.
* up is socket
* m is either
* optional mbuf chain containing message
* ioctl command (PRU_CONTROL)
* nam is either
* optional mbuf chain containing an address
* ioctl data (PRU_CONTROL)
* optionally protocol number (PRU_ATTACH)
* message flags (PRU_RCVD)
* ctl is either
* optional mbuf chain containing socket options
* optional interface pointer (PRU_CONTROL, PRU_PURGEIF)
* l is pointer to process requesting action (if any)
*
* we are responsible for disposing of m and ctl if
* they are mbuf chains
*/
int
rfcomm_usrreq(struct socket *up, int req, struct mbuf *m,
struct mbuf *nam, struct mbuf *ctl, struct lwp *l)
{
struct rfcomm_dlc *pcb = up->so_pcb;
struct sockaddr_bt *sa;
struct mbuf *m0;
int err = 0;
DPRINTFN(2, "%s\n", prurequests[req]);
switch (req) {
case PRU_CONTROL:
return EPASSTHROUGH;
case PRU_PURGEIF:
return EOPNOTSUPP;
case PRU_ATTACH:
if (up->so_lock == NULL) {
mutex_obj_hold(bt_lock);
up->so_lock = bt_lock;
solock(up);
}
KASSERT(solocked(up));
if (pcb != NULL)
return EINVAL;
/*
* Since we have nothing to add, we attach the DLC
* structure directly to our PCB pointer.
*/
err = soreserve(up, rfcomm_sendspace, rfcomm_recvspace);
if (err)
return err;
err = rfcomm_attach((struct rfcomm_dlc **)&up->so_pcb,
&rfcomm_proto, up);
if (err)
return err;
err = rfcomm_rcvd(up->so_pcb, sbspace(&up->so_rcv));
if (err) {
rfcomm_detach((struct rfcomm_dlc **)&up->so_pcb);
return err;
}
return 0;
}
if (pcb == NULL) {
err = EINVAL;
goto release;
}
switch(req) {
case PRU_DISCONNECT:
soisdisconnecting(up);
return rfcomm_disconnect(pcb, up->so_linger);
case PRU_ABORT:
rfcomm_disconnect(pcb, 0);
soisdisconnected(up);
/* fall through to */
case PRU_DETACH:
return rfcomm_detach((struct rfcomm_dlc **)&up->so_pcb);
case PRU_BIND:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
if (sa->bt_len != sizeof(struct sockaddr_bt))
return EINVAL;
if (sa->bt_family != AF_BLUETOOTH)
return EAFNOSUPPORT;
return rfcomm_bind(pcb, sa);
case PRU_CONNECT:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
if (sa->bt_len != sizeof(struct sockaddr_bt))
return EINVAL;
if (sa->bt_family != AF_BLUETOOTH)
return EAFNOSUPPORT;
soisconnecting(up);
return rfcomm_connect(pcb, sa);
case PRU_PEERADDR:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
nam->m_len = sizeof(struct sockaddr_bt);
return rfcomm_peeraddr(pcb, sa);
case PRU_SOCKADDR:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
nam->m_len = sizeof(struct sockaddr_bt);
return rfcomm_sockaddr(pcb, sa);
case PRU_SHUTDOWN:
socantsendmore(up);
break;
case PRU_SEND:
KASSERT(m != NULL);
if (ctl) /* no use for that */
m_freem(ctl);
m0 = m_copypacket(m, M_DONTWAIT);
if (m0 == NULL)
return ENOMEM;
sbappendstream(&up->so_snd, m);
return rfcomm_send(pcb, m0);
case PRU_SENSE:
return 0; /* (no release) */
case PRU_RCVD:
return rfcomm_rcvd(pcb, sbspace(&up->so_rcv));
case PRU_RCVOOB:
return EOPNOTSUPP; /* (no release) */
case PRU_LISTEN:
return rfcomm_listen(pcb);
case PRU_ACCEPT:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
nam->m_len = sizeof(struct sockaddr_bt);
return rfcomm_peeraddr(pcb, sa);
case PRU_CONNECT2:
case PRU_SENDOOB:
case PRU_FASTTIMO:
case PRU_SLOWTIMO:
case PRU_PROTORCV:
case PRU_PROTOSEND:
err = EOPNOTSUPP;
break;
default:
UNKNOWN(req);
err = EOPNOTSUPP;
break;
}
release:
if (m) m_freem(m);
if (ctl) m_freem(ctl);
return err;
}
/*
* Open called to set up a new instance of a fifo or
* to find an active instance of a fifo.
*/
static int
fifo_open(void *v)
{
struct vop_open_args /* {
struct vnode *a_vp;
int a_mode;
kauth_cred_t a_cred;
} */ *ap = v;
struct lwp *l = curlwp;
struct vnode *vp;
struct fifoinfo *fip;
struct socket *rso, *wso;
int error;
vp = ap->a_vp;
KASSERT(VOP_ISLOCKED(vp));
if ((fip = vp->v_fifoinfo) == NULL) {
fip = kmem_alloc(sizeof(*fip), KM_SLEEP);
error = socreate(AF_LOCAL, &rso, SOCK_STREAM, 0, l, NULL);
if (error != 0) {
kmem_free(fip, sizeof(*fip));
return (error);
}
fip->fi_readsock = rso;
error = socreate(AF_LOCAL, &wso, SOCK_STREAM, 0, l, rso);
if (error != 0) {
(void)soclose(rso);
kmem_free(fip, sizeof(*fip));
return (error);
}
fip->fi_writesock = wso;
solock(wso);
if ((error = unp_connect2(wso, rso, PRU_CONNECT2)) != 0) {
sounlock(wso);
(void)soclose(wso);
(void)soclose(rso);
kmem_free(fip, sizeof(*fip));
return (error);
}
fip->fi_readers = 0;
fip->fi_writers = 0;
wso->so_state |= SS_CANTRCVMORE;
rso->so_state |= SS_CANTSENDMORE;
cv_init(&fip->fi_rcv, "fiford");
cv_init(&fip->fi_wcv, "fifowr");
vp->v_fifoinfo = fip;
} else {
wso = fip->fi_writesock;
rso = fip->fi_readsock;
solock(wso);
}
if (ap->a_mode & FREAD) {
if (fip->fi_readers++ == 0) {
wso->so_state &= ~SS_CANTSENDMORE;
cv_broadcast(&fip->fi_wcv);
}
}
if (ap->a_mode & FWRITE) {
if (fip->fi_writers++ == 0) {
rso->so_state &= ~SS_CANTRCVMORE;
cv_broadcast(&fip->fi_rcv);
}
}
if (ap->a_mode & FREAD) {
if (ap->a_mode & O_NONBLOCK) {
} else {
while (!soreadable(rso) && fip->fi_writers == 0) {
VOP_UNLOCK(vp);
error = cv_wait_sig(&fip->fi_rcv,
wso->so_lock);
sounlock(wso);
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
if (error)
goto bad;
solock(wso);
}
}
}
if (ap->a_mode & FWRITE) {
if (ap->a_mode & O_NONBLOCK) {
if (fip->fi_readers == 0) {
error = ENXIO;
sounlock(wso);
goto bad;
}
} else {
while (fip->fi_readers == 0) {
VOP_UNLOCK(vp);
error = cv_wait_sig(&fip->fi_wcv,
wso->so_lock);
sounlock(wso);
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
if (error)
goto bad;
solock(wso);
}
}
}
sounlock(wso);
return (0);
bad:
VOP_CLOSE(vp, ap->a_mode, ap->a_cred);
return (error);
}
/*
* Slightly changed version of sosend()
*/
static int
kttcp_sosend(struct socket *so, unsigned long long slen,
unsigned long long *done, struct lwp *l, int flags)
{
struct mbuf **mp, *m, *top;
long space, len, mlen;
int error, dontroute, atomic;
long long resid;
atomic = sosendallatonce(so);
resid = slen;
top = NULL;
/*
* In theory resid should be unsigned.
* However, space must be signed, as it might be less than 0
* if we over-committed, and we must use a signed comparison
* of space and resid. On the other hand, a negative resid
* causes us to loop sending 0-length segments to the protocol.
*/
if (resid < 0) {
error = EINVAL;
goto out;
}
dontroute =
(flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 &&
(so->so_proto->pr_flags & PR_ATOMIC);
l->l_ru.ru_msgsnd++;
#define snderr(errno) { error = errno; goto release; }
solock(so);
restart:
if ((error = sblock(&so->so_snd, SBLOCKWAIT(flags))) != 0)
goto out;
do {
if (so->so_state & SS_CANTSENDMORE)
snderr(EPIPE);
if (so->so_error) {
error = so->so_error;
so->so_error = 0;
goto release;
}
if ((so->so_state & SS_ISCONNECTED) == 0) {
if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
snderr(ENOTCONN);
} else {
snderr(EDESTADDRREQ);
}
}
space = sbspace(&so->so_snd);
if (flags & MSG_OOB)
space += 1024;
if ((atomic && resid > so->so_snd.sb_hiwat))
snderr(EMSGSIZE);
if (space < resid && (atomic || space < so->so_snd.sb_lowat)) {
if (so->so_state & SS_NBIO)
snderr(EWOULDBLOCK);
SBLASTRECORDCHK(&so->so_rcv,
"kttcp_soreceive sbwait 1");
SBLASTMBUFCHK(&so->so_rcv,
"kttcp_soreceive sbwait 1");
sbunlock(&so->so_snd);
error = sbwait(&so->so_snd);
if (error)
goto out;
goto restart;
}
mp = ⊤
do {
sounlock(so);
do {
if (top == 0) {
m = m_gethdr(M_WAIT, MT_DATA);
mlen = MHLEN;
m->m_pkthdr.len = 0;
m->m_pkthdr.rcvif = NULL;
} else {
m = m_get(M_WAIT, MT_DATA);
mlen = MLEN;
}
if (resid >= MINCLSIZE && space >= MCLBYTES) {
m_clget(m, M_WAIT);
if ((m->m_flags & M_EXT) == 0)
goto nopages;
mlen = MCLBYTES;
#ifdef MAPPED_MBUFS
len = lmin(MCLBYTES, resid);
#else
if (atomic && top == 0) {
len = lmin(MCLBYTES - max_hdr,
resid);
m->m_data += max_hdr;
} else
len = lmin(MCLBYTES, resid);
#endif
space -= len;
} else {
nopages:
len = lmin(lmin(mlen, resid), space);
space -= len;
/*
* For datagram protocols, leave room
* for protocol headers in first mbuf.
*/
if (atomic && top == 0 && len < mlen)
MH_ALIGN(m, len);
}
resid -= len;
m->m_len = len;
*mp = m;
top->m_pkthdr.len += len;
if (error)
goto release;
mp = &m->m_next;
if (resid <= 0) {
if (flags & MSG_EOR)
top->m_flags |= M_EOR;
break;
}
} while (space > 0 && atomic);
solock(so);
if (so->so_state & SS_CANTSENDMORE)
snderr(EPIPE);
if (dontroute)
so->so_options |= SO_DONTROUTE;
if (resid > 0)
so->so_state |= SS_MORETOCOME;
if (flags & MSG_OOB)
error = (*so->so_proto->pr_usrreqs->pr_sendoob)(so,
top, NULL);
else
error = (*so->so_proto->pr_usrreqs->pr_send)(so,
top, NULL, NULL, l);
if (dontroute)
so->so_options &= ~SO_DONTROUTE;
if (resid > 0)
so->so_state &= ~SS_MORETOCOME;
top = 0;
mp = ⊤
if (error)
goto release;
} while (resid && space > 0);
} while (resid);
release:
sbunlock(&so->so_snd);
out:
sounlock(so);
if (top)
m_freem(top);
*done = slen - resid;
#if 0
printf("sosend: error %d slen %llu resid %lld\n", error, slen, resid);
#endif
return (error);
}
static int
kttcp_soreceive(struct socket *so, unsigned long long slen,
unsigned long long *done, struct lwp *l, int *flagsp)
{
struct mbuf *m, **mp;
int flags, len, error, offset, moff, type;
long long orig_resid, resid;
const struct protosw *pr;
struct mbuf *nextrecord;
pr = so->so_proto;
mp = NULL;
type = 0;
resid = orig_resid = slen;
if (flagsp)
flags = *flagsp &~ MSG_EOR;
else
flags = 0;
if (flags & MSG_OOB) {
m = m_get(M_WAIT, MT_DATA);
solock(so);
error = (*pr->pr_usrreqs->pr_recvoob)(so, m, flags & MSG_PEEK);
sounlock(so);
if (error)
goto bad;
do {
resid -= min(resid, m->m_len);
m = m_free(m);
} while (resid && error == 0 && m);
bad:
if (m)
m_freem(m);
return (error);
}
if (mp)
*mp = NULL;
solock(so);
restart:
if ((error = sblock(&so->so_rcv, SBLOCKWAIT(flags))) != 0)
return (error);
m = so->so_rcv.sb_mb;
/*
* If we have less data than requested, block awaiting more
* (subject to any timeout) if:
* 1. the current count is less than the low water mark,
* 2. MSG_WAITALL is set, and it is possible to do the entire
* receive operation at once if we block (resid <= hiwat), or
* 3. MSG_DONTWAIT is not set.
* If MSG_WAITALL is set but resid is larger than the receive buffer,
* we have to do the receive in sections, and thus risk returning
* a short count if a timeout or signal occurs after we start.
*/
if (m == NULL || (((flags & MSG_DONTWAIT) == 0 &&
so->so_rcv.sb_cc < resid) &&
(so->so_rcv.sb_cc < so->so_rcv.sb_lowat ||
((flags & MSG_WAITALL) && resid <= so->so_rcv.sb_hiwat)) &&
m->m_nextpkt == NULL && (pr->pr_flags & PR_ATOMIC) == 0)) {
#ifdef DIAGNOSTIC
if (m == NULL && so->so_rcv.sb_cc)
panic("receive 1");
#endif
if (so->so_error) {
if (m)
goto dontblock;
error = so->so_error;
if ((flags & MSG_PEEK) == 0)
so->so_error = 0;
goto release;
}
if (so->so_state & SS_CANTRCVMORE) {
if (m)
goto dontblock;
else
goto release;
}
for (; m; m = m->m_next)
if (m->m_type == MT_OOBDATA || (m->m_flags & M_EOR)) {
m = so->so_rcv.sb_mb;
goto dontblock;
}
if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 &&
(so->so_proto->pr_flags & PR_CONNREQUIRED)) {
error = ENOTCONN;
goto release;
}
if (resid == 0)
goto release;
if ((so->so_state & SS_NBIO) ||
(flags & (MSG_DONTWAIT|MSG_NBIO))) {
error = EWOULDBLOCK;
goto release;
}
sbunlock(&so->so_rcv);
error = sbwait(&so->so_rcv);
if (error) {
sounlock(so);
return (error);
}
goto restart;
}
dontblock:
/*
* On entry here, m points to the first record of the socket buffer.
* While we process the initial mbufs containing address and control
* info, we save a copy of m->m_nextpkt into nextrecord.
*/
#ifdef notyet /* XXXX */
if (uio->uio_lwp)
uio->uio_lwp->l_ru.ru_msgrcv++;
#endif
KASSERT(m == so->so_rcv.sb_mb);
SBLASTRECORDCHK(&so->so_rcv, "kttcp_soreceive 1");
SBLASTMBUFCHK(&so->so_rcv, "kttcp_soreceive 1");
nextrecord = m->m_nextpkt;
if (pr->pr_flags & PR_ADDR) {
#ifdef DIAGNOSTIC
if (m->m_type != MT_SONAME)
panic("receive 1a");
#endif
orig_resid = 0;
if (flags & MSG_PEEK) {
m = m->m_next;
} else {
sbfree(&so->so_rcv, m);
MFREE(m, so->so_rcv.sb_mb);
m = so->so_rcv.sb_mb;
}
}
while (m && m->m_type == MT_CONTROL && error == 0) {
if (flags & MSG_PEEK) {
m = m->m_next;
} else {
sbfree(&so->so_rcv, m);
MFREE(m, so->so_rcv.sb_mb);
m = so->so_rcv.sb_mb;
}
}
/*
* If m is non-NULL, we have some data to read. From now on,
* make sure to keep sb_lastrecord consistent when working on
* the last packet on the chain (nextrecord == NULL) and we
* change m->m_nextpkt.
*/
if (m) {
if ((flags & MSG_PEEK) == 0) {
m->m_nextpkt = nextrecord;
/*
* If nextrecord == NULL (this is a single chain),
* then sb_lastrecord may not be valid here if m
* was changed earlier.
*/
if (nextrecord == NULL) {
KASSERT(so->so_rcv.sb_mb == m);
so->so_rcv.sb_lastrecord = m;
}
}
type = m->m_type;
if (type == MT_OOBDATA)
flags |= MSG_OOB;
} else {
if ((flags & MSG_PEEK) == 0) {
KASSERT(so->so_rcv.sb_mb == m);
so->so_rcv.sb_mb = nextrecord;
SB_EMPTY_FIXUP(&so->so_rcv);
}
}
SBLASTRECORDCHK(&so->so_rcv, "kttcp_soreceive 2");
SBLASTMBUFCHK(&so->so_rcv, "kttcp_soreceive 2");
moff = 0;
offset = 0;
while (m && resid > 0 && error == 0) {
if (m->m_type == MT_OOBDATA) {
if (type != MT_OOBDATA)
break;
} else if (type == MT_OOBDATA)
break;
#ifdef DIAGNOSTIC
else if (m->m_type != MT_DATA && m->m_type != MT_HEADER)
panic("receive 3");
#endif
so->so_state &= ~SS_RCVATMARK;
len = resid;
if (so->so_oobmark && len > so->so_oobmark - offset)
len = so->so_oobmark - offset;
if (len > m->m_len - moff)
len = m->m_len - moff;
/*
* If mp is set, just pass back the mbufs.
* Otherwise copy them out via the uio, then free.
* Sockbuf must be consistent here (points to current mbuf,
* it points to next record) when we drop priority;
* we must note any additions to the sockbuf when we
* block interrupts again.
*/
resid -= len;
if (len == m->m_len - moff) {
if (m->m_flags & M_EOR)
flags |= MSG_EOR;
if (flags & MSG_PEEK) {
m = m->m_next;
moff = 0;
} else {
nextrecord = m->m_nextpkt;
sbfree(&so->so_rcv, m);
if (mp) {
*mp = m;
mp = &m->m_next;
so->so_rcv.sb_mb = m = m->m_next;
*mp = NULL;
} else {
MFREE(m, so->so_rcv.sb_mb);
m = so->so_rcv.sb_mb;
}
/*
* If m != NULL, we also know that
* so->so_rcv.sb_mb != NULL.
*/
KASSERT(so->so_rcv.sb_mb == m);
if (m) {
m->m_nextpkt = nextrecord;
if (nextrecord == NULL)
so->so_rcv.sb_lastrecord = m;
} else {
so->so_rcv.sb_mb = nextrecord;
SB_EMPTY_FIXUP(&so->so_rcv);
}
SBLASTRECORDCHK(&so->so_rcv,
"kttcp_soreceive 3");
SBLASTMBUFCHK(&so->so_rcv,
"kttcp_soreceive 3");
}
} else {
if (flags & MSG_PEEK)
moff += len;
else {
if (mp) {
sounlock(so);
*mp = m_copym(m, 0, len, M_WAIT);
solock(so);
}
m->m_data += len;
m->m_len -= len;
so->so_rcv.sb_cc -= len;
}
}
if (so->so_oobmark) {
if ((flags & MSG_PEEK) == 0) {
so->so_oobmark -= len;
if (so->so_oobmark == 0) {
so->so_state |= SS_RCVATMARK;
break;
}
} else {
offset += len;
if (offset == so->so_oobmark)
break;
}
}
if (flags & MSG_EOR)
break;
/*
* If the MSG_WAITALL flag is set (for non-atomic socket),
* we must not quit until "uio->uio_resid == 0" or an error
* termination. If a signal/timeout occurs, return
* with a short count but without error.
* Keep sockbuf locked against other readers.
*/
while (flags & MSG_WAITALL && m == NULL && resid > 0 &&
!sosendallatonce(so) && !nextrecord) {
if (so->so_error || so->so_state & SS_CANTRCVMORE)
break;
/*
* If we are peeking and the socket receive buffer is
* full, stop since we can't get more data to peek at.
*/
if ((flags & MSG_PEEK) && sbspace(&so->so_rcv) <= 0)
break;
/*
* If we've drained the socket buffer, tell the
* protocol in case it needs to do something to
* get it filled again.
*/
if ((pr->pr_flags & PR_WANTRCVD) && so->so_pcb) {
(*pr->pr_usrreqs->pr_rcvd)(so, flags, l);
}
SBLASTRECORDCHK(&so->so_rcv,
"kttcp_soreceive sbwait 2");
SBLASTMBUFCHK(&so->so_rcv,
"kttcp_soreceive sbwait 2");
error = sbwait(&so->so_rcv);
if (error) {
sbunlock(&so->so_rcv);
sounlock(so);
return (0);
}
if ((m = so->so_rcv.sb_mb) != NULL)
nextrecord = m->m_nextpkt;
}
}
if (m && pr->pr_flags & PR_ATOMIC) {
flags |= MSG_TRUNC;
if ((flags & MSG_PEEK) == 0)
(void) sbdroprecord(&so->so_rcv);
}
if ((flags & MSG_PEEK) == 0) {
if (m == NULL) {
/*
* First part is an SB_EMPTY_FIXUP(). Second part
* makes sure sb_lastrecord is up-to-date if
* there is still data in the socket buffer.
*/
so->so_rcv.sb_mb = nextrecord;
if (so->so_rcv.sb_mb == NULL) {
so->so_rcv.sb_mbtail = NULL;
so->so_rcv.sb_lastrecord = NULL;
} else if (nextrecord->m_nextpkt == NULL)
so->so_rcv.sb_lastrecord = nextrecord;
}
SBLASTRECORDCHK(&so->so_rcv, "kttcp_soreceive 4");
SBLASTMBUFCHK(&so->so_rcv, "kttcp_soreceive 4");
if (pr->pr_flags & PR_WANTRCVD && so->so_pcb) {
(*pr->pr_usrreqs->pr_rcvd)(so, flags, l);
}
}
if (orig_resid == resid && orig_resid &&
(flags & MSG_EOR) == 0 && (so->so_state & SS_CANTRCVMORE) == 0) {
sbunlock(&so->so_rcv);
goto restart;
}
if (flagsp)
*flagsp |= flags;
release:
sbunlock(&so->so_rcv);
sounlock(so);
*done = slen - resid;
#if 0
printf("soreceive: error %d slen %llu resid %lld\n", error, slen, resid);
#endif
return (error);
}
/* ARGSUSED4 */
int
if_route(const struct interface *iface, const struct in_addr *dest,
const struct in_addr *net, const struct in_addr *gate,
int metric, int action)
{
int error;
union sockunion {
struct sockaddr sa;
struct sockaddr_in sin;
#ifdef INET6
struct sockaddr_in6 sin6;
#endif
struct sockaddr_dl sdl;
struct sockaddr_storage ss;
} su;
struct rtm
{
struct rt_msghdr hdr;
char buffer[sizeof(su) * 4];
} rtm;
char *bp = rtm.buffer, *p;
size_t l;
struct mbuf *m;
#define ADDSU(_su) { \
l = RT_ROUNDUP(_su.sa.sa_len); \
memcpy(bp, &(_su), l); \
bp += l; \
}
#define ADDADDR(_a) { \
memset (&su, 0, sizeof(su)); \
su.sin.sin_family = AF_INET; \
su.sin.sin_len = sizeof(su.sin); \
memcpy (&su.sin.sin_addr, _a, sizeof(su.sin.sin_addr)); \
ADDSU(su); \
}
memset(&rtm, 0, sizeof(rtm));
rtm.hdr.rtm_version = RTM_VERSION;
rtm.hdr.rtm_seq = 1;
if (action == 0)
rtm.hdr.rtm_type = RTM_CHANGE;
else if (action > 0)
rtm.hdr.rtm_type = RTM_ADD;
else {
rtm.hdr.rtm_type = RTM_DELETE;
/* shortcircuit a bit for now */
return 0;
}
rtm.hdr.rtm_flags = RTF_UP;
/* None interface subnet routes are static. */
if (gate->s_addr != INADDR_ANY ||
net->s_addr != iface->net.s_addr ||
dest->s_addr != (iface->addr.s_addr & iface->net.s_addr))
rtm.hdr.rtm_flags |= RTF_STATIC;
rtm.hdr.rtm_addrs = RTA_DST | RTA_GATEWAY;
if (dest->s_addr == gate->s_addr && net->s_addr == INADDR_BROADCAST)
rtm.hdr.rtm_flags |= RTF_HOST;
else {
rtm.hdr.rtm_addrs |= RTA_NETMASK;
if (rtm.hdr.rtm_flags & RTF_STATIC)
rtm.hdr.rtm_flags |= RTF_GATEWAY;
if (action >= 0)
rtm.hdr.rtm_addrs |= RTA_IFA;
}
ADDADDR(dest);
if (rtm.hdr.rtm_flags & RTF_HOST ||
!(rtm.hdr.rtm_flags & RTF_STATIC))
{
/* Make us a link layer socket for the host gateway */
memset(&su, 0, sizeof(su));
memcpy(&su.sdl, iface->ifp->if_sadl, sizeof(su.sdl));
ADDSU(su);
} else {
ADDADDR(gate);
}
if (rtm.hdr.rtm_addrs & RTA_NETMASK) {
/* Ensure that netmask is set correctly */
memset(&su, 0, sizeof(su));
su.sin.sin_family = AF_INET;
su.sin.sin_len = sizeof(su.sin);
memcpy(&su.sin.sin_addr, &net->s_addr, sizeof(su.sin.sin_addr));
p = su.sa.sa_len + (char *)&su;
for (su.sa.sa_len = 0; p > (char *)&su;)
if (*--p != 0) {
su.sa.sa_len = 1 + p - (char *)&su;
break;
}
ADDSU(su);
}
if (rtm.hdr.rtm_addrs & RTA_IFA)
ADDADDR(&iface->addr);
m = m_gethdr(M_WAIT, MT_DATA);
m->m_pkthdr.len = rtm.hdr.rtm_msglen = l = bp - (char *)&rtm;
m->m_len = 0;
m_copyback(m, 0, l, &rtm);
/* XXX: no check */
solock(routeso);
#if __NetBSD_Prereq__(7,99,26)
error = routeso->so_proto->pr_usrreqs->pr_send(routeso,
m, NULL, NULL, curlwp);
#else
error = routeso->so_proto->pr_output(m, routeso);
#endif
sounlock(routeso);
return error;
}
int
soo_ioctl(file_t *fp, u_long cmd, void *data)
{
struct socket *so = fp->f_data;
int error = 0;
switch (cmd) {
case FIONBIO:
solock(so);
if (*(int *)data)
so->so_state |= SS_NBIO;
else
so->so_state &= ~SS_NBIO;
sounlock(so);
break;
case FIOASYNC:
solock(so);
if (*(int *)data) {
so->so_state |= SS_ASYNC;
so->so_rcv.sb_flags |= SB_ASYNC;
so->so_snd.sb_flags |= SB_ASYNC;
} else {
so->so_state &= ~SS_ASYNC;
so->so_rcv.sb_flags &= ~SB_ASYNC;
so->so_snd.sb_flags &= ~SB_ASYNC;
}
sounlock(so);
break;
case FIONREAD:
*(int *)data = so->so_rcv.sb_cc;
break;
case FIONWRITE:
*(int *)data = so->so_snd.sb_cc;
break;
case FIONSPACE:
/*
* See the comment around sbspace()'s definition
* in sys/socketvar.h in face of counts about maximum
* to understand the following test. We detect overflow
* and return zero.
*/
solock(so);
if ((so->so_snd.sb_hiwat < so->so_snd.sb_cc)
|| (so->so_snd.sb_mbmax < so->so_snd.sb_mbcnt))
*(int *)data = 0;
else
*(int *)data = sbspace(&so->so_snd);
sounlock(so);
break;
case SIOCSPGRP:
case FIOSETOWN:
case TIOCSPGRP:
error = fsetown(&so->so_pgid, cmd, data);
break;
case SIOCGPGRP:
case FIOGETOWN:
case TIOCGPGRP:
error = fgetown(so->so_pgid, cmd, data);
break;
case SIOCATMARK:
*(int *)data = (so->so_state&SS_RCVATMARK) != 0;
break;
default:
/*
* Interface/routing/protocol specific ioctls:
* interface and routing ioctls should have a
* different entry since a socket's unnecessary
*/
KERNEL_LOCK(1, NULL);
if (IOCGROUP(cmd) == 'i')
error = ifioctl(so, cmd, data, curlwp);
else if (IOCGROUP(cmd) == 'r')
error = rtioctl(cmd, data, curlwp);
else {
error = (*so->so_proto->pr_usrreq)(so, PRU_CONTROL,
(struct mbuf *)cmd, (struct mbuf *)data, NULL,
curlwp);
}
KERNEL_UNLOCK_ONE(NULL);
break;
}
return error;
}
