int
darwin_sys_sendto(struct lwp *l, const struct darwin_sys_sendto_args *uap, register_t *retval)
{
/* {
syscallarg(int) s;
syscallarg(const void *) buf;
syscallarg(size_t) len;
syscallarg(int) flags;
syscallarg(struct sockaddr *) to;
syscallarg(unsigned int) tolen;
} */
struct msghdr msg;
struct iovec aiov;
struct mbuf *nam;
int error;
error = sockargs(&nam, SCARG(uap, to), SCARG(uap, tolen), MT_SONAME);
if (error != 0)
return error;
error = darwin_to_native_sockaddr(nam);
if (error != 0)
return error;
msg.msg_name = nam;
msg.msg_namelen = 0;
msg.msg_iov = &aiov;
msg.msg_iovlen = 1;
msg.msg_control = 0;
msg.msg_flags = MSG_NAMEMBUF;
aiov.iov_base = __UNCONST(SCARG(uap, buf)); /* XXXUNCONST kills const */
aiov.iov_len = SCARG(uap, len);
return do_sys_sendmsg(l, SCARG(uap, s), &msg, SCARG(uap, flags), retval);
}
/* ARGSUSED */
int
sys_bind(struct proc *p, void *v, register_t *retval)
{
struct sys_bind_args /* {
syscallarg(int) s;
syscallarg(const struct sockaddr *) name;
syscallarg(socklen_t) namelen;
} */ *uap = v;
struct file *fp;
struct mbuf *nam;
int error;
if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0)
return (error);
error = sockargs(&nam, SCARG(uap, name), SCARG(uap, namelen),
MT_SONAME);
if (error == 0) {
#ifdef KTRACE
if (KTRPOINT(p, KTR_STRUCT))
ktrsockaddr(p, mtod(nam, caddr_t), SCARG(uap, namelen));
#endif
error = sobind(fp->f_data, nam, p);
m_freem(nam);
}
FRELE(fp, p);
return (error);
}
/* ARGSUSED */
int
sys_connect(struct proc *p, void *v, register_t *retval)
{
struct sys_connect_args /* {
syscallarg(int) s;
syscallarg(const struct sockaddr *) name;
syscallarg(socklen_t) namelen;
} */ *uap = v;
struct file *fp;
struct socket *so;
struct mbuf *nam = NULL;
int error, s;
if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0)
return (error);
so = fp->f_data;
if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {
FRELE(fp, p);
return (EALREADY);
}
error = sockargs(&nam, SCARG(uap, name), SCARG(uap, namelen),
MT_SONAME);
if (error)
goto bad;
#ifdef KTRACE
if (KTRPOINT(p, KTR_STRUCT))
ktrsockaddr(p, mtod(nam, caddr_t), SCARG(uap, namelen));
#endif
error = soconnect(so, nam);
if (error)
goto bad;
if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {
FRELE(fp, p);
m_freem(nam);
return (EINPROGRESS);
}
s = splsoftnet();
while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
error = tsleep(&so->so_timeo, PSOCK | PCATCH, "netcon2", 0);
if (error)
break;
}
if (error == 0) {
error = so->so_error;
so->so_error = 0;
}
splx(s);
bad:
so->so_state &= ~SS_ISCONNECTING;
FRELE(fp, p);
if (nam)
m_freem(nam);
if (error == ERESTART)
error = EINTR;
return (error);
}
static int bsd_bind ( cyg_file *fp, const sockaddr *sa, socklen_t len )
{
struct mbuf *nam;
int error;
error = sockargs(&nam, (caddr_t)sa, len, MT_SONAME);
if (error)
return (error);
error = sobind((struct socket *)fp->f_data, nam);
m_freem(nam);
return error;
}
static int bsd_connect ( cyg_file *fp, const sockaddr *sa, socklen_t len )
{
register struct socket *so;
struct mbuf *nam;
int error, s;
so = (struct socket *)fp->f_data;
if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING))
return (EALREADY);
error = sockargs(&nam, (caddr_t)sa, len, MT_SONAME);
if (error)
return (error);
error = soconnect(so, nam);
if (error)
goto bad;
if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {
m_freem(nam);
return (EINPROGRESS);
}
s = splsoftnet();
while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
error = tsleep((caddr_t)&so->so_timeo, PSOCK | PCATCH,
netcon, 0);
if (error)
break;
}
if (error == 0) {
error = so->so_error;
so->so_error = 0;
}
splx(s);
bad:
so->so_state &= ~SS_ISCONNECTING;
m_freem(nam);
return error;
}
int
sys_connect(struct lwp *l, const struct sys_connect_args *uap,
register_t *retval)
{
/* {
syscallarg(int) s;
syscallarg(const struct sockaddr *) name;
syscallarg(unsigned int) namelen;
} */
int error;
struct mbuf *nam;
error = sockargs(&nam, SCARG(uap, name), SCARG(uap, namelen),
MT_SONAME);
if (error)
return error;
return do_sys_connect(l, SCARG(uap, s), nam);
}
int
darwin_sys_bind(struct lwp *l, const struct darwin_sys_bind_args *uap, register_t *retval)
{
/* {
syscallarg(int) s;
syscallarg(struct sockaddr *) name;
syscallarg(unsigned int *) namelen;
} */
struct mbuf *nam;
int error;
error = sockargs(&nam, SCARG(uap, name), SCARG(uap, namelen),
MT_SONAME);
if (error == 0)
error = darwin_to_native_sockaddr(nam);
if (error == 0)
error = do_sys_bind(l, SCARG(uap, s), nam);
return error;
}
int
t_bind (long s,
struct sockaddr * addr,
int addrlen)
{
struct mbuf * nam;
struct sockaddr sa;
struct sockaddr * sap;
struct socket * so;
int err;
so = LONG2SO(s); /* convert long to socket */
SOC_CHECK(so);
DOMAIN_CHECK(so, addrlen);
so->so_error = 0;
if (addr == (struct sockaddr *)NULL)
{
MEMSET ((void *)&sa, 0, sizeof(sa));
addrlen = sizeof(sa);
sa.sa_family = so->so_domain;
sap = &sa;
} else
sap = addr;
if ((nam = sockargs (sap, addrlen, MT_SONAME)) == NULL)
{
so->so_error = ENOMEM;
return SOCKET_ERROR;
}
LOCK_NET_RESOURCE(NET_RESID);
err = sobind (so, nam);
m_freem(nam);
UNLOCK_NET_RESOURCE(NET_RESID);
if (err)
{
so->so_error = err;
return SOCKET_ERROR;
}
return 0;
}
int
t_sendto (long s,
char * buf,
int len,
int flags,
struct sockaddr * to,
int tolen)
{
struct socket * so;
int sendlen;
int err;
struct mbuf * name;
so = LONG2SO(s);
SOC_CHECK(so);
so->so_error = 0;
switch (so->so_type)
{
case SOCK_STREAM:
/* this is a stream socket, so pass this request through
* t_send() for its large-send support.
*/
return t_send(s, buf, len, flags);
/*NOTREACHED*/
case SOCK_DGRAM:
/* datagram (UDP) socket -- prepare to check length */
sendlen = udp_maxalloc();
break;
#ifdef IP_RAW
case SOCK_RAW:
/* raw socket -- prepare to check length */
sendlen = ip_raw_maxalloc(so->so_options & SO_HDRINCL);
break;
#endif /* IP_RAW */
default:
/* socket has unknown type */
dtrap();
so->so_error = EFAULT;
return SOCKET_ERROR;
/*NOTREACHED*/
}
/* fall through for non-stream sockets: SOCK_DGRAM (UDP) and
* SOCK_RAW (raw IP)
*/
/* check length against underlying stack's maximum */
if (len > sendlen)
{
so->so_error = EMSGSIZE;
return SOCKET_ERROR;
}
/* if a sockaddr was passed, wrap it in an mbuf and pas it into the
* bowels of the BSD code; else assume this is a bound UDP socket
* and this call came from t_send() below.
*/
if (to) /* sockaddr was passed */
{
name = sockargs(to, tolen, MT_SONAME);
if(name == NULL)
{
so->so_error = ENOMEM;
return SOCKET_ERROR;
}
}
else /* hope user called bind() first... */
name = NULL;
sendlen = len;
LOCK_NET_RESOURCE(NET_RESID);
err = sosend (so, name, buf, &sendlen, flags);
if (name)
m_freem(name);
UNLOCK_NET_RESOURCE(NET_RESID);
if (err != 0)
{
so->so_error = err;
return SOCKET_ERROR;
}
return (len - sendlen);
}
int
t_connect(long s,
struct sockaddr * addr,
int addrlen)
{
struct socket * so;
struct mbuf * nam;
so = LONG2SO(s);
SOC_CHECK(so);
DOMAIN_CHECK(so, addrlen);
#ifdef NB_CONNECT
/* need to test non blocking connect bits in case this is a
poll of a previous request */
if (so->so_state & SS_NBIO)
{
if (so->so_state & SS_ISCONNECTING) /* still trying */
{
so->so_error = EINPROGRESS;
return SOCKET_ERROR;
}
if (so->so_state & SS_ISCONNECTED) /* connected OK */
{
so->so_error = 0;
return 0;
}
if (so->so_state & SS_WASCONNECTING)
{
so->so_state &= ~SS_WASCONNECTING;
if (so->so_error) /* connect error - maybe timeout */
return SOCKET_ERROR;
}
}
#endif /* NB_CONNECT */
so->so_error = 0;
if ((nam = sockargs (addr, addrlen, MT_SONAME))
== NULL)
{
so->so_error = ENOMEM;
return SOCKET_ERROR;
}
#ifdef TRACE_DEBUG
{ struct sockaddr_in *sin = (struct sockaddr_in *)uap->sap;
INET_TRACE (INETM_SOCKET, ("INET: connect, port %d addr %lx\n",
sin->sin_port, sin->sin_addr.s_addr));
}
#endif /* TRACE_DEBUG */
LOCK_NET_RESOURCE(NET_RESID);
if ((so->so_error = soconnect (so, nam)) != 0)
goto bad;
#ifdef NB_CONNECT
/* need to test non blocking connect bits after soconnect() call */
if ((so->so_state & SS_NBIO)&& (so->so_state & SS_ISCONNECTING))
{
so->so_error = EINPROGRESS;
goto bad;
}
#endif /* NB_CONNECT */
INET_TRACE (INETM_SOCKET, ("INET: connect, so %x so_state %x so_error %d\n",
so, so->so_state, so->so_error));
while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0)
{
tcp_sleep ((char *)&so->so_timeo);
}
bad:
if (so->so_error != EINPROGRESS)
so->so_state &= ~(SS_ISCONNECTING|SS_WASCONNECTING);
m_freem (nam);
UNLOCK_NET_RESOURCE(NET_RESID);
if (so->so_error)
{
/* printf("t_connect(): so_error = %d\n", so->so_error);*/
return SOCKET_ERROR;
}
return 0;
}
static int
do_sys_sendmsg_so(struct lwp *l, int s, struct socket *so, file_t *fp,
struct msghdr *mp, int flags, register_t *retsize)
{
struct iovec aiov[UIO_SMALLIOV], *iov = aiov, *tiov, *ktriov = NULL;
struct mbuf *to, *control;
struct uio auio;
size_t len, iovsz;
int i, error;
ktrkuser("msghdr", mp, sizeof *mp);
/* If the caller passed us stuff in mbufs, we must free them. */
to = (mp->msg_flags & MSG_NAMEMBUF) ? mp->msg_name : NULL;
control = (mp->msg_flags & MSG_CONTROLMBUF) ? mp->msg_control : NULL;
iovsz = mp->msg_iovlen * sizeof(struct iovec);
if (mp->msg_flags & MSG_IOVUSRSPACE) {
if ((unsigned int)mp->msg_iovlen > UIO_SMALLIOV) {
if ((unsigned int)mp->msg_iovlen > IOV_MAX) {
error = EMSGSIZE;
goto bad;
}
iov = kmem_alloc(iovsz, KM_SLEEP);
}
if (mp->msg_iovlen != 0) {
error = copyin(mp->msg_iov, iov, iovsz);
if (error)
goto bad;
}
mp->msg_iov = iov;
}
auio.uio_iov = mp->msg_iov;
auio.uio_iovcnt = mp->msg_iovlen;
auio.uio_rw = UIO_WRITE;
auio.uio_offset = 0; /* XXX */
auio.uio_resid = 0;
KASSERT(l == curlwp);
auio.uio_vmspace = l->l_proc->p_vmspace;
for (i = 0, tiov = mp->msg_iov; i < mp->msg_iovlen; i++, tiov++) {
/*
* Writes return ssize_t because -1 is returned on error.
* Therefore, we must restrict the length to SSIZE_MAX to
* avoid garbage return values.
*/
auio.uio_resid += tiov->iov_len;
if (tiov->iov_len > SSIZE_MAX || auio.uio_resid > SSIZE_MAX) {
error = EINVAL;
goto bad;
}
}
if (mp->msg_name && to == NULL) {
error = sockargs(&to, mp->msg_name, mp->msg_namelen,
MT_SONAME);
if (error)
goto bad;
}
if (mp->msg_control) {
if (mp->msg_controllen < CMSG_ALIGN(sizeof(struct cmsghdr))) {
error = EINVAL;
goto bad;
}
if (control == NULL) {
error = sockargs(&control, mp->msg_control,
mp->msg_controllen, MT_CONTROL);
if (error)
goto bad;
}
}
if (ktrpoint(KTR_GENIO) && iovsz > 0) {
ktriov = kmem_alloc(iovsz, KM_SLEEP);
memcpy(ktriov, auio.uio_iov, iovsz);
}
if (mp->msg_name)
MCLAIM(to, so->so_mowner);
if (mp->msg_control)
MCLAIM(control, so->so_mowner);
len = auio.uio_resid;
error = (*so->so_send)(so, to, &auio, NULL, control, flags, l);
/* Protocol is responsible for freeing 'control' */
control = NULL;
if (error) {
if (auio.uio_resid != len && (error == ERESTART ||
error == EINTR || error == EWOULDBLOCK))
error = 0;
if (error == EPIPE && (fp->f_flag & FNOSIGPIPE) == 0 &&
(flags & MSG_NOSIGNAL) == 0) {
mutex_enter(proc_lock);
psignal(l->l_proc, SIGPIPE);
mutex_exit(proc_lock);
}
}
if (error == 0)
*retsize = len - auio.uio_resid;
bad:
if (ktriov != NULL) {
ktrgeniov(s, UIO_WRITE, ktriov, *retsize, error);
kmem_free(ktriov, iovsz);
}
if (iov != aiov)
kmem_free(iov, iovsz);
if (to)
m_freem(to);
if (control)
m_freem(control);
return error;
}
int
sendit(struct proc *p, int s, struct msghdr *mp, int flags, register_t *retsize)
{
struct file *fp;
struct uio auio;
struct iovec *iov;
int i;
struct mbuf *to, *control;
size_t len;
int error;
#ifdef KTRACE
struct iovec *ktriov = NULL;
#endif
to = NULL;
if ((error = getsock(p->p_fd, s, &fp)) != 0)
return (error);
auio.uio_iov = mp->msg_iov;
auio.uio_iovcnt = mp->msg_iovlen;
auio.uio_segflg = UIO_USERSPACE;
auio.uio_rw = UIO_WRITE;
auio.uio_procp = p;
auio.uio_offset = 0; /* XXX */
auio.uio_resid = 0;
iov = mp->msg_iov;
for (i = 0; i < mp->msg_iovlen; i++, iov++) {
/* Don't allow sum > SSIZE_MAX */
if (iov->iov_len > SSIZE_MAX ||
(auio.uio_resid += iov->iov_len) > SSIZE_MAX) {
error = EINVAL;
goto bad;
}
}
if (mp->msg_name) {
error = sockargs(&to, mp->msg_name, mp->msg_namelen,
MT_SONAME);
if (error)
goto bad;
#ifdef KTRACE
if (KTRPOINT(p, KTR_STRUCT))
ktrsockaddr(p, mtod(to, caddr_t), mp->msg_namelen);
#endif
}
if (mp->msg_control) {
if (mp->msg_controllen < CMSG_ALIGN(sizeof(struct cmsghdr))) {
error = EINVAL;
goto bad;
}
error = sockargs(&control, mp->msg_control,
mp->msg_controllen, MT_CONTROL);
if (error)
goto bad;
} else
control = 0;
#ifdef KTRACE
if (KTRPOINT(p, KTR_GENIO)) {
int iovlen = auio.uio_iovcnt * sizeof (struct iovec);
ktriov = malloc(iovlen, M_TEMP, M_WAITOK);
bcopy(auio.uio_iov, ktriov, iovlen);
}
#endif
len = auio.uio_resid;
error = sosend(fp->f_data, to, &auio, NULL, control, flags);
if (error) {
if (auio.uio_resid != len && (error == ERESTART ||
error == EINTR || error == EWOULDBLOCK))
error = 0;
if (error == EPIPE && (flags & MSG_NOSIGNAL) == 0)
ptsignal(p, SIGPIPE, STHREAD);
}
if (error == 0) {
*retsize = len - auio.uio_resid;
fp->f_wxfer++;
fp->f_wbytes += *retsize;
}
#ifdef KTRACE
if (ktriov != NULL) {
if (error == 0)
ktrgenio(p, s, UIO_WRITE, ktriov, *retsize);
free(ktriov, M_TEMP);
}
#endif
bad:
FRELE(fp, p);
if (to)
m_freem(to);
return (error);
}
