static int
ng_ksocket_connect(hook_p hook)
{
node_p node = NG_HOOK_NODE(hook);
const priv_p priv = NG_NODE_PRIVATE(node);
struct socket *const so = priv->so;
/* Add our hook for incoming data and other events */
priv->so->so_upcallarg = (caddr_t)node;
priv->so->so_upcall = ng_ksocket_incoming;
SOCKBUF_LOCK(&priv->so->so_rcv);
priv->so->so_rcv.sb_flags |= SB_UPCALL;
SOCKBUF_UNLOCK(&priv->so->so_rcv);
SOCKBUF_LOCK(&priv->so->so_snd);
priv->so->so_snd.sb_flags |= SB_UPCALL;
SOCKBUF_UNLOCK(&priv->so->so_snd);
SOCK_LOCK(priv->so);
sosetstate(priv->so, SS_NBIO);
SOCK_UNLOCK(priv->so);
/*
* --Original comment--
* On a cloned socket we may have already received one or more
* upcalls which we couldn't handle without a hook. Handle
* those now.
* We cannot call the upcall function directly
* from here, because until this function has returned our
* hook isn't connected.
*
* ---meta comment for -current ---
* XXX This is dubius.
* Upcalls between the time that the hook was
* first created and now (on another processesor) will
* be earlier on the queue than the request to finalise the hook.
* By the time the hook is finalised,
* The queued upcalls will have happenned and the code
* will have discarded them because of a lack of a hook.
* (socket not open).
*
* This is a bad byproduct of the complicated way in which hooks
* are now created (3 daisy chained async events).
*
* Since we are a netgraph operation
* We know that we hold a lock on this node. This forces the
* request we make below to be queued rather than implemented
* immediatly which will cause the upcall function to be called a bit
* later.
* However, as we will run any waiting queued operations immediatly
* after doing this one, if we have not finalised the other end
* of the hook, those queued operations will fail.
*/
if (priv->flags & KSF_CLONED) {
ng_send_fn(node, NULL, &ng_ksocket_incoming2, so, M_WAITOK | M_NULLOK);
}
return (0);
}
/*
* If only one hook, allow read(2) and write(2) to work.
*/
static int
ngs_connect(hook_p hook)
{
node_p node = NG_HOOK_NODE(hook);
struct ngsock *priv = NG_NODE_PRIVATE(node);
if ((priv->datasock) && (priv->datasock->ng_socket)) {
if (NG_NODE_NUMHOOKS(node) == 1)
sosetstate(priv->datasock->ng_socket, SS_ISCONNECTED);
else
soclrstate(priv->datasock->ng_socket, SS_ISCONNECTED);
}
return (0);
}
/*
* Hook disconnection
*
* For this type, removal of the last link destroys the node
* if the NOLINGER flag is set.
*/
static int
ngs_disconnect(hook_p hook)
{
node_p node = NG_HOOK_NODE(hook);
struct ngsock *const priv = NG_NODE_PRIVATE(node);
if ((priv->datasock) && (priv->datasock->ng_socket)) {
if (NG_NODE_NUMHOOKS(node) == 1)
sosetstate(priv->datasock->ng_socket, SS_ISCONNECTED);
else
soclrstate(priv->datasock->ng_socket, SS_ISCONNECTED);
}
if ((priv->flags & NGS_FLAG_NOLINGER) &&
(NG_NODE_NUMHOOKS(node) == 0) && (NG_NODE_IS_VALID(node)))
ng_rmnode_self(node);
return (0);
}
/*
* MPSAFE
*/
int
soo_ioctl(struct file *fp, u_long cmd, caddr_t data,
struct ucred *cred, struct sysmsg *msg)
{
struct socket *so;
int error;
so = (struct socket *)fp->f_data;
switch (cmd) {
case FIOASYNC:
if (*(int *)data) {
sosetstate(so, SS_ASYNC);
atomic_set_int(&so->so_rcv.ssb_flags, SSB_ASYNC);
atomic_set_int(&so->so_snd.ssb_flags, SSB_ASYNC);
} else {
soclrstate(so, SS_ASYNC);
atomic_clear_int(&so->so_rcv.ssb_flags, SSB_ASYNC);
atomic_clear_int(&so->so_snd.ssb_flags, SSB_ASYNC);
}
error = 0;
break;
case FIONREAD:
*(int *)data = so->so_rcv.ssb_cc;
error = 0;
break;
case FIOSETOWN:
error = fsetown(*(int *)data, &so->so_sigio);
break;
case FIOGETOWN:
*(int *)data = fgetown(&so->so_sigio);
error = 0;
break;
case SIOCSPGRP:
error = fsetown(-(*(int *)data), &so->so_sigio);
break;
case SIOCGPGRP:
*(int *)data = -fgetown(&so->so_sigio);
error = 0;
break;
case SIOCATMARK:
*(int *)data = (so->so_state&SS_RCVATMARK) != 0;
error = 0;
break;
default:
/*
* Interface/routing/protocol specific ioctls:
* interface and routing ioctls should have a
* different entry since a socket's unnecessary
*/
if (IOCGROUP(cmd) == 'i') {
error = ifioctl(so, cmd, data, cred);
} else if (IOCGROUP(cmd) == 'r') {
error = rtioctl(cmd, data, cred);
} else {
error = so_pru_control_direct(so, cmd, data, NULL);
}
break;
}
return (error);
}
/*
* Handle the first completed incoming connection, assumed to be already
* on the socket's so_comp queue.
*/
static void
ng_ksocket_finish_accept(priv_p priv)
{
struct socket *const head = priv->so;
struct socket *so;
struct sockaddr *sa = NULL;
struct ng_mesg *resp;
struct ng_ksocket_accept *resp_data;
node_p node;
priv_p priv2;
int len;
int error;
ACCEPT_LOCK();
so = TAILQ_FIRST(&head->so_comp);
if (so == NULL) { /* Should never happen */
ACCEPT_UNLOCK();
return;
}
TAILQ_REMOVE(&head->so_comp, so, so_list);
head->so_qlen--;
so->so_qstate &= ~SQ_COMP;
so->so_head = NULL;
SOCK_LOCK(so);
soref(so);
sosetstate(so, SS_NBIO);
SOCK_UNLOCK(so);
ACCEPT_UNLOCK();
/* XXX KNOTE(&head->so_rcv.sb_sel.si_note, 0); */
soaccept(so, &sa);
len = OFFSETOF(struct ng_ksocket_accept, addr);
if (sa != NULL)
len += sa->sa_len;
NG_MKMESSAGE(resp, NGM_KSOCKET_COOKIE, NGM_KSOCKET_ACCEPT, len,
M_WAITOK | M_NULLOK);
if (resp == NULL) {
soclose(so);
goto out;
}
resp->header.flags |= NGF_RESP;
resp->header.token = priv->response_token;
/* Clone a ksocket node to wrap the new socket */
error = ng_make_node_common(&ng_ksocket_typestruct, &node);
if (error) {
kfree(resp, M_NETGRAPH);
soclose(so);
goto out;
}
if (ng_ksocket_constructor(node) != 0) {
NG_NODE_UNREF(node);
kfree(resp, M_NETGRAPH);
soclose(so);
goto out;
}
priv2 = NG_NODE_PRIVATE(node);
priv2->so = so;
priv2->flags |= KSF_CLONED | KSF_EMBRYONIC;
/*
* Insert the cloned node into a list of embryonic children
* on the parent node. When a hook is created on the cloned
* node it will be removed from this list. When the parent
* is destroyed it will destroy any embryonic children it has.
*/
LIST_INSERT_HEAD(&priv->embryos, priv2, siblings);
so->so_upcallarg = (caddr_t)node;
so->so_upcall = ng_ksocket_incoming;
SOCKBUF_LOCK(&so->so_rcv);
so->so_rcv.sb_flags |= SB_UPCALL;
SOCKBUF_UNLOCK(&so->so_rcv);
SOCKBUF_LOCK(&so->so_snd);
so->so_snd.sb_flags |= SB_UPCALL;
SOCKBUF_UNLOCK(&so->so_snd);
/* Fill in the response data and send it or return it to the caller */
resp_data = (struct ng_ksocket_accept *)resp->data;
resp_data->nodeid = NG_NODE_ID(node);
if (sa != NULL)
bcopy(sa, &resp_data->addr, sa->sa_len);
NG_SEND_MSG_ID(error, node, resp, priv->response_addr, 0);
out:
if (sa != NULL)
kfree(sa, M_SONAME);
}
/*
* Close a socket on last file table reference removal.
* Initiate disconnect if connected.
* Free socket when disconnect complete.
*/
int
soclose(struct socket *so, int fflag)
{
int error = 0;
funsetown(&so->so_sigio);
if (so->so_pcb == NULL)
goto discard;
if (so->so_state & SS_ISCONNECTED) {
if ((so->so_state & SS_ISDISCONNECTING) == 0) {
error = sodisconnect(so);
if (error)
goto drop;
}
if (so->so_options & SO_LINGER) {
if ((so->so_state & SS_ISDISCONNECTING) &&
(fflag & FNONBLOCK))
goto drop;
while (so->so_state & SS_ISCONNECTED) {
error = tsleep(&so->so_timeo, PCATCH,
"soclos", so->so_linger * hz);
if (error)
break;
}
}
}
drop:
if (so->so_pcb) {
int error2;
error2 = so_pru_detach(so);
if (error == 0)
error = error2;
}
discard:
lwkt_getpooltoken(so);
if (so->so_options & SO_ACCEPTCONN) {
struct socket *sp;
while ((sp = TAILQ_FIRST(&so->so_incomp)) != NULL) {
TAILQ_REMOVE(&so->so_incomp, sp, so_list);
soclrstate(sp, SS_INCOMP);
sp->so_head = NULL;
so->so_incqlen--;
soaborta(sp);
}
while ((sp = TAILQ_FIRST(&so->so_comp)) != NULL) {
TAILQ_REMOVE(&so->so_comp, sp, so_list);
soclrstate(sp, SS_COMP);
sp->so_head = NULL;
so->so_qlen--;
soaborta(sp);
}
}
lwkt_relpooltoken(so);
if (so->so_state & SS_NOFDREF)
panic("soclose: NOFDREF");
sosetstate(so, SS_NOFDREF); /* take ref */
sofree(so); /* dispose of ref */
return (error);
}
int
socreate(int dom, struct socket **aso, int type,
int proto, struct thread *td)
{
struct proc *p = td->td_proc;
struct protosw *prp;
struct socket *so;
struct pru_attach_info ai;
int error;
if (proto)
prp = pffindproto(dom, proto, type);
else
prp = pffindtype(dom, type);
if (prp == 0 || prp->pr_usrreqs->pru_attach == 0)
return (EPROTONOSUPPORT);
if (p->p_ucred->cr_prison && jail_socket_unixiproute_only &&
prp->pr_domain->dom_family != PF_LOCAL &&
prp->pr_domain->dom_family != PF_INET &&
prp->pr_domain->dom_family != PF_INET6 &&
prp->pr_domain->dom_family != PF_ROUTE) {
return (EPROTONOSUPPORT);
}
if (prp->pr_type != type)
return (EPROTOTYPE);
so = soalloc(p != 0);
if (so == NULL)
return (ENOBUFS);
/*
* Callers of socreate() presumably will connect up a descriptor
* and call soclose() if they cannot. This represents our so_refs
* (which should be 1) from soalloc().
*/
soclrstate(so, SS_NOFDREF);
/*
* Set a default port for protocol processing. No action will occur
* on the socket on this port until an inpcb is attached to it and
* is able to match incoming packets, or until the socket becomes
* available to userland.
*
* We normally default the socket to the protocol thread on cpu 0.
* If PR_SYNC_PORT is set (unix domain sockets) there is no protocol
* thread and all pr_*()/pru_*() calls are executed synchronously.
*/
if (prp->pr_flags & PR_SYNC_PORT)
so->so_port = &netisr_sync_port;
else
so->so_port = cpu_portfn(0);
TAILQ_INIT(&so->so_incomp);
TAILQ_INIT(&so->so_comp);
so->so_type = type;
so->so_cred = crhold(p->p_ucred);
so->so_proto = prp;
ai.sb_rlimit = &p->p_rlimit[RLIMIT_SBSIZE];
ai.p_ucred = p->p_ucred;
ai.fd_rdir = p->p_fd->fd_rdir;
/*
* Auto-sizing of socket buffers is managed by the protocols and
* the appropriate flags must be set in the pru_attach function.
*/
error = so_pru_attach(so, proto, &ai);
if (error) {
sosetstate(so, SS_NOFDREF);
sofree(so); /* from soalloc */
return error;
}
/*
* NOTE: Returns referenced socket.
*/
*aso = so;
return (0);
}
