/*
* Connection expected to be locked
*/
int
ncp_sock_disconnect(struct ncp_conn *conn) {
struct socket *so;
conn->flags &= ~(NCPFL_SOCONN | NCPFL_ATTACHED | NCPFL_LOGGED);
if (conn->ncp_so) {
so = conn->ncp_so;
conn->ncp_so = NULL;
soshutdown(so, SHUT_RDWR);
soclose(so, FNONBLOCK);
}
if (conn->wdg_so) {
so = conn->wdg_so;
conn->wdg_so = NULL;
soshutdown(so, SHUT_RDWR);
soclose(so, FNONBLOCK);
}
#ifdef NCPBURST
if (conn->bc_so) {
so = conn->bc_so;
conn->bc_so = NULL;
soshutdown(so, SHUT_RDWR);
soclose(so, FNONBLOCK);
}
#endif
return 0;
}
/*
* Connection expected to be locked
*/
int
ncp_sock_disconnect(struct ncp_conn *conn) {
register struct socket *so;
conn->flags &= ~(NCPFL_SOCONN | NCPFL_ATTACHED | NCPFL_LOGGED);
if (conn->ncp_so) {
so = conn->ncp_so;
conn->ncp_so = (struct socket *)0;
soshutdown(so, 2);
soclose(so);
}
if (conn->wdg_so) {
so = conn->wdg_so;
conn->wdg_so = (struct socket *)0;
soshutdown(so, 2);
soclose(so);
}
#ifdef NCPBURST
if (conn->bc_so) {
so = conn->bc_so;
conn->bc_so = (struct socket *)NULL;
soshutdown(so, 2);
soclose(so);
}
#endif
return 0;
}
/*
* MPSAFE
*/
int
soo_shutdown(struct file *fp, int how)
{
int error;
if (fp->f_data)
error = soshutdown((struct socket *)fp->f_data, how);
else
error = 0;
return (error);
}
errno_t xi_sock_shutdown(xi_socket_t so, int how)
{
#ifdef __KPI_SOCKET__
return sock_shutdown(so, how);
#else
thread_funnel_set(network_flock, TRUE);
errno_t error;
error = soshutdown(so, how);
(void)thread_funnel_set(network_flock, FALSE);
return error;
#endif
}
void
osi_StopListener(void)
{
struct proc *p;
/*
* Have to drop global lock to safely do this.
* soclose() is currently protected by Giant,
* but pfind and psignal are MPSAFE.
*/
int haveGlock = ISAFS_GLOCK();
if (haveGlock)
AFS_GUNLOCK();
soshutdown(rx_socket, 2);
#ifndef AFS_FBSD70_ENV
soclose(rx_socket);
#endif
p = pfind(rxk_ListenerPid);
afs_warn("osi_StopListener: rxk_ListenerPid %lx\n", p);
if (p)
psignal(p, SIGUSR1);
#ifdef AFS_FBSD50_ENV
PROC_UNLOCK(p);
#endif
#ifdef AFS_FBSD70_ENV
{
/* Avoid destroying socket until osi_NetReceive has
* had a chance to clean up */
int tries;
struct mtx s_mtx;
MUTEX_INIT(&s_mtx, "rx_shutdown_mutex", MUTEX_DEFAULT, 0);
MUTEX_ENTER(&s_mtx);
tries = 3;
while ((tries > 0) && (!so_is_disconn(rx_socket))) {
msleep(&osi_StopListener, &s_mtx, PSOCK | PCATCH,
"rx_shutdown_timedwait", 1 * hz);
--tries;
}
if (so_is_disconn(rx_socket))
soclose(rx_socket);
MUTEX_EXIT(&s_mtx);
MUTEX_DESTROY(&s_mtx);
}
#endif
if (haveGlock)
AFS_GLOCK();
}
/* ARGSUSED */
int
sys_shutdown(struct proc *p, void *v, register_t *retval)
{
struct sys_shutdown_args /* {
syscallarg(int) s;
syscallarg(int) how;
} */ *uap = v;
struct file *fp;
int error;
if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0)
return (error);
error = soshutdown(fp->f_data, SCARG(uap, how));
FRELE(fp, p);
return (error);
}
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;
}
int
shutdown (int s, int how)
{
struct socket *so;
int error;
rtems_bsdnet_semaphore_obtain ();
if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {
rtems_bsdnet_semaphore_release ();
return -1;
}
error = soshutdown(so, how);
rtems_bsdnet_semaphore_release ();
if (error) {
errno = error;
return -1;
}
return 0;
}
int
t_shutdown(long s, int how)
{
struct socket *so;
int err;
so = LONG2SO(s);
SOC_CHECK(so);
so->so_error = 0;
INET_TRACE (INETM_SOCKET, ("INET:shutdown so %x how %d\n", so, how));
LOCK_NET_RESOURCE(NET_RESID);
err = soshutdown(so, how);
UNLOCK_NET_RESOURCE(NET_RESID);
if (err != 0)
{
so->so_error = err;
return SOCKET_ERROR;
}
return 0;
}
/*
* XXX Liang: timeout for write is not supported yet.
*/
int
libcfs_sock_write (struct socket *sock, void *buffer, int nob, int timeout)
{
int rc;
CFS_DECL_NET_DATA;
while (nob > 0) {
struct iovec iov = {
.iov_base = buffer,
.iov_len = nob
};
struct uio suio = {
.uio_iov = &iov,
.uio_iovcnt = 1,
.uio_offset = 0,
.uio_resid = nob,
.uio_segflg = UIO_SYSSPACE,
.uio_rw = UIO_WRITE,
.uio_procp = NULL
};
CFS_NET_IN;
rc = sosend(sock, NULL, &suio, (struct mbuf *)0, (struct mbuf *)0, 0);
CFS_NET_EX;
if (rc != 0) {
if ( suio.uio_resid != nob && ( rc == ERESTART || rc == EINTR ||\
rc == EWOULDBLOCK))
rc = 0;
if ( rc != 0 )
return -rc;
rc = nob - suio.uio_resid;
buffer = ((char *)buffer) + rc;
nob = suio.uio_resid;
continue;
}
break;
}
return (0);
}
/*
* XXX Liang: timeout for read is not supported yet.
*/
int
libcfs_sock_read (struct socket *sock, void *buffer, int nob, int timeout)
{
int rc;
CFS_DECL_NET_DATA;
while (nob > 0) {
struct iovec iov = {
.iov_base = buffer,
.iov_len = nob
};
struct uio ruio = {
.uio_iov = &iov,
.uio_iovcnt = 1,
.uio_offset = 0,
.uio_resid = nob,
.uio_segflg = UIO_SYSSPACE,
.uio_rw = UIO_READ,
.uio_procp = NULL
};
CFS_NET_IN;
rc = soreceive(sock, (struct sockaddr **)0, &ruio, (struct mbuf **)0, (struct mbuf **)0, (int *)0);
CFS_NET_EX;
if (rc != 0) {
if ( ruio.uio_resid != nob && ( rc == ERESTART || rc == EINTR ||\
rc == EWOULDBLOCK))
rc = 0;
if (rc != 0)
return -rc;
rc = nob - ruio.uio_resid;
buffer = ((char *)buffer) + rc;
nob = ruio.uio_resid;
continue;
}
break;
}
return (0);
}
int
libcfs_sock_setbuf (struct socket *sock, int txbufsize, int rxbufsize)
{
struct sockopt sopt;
int rc = 0;
int option;
CFS_DECL_NET_DATA;
bzero(&sopt, sizeof sopt);
sopt.sopt_dir = SOPT_SET;
sopt.sopt_level = SOL_SOCKET;
sopt.sopt_val = &option;
sopt.sopt_valsize = sizeof(option);
if (txbufsize != 0) {
option = txbufsize;
if (option > KSOCK_MAX_BUF)
option = KSOCK_MAX_BUF;
sopt.sopt_name = SO_SNDBUF;
CFS_NET_IN;
rc = sosetopt(sock, &sopt);
CFS_NET_EX;
if (rc != 0) {
CERROR ("Can't set send buffer %d: %d\n",
option, rc);
return -rc;
}
}
if (rxbufsize != 0) {
option = rxbufsize;
sopt.sopt_name = SO_RCVBUF;
CFS_NET_IN;
rc = sosetopt(sock, &sopt);
CFS_NET_EX;
if (rc != 0) {
CERROR ("Can't set receive buffer %d: %d\n",
option, rc);
return -rc;
}
}
return 0;
}
int
libcfs_sock_getaddr (struct socket *sock, int remote, __u32 *ip, int *port)
{
struct sockaddr_in *sin;
struct sockaddr *sa = NULL;
int rc;
CFS_DECL_NET_DATA;
if (remote != 0) {
CFS_NET_IN;
rc = sock->so_proto->pr_usrreqs->pru_peeraddr(sock, &sa);
CFS_NET_EX;
if (rc != 0) {
if (sa) FREE(sa, M_SONAME);
CERROR ("Error %d getting sock peer IP\n", rc);
return -rc;
}
} else {
CFS_NET_IN;
rc = sock->so_proto->pr_usrreqs->pru_sockaddr(sock, &sa);
CFS_NET_EX;
if (rc != 0) {
if (sa) FREE(sa, M_SONAME);
CERROR ("Error %d getting sock local IP\n", rc);
return -rc;
}
}
if (sa != NULL) {
sin = (struct sockaddr_in *)sa;
if (ip != NULL)
*ip = ntohl (sin->sin_addr.s_addr);
if (port != NULL)
*port = ntohs (sin->sin_port);
if (sa)
FREE(sa, M_SONAME);
}
return 0;
}
int
libcfs_sock_getbuf (struct socket *sock, int *txbufsize, int *rxbufsize)
{
struct sockopt sopt;
int rc;
CFS_DECL_NET_DATA;
bzero(&sopt, sizeof sopt);
sopt.sopt_dir = SOPT_GET;
sopt.sopt_level = SOL_SOCKET;
if (txbufsize != NULL) {
sopt.sopt_val = txbufsize;
sopt.sopt_valsize = sizeof(*txbufsize);
sopt.sopt_name = SO_SNDBUF;
CFS_NET_IN;
rc = sogetopt(sock, &sopt);
CFS_NET_EX;
if (rc != 0) {
CERROR ("Can't get send buffer size: %d\n", rc);
return -rc;
}
}
if (rxbufsize != NULL) {
sopt.sopt_val = rxbufsize;
sopt.sopt_valsize = sizeof(*rxbufsize);
sopt.sopt_name = SO_RCVBUF;
CFS_NET_IN;
rc = sogetopt(sock, &sopt);
CFS_NET_EX;
if (rc != 0) {
CERROR ("Can't get receive buffer size: %d\n", rc);
return -rc;
}
}
return 0;
}
int
libcfs_sock_connect (struct socket **sockp, int *fatal,
__u32 local_ip, int local_port,
__u32 peer_ip, int peer_port)
{
struct sockaddr_in srvaddr;
struct socket *so;
int s;
int rc;
CFS_DECL_FUNNEL_DATA;
rc = libcfs_sock_create(sockp, fatal, local_ip, local_port);
if (rc != 0)
return rc;
so = *sockp;
bzero(&srvaddr, sizeof(srvaddr));
srvaddr.sin_len = sizeof(struct sockaddr_in);
srvaddr.sin_family = AF_INET;
srvaddr.sin_port = htons (peer_port);
srvaddr.sin_addr.s_addr = htonl (peer_ip);
CFS_NET_IN;
rc = soconnect(so, (struct sockaddr *)&srvaddr);
if (rc != 0) {
CFS_NET_EX;
if (rc != EADDRNOTAVAIL && rc != EADDRINUSE)
CDEBUG(D_NETERROR,
"Error %d connecting %u.%u.%u.%u/%d -> %u.%u.%u.%u/%d\n", rc,
HIPQUAD(local_ip), local_port, HIPQUAD(peer_ip), peer_port);
goto out;
}
s = splnet();
while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
CDEBUG(D_NET, "ksocknal sleep for waiting auto_connect.\n");
(void) tsleep((caddr_t)&so->so_timeo, PSOCK, "ksocknal_conn", hz);
}
if ((rc = so->so_error) != 0) {
so->so_error = 0;
splx(s);
CFS_NET_EX;
CDEBUG(D_NETERROR,
"Error %d connecting %u.%u.%u.%u/%d -> %u.%u.%u.%u/%d\n", rc,
HIPQUAD(local_ip), local_port, HIPQUAD(peer_ip), peer_port);
goto out;
}
LASSERT(so->so_state & SS_ISCONNECTED);
splx(s);
CFS_NET_EX;
if (sockp)
*sockp = so;
return (0);
out:
CFS_NET_IN;
soshutdown(so, 2);
soclose(so);
CFS_NET_EX;
return (-rc);
}
void
libcfs_sock_release (struct socket *sock)
{
CFS_DECL_FUNNEL_DATA;
CFS_NET_IN;
soshutdown(sock, 0);
CFS_NET_EX;
}
static int
bsd_shutdown(cyg_file *fp, int how)
{
return (soshutdown((struct socket *)fp->f_data, how));
}
