8000 minix/minix/net/uds/uds.c at master · ze-gois/minix · GitHub
[go: up one dir, main page]

Skip to content

Latest commit

 

History

History
1417 lines (1163 loc) · 36.7 KB

uds.c

File metadata and controls

1417 lines (1163 loc) · 36.7 KB
/* UNIX Domain Sockets - uds.c - socket management */
#include "uds.h"
static struct udssock uds_array[NR_UDSSOCK];
static TAILQ_HEAD(uds_freelist, udssock) uds_freelist;
static unsigned int uds_in_use;
static int uds_running;
static const struct sockevent_ops uds_ops;
static SLIST_HEAD(udshash, udssock) udshash[UDSHASH_SLOTS];
/*
* Initialize file-to-socket hash table.
*/
static void
udshash_init(void)
{
unsigned int slot;
for (slot = 0; slot < __arraycount(udshash); slot++)
SLIST_INIT(&udshash[slot]);
}
/*
* Return a hash table slot number for the given <dev,ino> pair.
*/
static unsigned int
udshash_slot(dev_t dev, ino_t ino)
{
assert(dev != NO_DEV);
assert(ino != 0);
/*
* Effectively combining two 64-bit numbers into a single 6-or-so-bit
* hash is not too easy. This hash function is probably among the
* worst options. Then again it is not all that critical as we are not
* expecting that many bound UDS sockets in the system anyway.
*/
return (unsigned int)(dev ^ ino) % UDSHASH_SLOTS;
}
/*
* Look for a socket that is bound to the given <dev,ino> pair. Return a
* pointer to the socket if found, or NULL otherwise.
*/
static struct udssock *
udshash_get(dev_t dev, ino_t ino)
{
struct udssock *uds;
unsigned int slot;
slot = udshash_slot(dev, ino);
SLIST_FOREACH(uds, &udshash[slot], uds_hash) {
if (uds->uds_dev == dev && uds->uds_ino == ino)
return uds;
}
return NULL;
}
/*
* Add a socket to the file-to-socket hash table. The socket must have its
* device and inode fields set, and must not be in the hash table already.
*/
static void
udshash_add(struct udssock * uds)
{
unsigned int slot;
slot = udshash_slot(uds->uds_dev, uds->uds_ino);
SLIST_INSERT_HEAD(&udshash[slot], uds, uds_hash);
}
/*
* Remove a socket from the file-to-socket hash table. The socket must be in
* the hash table.
*/
static void
udshash_del(struct udssock * uds)
{
unsigned int slot;
slot = udshash_slot(uds->uds_dev, uds->uds_ino);
/* This macro is O(n). */
SLIST_REMOVE(&udshash[slot], uds, udssock, uds_hash);
}
/*
* Return the socket identifier for the given UDS socket object.
*/
sockid_t
uds_get_id(struct udssock * uds)
{
return (sockid_t)(uds - uds_array);
}
/*
* Given either NULL or a previously returned socket, return the next in-use
* UDS socket of the given socket type, or NULL if there are no more matches.
* The sockets are returned in random order, but each matching socket is
* returned exactly once (until any socket is allocated or freed).
*/
struct udssock *
uds_enum(struct udssock * prev, int type)
{
sockid_t id;
if (prev != NULL)
id = uds_get_id(prev) + 1;
else
id = 0;
for (; id < NR_UDSSOCK; id++)
if ((uds_array[id].uds_flags & UDSF_IN_USE) &&
uds_get_type(&uds_array[id]) == type)
return &uds_array[id];
return NULL;
}
/*
* Invalidate credentials on the socket.
*/
static void
uds_clear_cred(struct udssock * uds)
{
uds->uds_cred.unp_pid = -1;
uds->uds_cred.unp_euid = -1;
uds->uds_cred.unp_egid = -1;
}
/*
* Obtain the credentials (process, user, and group ID) of the given user
* endpoint and associate them with the socket for later retrieval. It is
* important to note that this information is obtained once at connect time,
* and never updated later. The party receiving the credentials must take this
* into account.
*/
static void
uds_get_cred(struct udssock * uds, endpoint_t user_endpt)
{
int r;
if ((uds->uds_cred.unp_pid = r = getepinfo(user_endpt,
&uds->uds_cred.unp_euid, &uds->uds_cred.unp_egid)) < 0) {
printf("UDS: failed obtaining credentials of %d (%d)\n",
user_endpt, r);
uds_clear_cred(uds);
}
}
/*
* Allocate and initialize a UDS socket. On succes, return OK with a pointer
* to the new socket in 'udsp'. On failure, return a negative error code.
*/
static int
uds_alloc(struct udssock ** udsp)
{
struct udssock *uds;
int r;
/* Allocate, initialize, and return a UNIX domain socket object. */
if (TAILQ_EMPTY(&uds_freelist))
return ENOBUFS;
uds = TAILQ_FIRST(&uds_freelist);
uds->uds_conn = NULL; /* not connected */
uds->uds_link = NULL; /* not connecting or linked */
uds->uds_queued = 0;
uds->uds_flags = UDSF_IN_USE; /* may be found through enumeration */
uds->uds_pathlen = 0; /* not bound: no path */
uds->uds_dev = NO_DEV; /* not hashed: no socket file device */
uds->uds_ino = 0; /* not hashed: no socket file inode */
uds_clear_cred(uds); /* no bind/connect-time credentials */
TAILQ_INIT(&uds->uds_queue); /* an empty queue */
if ((r = uds_io_setup(uds)) != OK)
return r;
TAILQ_REMOVE(&uds_freelist, uds, uds_next);
assert(uds_in_use < NR_UDSSOCK);
uds_in_use++;
*udsp = uds;
return OK;
}
/*
* Free a previously allocated socket.
*/
static void
uds_free(struct sock * sock)
{
struct udssock *uds = (struct udssock *)sock;
uds_io_cleanup(uds);
uds->uds_flags = 0; /* no longer in use */
TAILQ_INSERT_HEAD(&uds_freelist, uds, uds_next);
assert(uds_in_use > 0);
if (--uds_in_use == 0 && uds_running == FALSE)
sef_cancel();
}
/*
* Create a new socket.
*/
static sockid_t
uds_socket(int domain, int type, int protocol, endpoint_t user_endpt __unused,
struct sock ** sockp, const struct sockevent_ops ** ops)
{
struct udssock *uds;
int r;
dprintf(("UDS: socket(%d,%d,%d)\n", domain, type, protocol));
if (domain != PF_UNIX) {
/* This means the service was configured incorrectly. */
printf("UDS: got request for domain %d\n", domain);
return EAFNOSUPPORT;
}
/* We support the following three socket types. */
switch (type) {
case SOCK_STREAM:
case SOCK_SEQPACKET:
case SOCK_DGRAM:
break;
default:
return EPROTOTYPE;
}
/*
* The PF_UNIX domain does not support particular protocols, so the
* given protocol must be zero (= anything that matches).
*/
if (protocol != UDSPROTO_UDS)
return EPROTONOSUPPORT;
if ((r = uds_alloc(&uds)) != OK)
return r;
dprintf(("UDS: socket returns %d\n", uds_get_id(uds)));
*sockp = &uds->uds_sock;
*ops = &uds_ops;
return uds_get_id(uds);
}
/*
* Connect a pair of sockets.
*/
static int
uds_pair(struct sock * sock1, struct sock * sock2, endpoint_t user_endpt)
{
struct udssock *uds1 = (struct udssock *)sock1;
struct udssock *uds2 = (struct udssock *)sock2;
dprintf(("UDS: pair(%d,%d)\n", uds_get_id(uds1), uds_get_id(uds2)));
/* Only connection-oriented types are acceptable. */
if (uds_get_type(uds1) == SOCK_DGRAM)
return EOPNOTSUPP;
/* Connect the sockets. */
uds1->uds_conn = uds2;
uds2->uds_conn = uds1;
uds1->uds_flags |= UDSF_CONNECTED;
uds2->uds_flags |= UDSF_CONNECTED;
/* Obtain the (same) credentials for both sides of the connection. */
uds_get_cred(uds1, user_endpt);
memcpy(&uds2->uds_cred, &uds1->uds_cred, sizeof(uds2->uds_cred));
return OK;
}
/*
* Disconnect a UDS socket, notifying or freeing up the other end of the
* connection depending on whether the socket was linked, that is, on the
* accept queue of a listening socket.
*/
static void
uds_disconnect(struct udssock * uds, int was_linked)
{
struct udssock *conn;
assert(uds_is_connected(uds));
assert(uds_has_conn(uds));
conn = uds->uds_conn;
assert(uds_is_connected(conn));
assert(uds_has_conn(conn));
assert(!uds_has_link(conn));
assert(conn->uds_conn == uds);
/* Disconnect the sockets. */
uds->uds_conn = NULL;
conn->uds_conn = NULL;
/*
* If the given socket is linked, then it is a connected socket for
* which the other end has been created but not yet accepted. In that
* case, the other end ('conn') will have to be freed up. Otherwise,
* it is a regular user-created socket and we must properly transition
* it into disconnected state.
*/
if (!was_linked) {
sockevent_raise(&conn->uds_sock, SEV_SEND | SEV_RECV);
/*
* Clear the peer credentials so that they will not be mistaken
* for having been obtained at bind time.
*/
uds_clear_cred(conn);
} else
sockevent_raise(&conn->uds_sock, SEV_CLOSE);
}
/*
* Add the socket 'link' to the queue of the socket 'uds'. This also implies
* that 'link's link socket is set to 'uds'.
*/
static void
uds_add_queue(struct udssock * uds, struct udssock * link)
{
dprintf(("UDS: add_queue(%d,%d)\n",
uds_get_id(uds), uds_get_id(link)));
TAILQ_INSERT_TAIL(&uds->uds_queue, link, uds_next);
uds->uds_queued++;
assert(uds->uds_queued != 0);
link->uds_link = uds;
}
/*
* Remove the socket 'link' from the queue of the socket 'uds'. This also
* reset 'link's link to NULL.
*/
static void
uds_del_queue(struct udssock * uds, struct udssock * link)
{
dprintf(("UDS: del_queue(%d,%d)\n",
uds_get_id(uds), uds_get_id(link)));
assert(link->uds_link == uds);
TAILQ_REMOVE(&uds->uds_queue, link, uds_next);
assert(uds->uds_queued > 0);
uds->uds_queued--;
link->uds_link = NULL;
}
/*
* Remove all sockets from the queue of the socket 'uds', with the exception of
* 'except' if non-NULL. Raise an ECONNRESET error on all removed sockets that
* are not equal to 'uds'.
*/
static void
uds_clear_queue(struct udssock * uds, struct udssock * except)
{
struct udssock *link, *tmp;
int found;
dprintf(("UDS: clear_queue(%d,%d)\n",
uds_get_id(uds), (except != NULL) ? uds_get_id(except) : -1));
found = 0;
/*
* Abort all connecting sockets queued on this socket, except for the
* given exception, which may be NULL.
*/
TAILQ_FOREACH_SAFE(link, &uds->uds_queue, uds_next, tmp) {
if (link == except) {
found++;
continue;
}
dprintf(("UDS: clear_queue removes %d\n", uds_get_id(link)));
assert(uds_get_type(link) == SOCK_DGRAM ||
uds_is_connecting(link) || uds_is_connected(link));
uds_del_queue(uds, link);
/*
* Generate an error only if the socket was not linked to
* itself (only datagram sockets can be linked to themselves).
* The error is not helpful for applications in that case.
*/
if (uds != link)
sockevent_set_error(&link->uds_sock, ECONNRESET);
/*
* If this is a listening socket, disconnect the connecting or
* connected end. If a connected peer was already created for
* the queued socket, dispose of that peer.
*
* Clear credentials obtained when starting to connect (in
* which case the socket is always a connection-oriented
* socket), so that they will not be mistaken for credentials
* obtained at bind time.
*/
if (uds_get_type(link) != SOCK_DGRAM) {
if (uds_is_connected(link))
uds_disconnect(link, TRUE /*was_linked*/);
else
uds_clear_cred(link);
}
}
assert(uds->uds_queued == found);
}
/*
* Check whether the socket address given in 'addr', with length 'addr_len', is
* a valid UNIX domain socket address (including a path to a socket file). On
* success, return the (non-zero) length of the socket file's path, minus the
* null terminator which may in fact not be present. The caller is responsible
* for copying and terminating the path as needed. A pointer to the path as
* stored in 'addr' is returned in 'pathp'. On failure, return an error code.
*/
static int
uds_check_addr(const struct sockaddr * addr, socklen_t addr_len,
const char ** pathp)
{
const char *p;
size_t len;
/*
* We could cast to a sockaddr_un structure pointer first, but that
* would not provide any benefits here. Instead, we use sa_data as the
* generic equivalent of sun_path.
*/
if (addr_len < offsetof(struct sockaddr, sa_data))
return EINVAL;
if (addr->sa_family != AF_UNIX)
return EAFNOSUPPORT;
len = (size_t)addr_len - offsetof(struct sockaddr, sa_data);
if (len > 0 && (p = memchr(addr->sa_data, '\0', len)) != NULL)
len = (size_t)(p - addr->sa_data);
/* The given path name must not be an empty string. */
if (len == 0)
return ENOENT;
/* This check should be redundant but better safe than sorry. */
if (len >= UDS_PATH_MAX)
return EINVAL;
*pathp = (const char *)addr->sa_data;
return len;
}
/*
* Given the socket file path given as 'path' with length 'path_len' (not
* necessarily null terminated), store a socket address with the path in
* 'addr', and return the socket address length in 'addr_len'. The calling
* libraries (libsockdriver, libsockevent) and the static assert in uds.h
* guarantee that 'addr' is sufficiently large to store any address we generate
* here. The libraries may subsequently copy out only a part of it to the user
* process. This function always succeeds.
*/
void
uds_make_addr(const char * path, size_t len, struct sockaddr * addr,
socklen_t * addr_len)
{
/*
* Generate the address. The stored length (sa_len/sun_len) does not
* include a null terminator. The entire structure does include a null
* terminator, but only if the socket is bound.
*/
addr->sa_len = offsetof(struct sockaddr, sa_data) + len;
addr->sa_family = AF_UNIX;
if (len > 0) {
/* This call may (intentionally) overrun the sa_data size. */
memcpy((char *)addr->sa_data, path, len);
((char *)addr->sa_data)[len] = '\0';
/* The socket is bound, so include the null terminator. */
len++;
assert(len <= UDS_PATH_MAX);
}
/* Note that this length may be different from sa_len/sun_len now. */
*addr_len = offsetof(struct sockaddr, sa_data) + len;
}
/*
* Bind a socket to a local address.
*/
static int
uds_bind(struct sock * sock, const struct sockaddr * addr, socklen_t addr_len,
endpoint_t user_endpt)
{
struct udssock *uds = (struct udssock *)sock;
struct udssock *uds2;
const char *path;
size_t len;
dev_t dev;
ino_t ino;
int r;
dprintf(("UDS: bind(%d)\n", uds_get_id(uds)));
/* A socket may be bound at any time, but only once. */
if (uds_is_bound(uds))
return EINVAL;
/* Verify that the user gave us an acceptable address. */
if ((r = uds_check_addr(addr, addr_len, &path)) < 0)
return r;
len = (size_t)r;
/* Attempt to create the socket file on the file system. */
r = socketpath(user_endpt, path, len, SPATH_CREATE, &dev, &ino);
if (r != OK)
return r;
assert(dev != NO_DEV && ino != 0);
/*
* It is possible that a socket file of a previously bound socket was
* unlinked, and due to inode number reuse, a new socket file has now
* been created with the same <dev,ino> pair. In that case, we must
* unbind the old socket, because it must no longer be found. The old
* socket will still have a path (and behave as though it is bound) but
* no longer be found through hash lookups.
*/
if ((uds2 = udshash_get(dev, ino)) != NULL) {
udshash_del(uds2);
uds2->uds_dev = NO_DEV;
uds2->uds_ino = 0;
}
/*
* Obtain credentials for the socket, unless the socket is already
* connecting or connected, in which case we must not replace the
* credentials we obtained already. We later clear those credentials
* upon a connection failure or disconnect, so that if the socket is
* then put in listening mode, we know there are no bind-time
* credentials. Not ideal, but we really need two separate sets of
* credentials if we want to get this right, which is a waste of memory
* as no sane application writer would ever rely on credential passing
* after recycling a socket..
*/
if (uds_get_type(uds) != SOCK_DGRAM && !uds_is_connecting(uds) &&
!uds_is_connected(uds))
uds_get_cred(uds, user_endpt);
/* Asssign the address to the socket. */
uds->uds_pathlen = len;
memcpy(&uds->uds_path, path, len);
uds->uds_dev = dev;
uds->uds_ino = ino;
udshash_add(uds);
return OK;
}
/*
* Look up a UDS socket based on a user-given address. If a socket exists for
* the address, check if it is type-compatible with the given UDS socket.
* On succes, return OK, with 'peerp' set to the socket that was found. On
* failure, return a negative error code.
*/
int
uds_lookup(struct udssock * uds, const struct sockaddr * addr,
socklen_t addr_len, endpoint_t user_endpt, struct udssock ** peerp)
{
struct udssock *peer;
const char *path;
size_t len;
dev_t dev;
ino_t ino;
int r;
/* Verify that the user gave us an acceptable address. */
if ((r = uds_check_addr(addr, addr_len, &path)) < 0)
return r;
len = (size_t)r;
/* Attempt to look up the socket file on the file system. */
r = socketpath(user_endpt, path, len, SPATH_CHECK, &dev, &ino);
if (r != OK)
return r;
assert(dev != NO_DEV && ino != 0);
if ((peer = udshash_get(dev, ino)) == NULL)
return ECONNREFUSED;
if (uds_get_type(peer) != uds_get_type(uds))
return EPROTOTYPE;
*peerp = peer;
return OK;
}
/*
* Given the listening socket 'uds', and the socket 'link' that is calling or
* has called connect(2) and is or will be linked to the listening socket's
* queue, create a new socket and connect it to 'link', putting both sockets in
* the connected state. The given link socket may be in unconnected,
* connecting, or disconnected state prior to the call. Return OK or an error
* code. The link state of the link socket remains unchanged in any case.
*/
static int
uds_attach(struct udssock * uds, struct udssock * link)
{
struct udssock *conn;
int r;
/*
* Allocate a new socket to use as peer socket for the connection that
* is about to be established. The new socket is not yet known by
* libsockevent.
*/
if ((r = uds_alloc(&conn)) != OK)
return r;
/*
* Ask libsockevent to clone the sock object in the new UDS socket from
* the listening socket. This adds the sock object to libsockevent's
* data structures and ensures that we can safely use the socket
* despite the fact that it has not yet been accepted (and thus
* returned to libsockevent). From this moment on, we must either
* return the socket's ID (but not a pointer to it!) from uds_accept()
* or raise SEV_CLOSE on it.
*/
sockevent_clone(&uds->uds_sock, &conn->uds_sock, uds_get_id(conn));
/* Connect the link socket to the new socket. */
link->uds_conn = conn;
link->uds_flags |= UDSF_CONNECTED;
/*
* Connect the new socket to the link socket as well. The child
* socket should also inherit pretty much all settings from the
* listening socket, including the bind path and the listening socket's
* bind-time credentials.
*/
conn->uds_conn = link;
conn->uds_flags = uds->uds_flags & (UDSF_PASSCRED | UDSF_CONNWAIT);
conn->uds_flags |= UDSF_CONNECTED;
conn->uds_pathlen = uds->uds_pathlen;
memcpy(conn->uds_path, uds->uds_path, (size_t)uds->uds_pathlen);
memcpy(&conn->uds_cred, &uds->uds_cred, sizeof(conn->uds_cred));
return OK;
}
/*
* Connect a socket to a remote address.
*/
static int
uds_connect(struct sock * sock, const struct sockaddr * addr,
socklen_t addr_len, endpoint_t user_endpt)
{
struct udssock *uds = (struct udssock *)sock;
struct udssock *link;
int r;
dprintf(("UDS: connect(%d)\n", uds_get_id(uds)));
/* For connection-oriented sockets, several state checks apply. */
if (uds_get_type(uds) != SOCK_DGRAM) {
if (uds_is_listening(uds))
return EOPNOTSUPP;
if (uds_is_connecting(uds))
return EALREADY;
if (uds_is_connected(uds))
return EISCONN;
/* Disconnected sockets may be reconnected, see below. */
} else {
/*
* Connectionless sockets may be unconnected by providing an
* address with family AF_UNSPEC. Handle this case first here.
*/
if (addr_len >= offsetof(struct sockaddr, sa_data) &&
addr->sa_family == AF_UNSPEC) {
/*
* Reset this socket's previous connection to another
* socket, if any. Unconnecting has no effect on other
* sockets connected to this socket, though.
*/
if (uds_has_link(uds))
uds_del_queue(uds->uds_link, uds);
return OK;
}
}
/*
* Find the socket identified by the given address. If it exists at
* all, see if it is a proper match.
*/
if ((r = uds_lookup(uds, addr, addr_len, user_endpt, &link)) != OK)
return r;
/*
* Handle connectionless sockets first, in which case a connect links
* the socket to a send target and limits receipt to datagrams from
* that target. We actually point the socket to the peer socket,
* through uds_link. That also means that if the target socket
* disappears, we have to reset any sockets connected to it, in which
* case we return them to the unconnected state. In order to allow
* finding all sockets connected to a particular socket, we put all
* those sockets on their target's queue, hence why we use uds_link and
* not uds_conn. As mentioned before, we allow reconnecting without
* restrictions.
* TODO: see if reconnecting should clear a pending ECONNRESET.
*
* An important note: 'uds' and 'link' may actually be the same socket,
* if the caller chooses to connect a socket with itself!
*/
if (uds_get_type(uds) == SOCK_DGRAM) {
/* Reconnecting to the same socket has no effect. */
if (uds_has_link(uds) && uds->uds_link == link)
return OK;
/*
* If the intended target is linked to another socket, we
* refuse linking to it. Sending or receiving would never work
* anyway. Do allow a socket to link to itself after being
* linked to another socket. The error code is the same as in
* the sending code, borrowed from Linux.
*/
if (uds != link && uds_has_link(link) && link->uds_link != uds)
return EPERM;
/*
* Reset this socket's previous link to another socket, if any.
*/
if (uds_has_link(uds))
uds_del_queue(uds->uds_link, uds);
/*
* Reset any links to this socket, except for the one by
* the intended target. Sending or receiving would no longer
* work anyway. If the socket was linked to itself, clear its
* self-link without generating an ECONNRESET. If the socket
* is relinking to itself, reestablish the link after first
* clearing it.
*/
uds_clear_queue(uds, (uds != link) ? link : NULL);
uds_add_queue(link, uds);
return OK;
}
/*
* For connection-oriented sockets there is more to do. First, make
* sure that the peer is a listening socket, that it has not been shut
* down, and that its backlog is not already at the configured maximum.
*/
if (!uds_is_listening(link))
return ECONNREFUSED;
if (uds_is_shutdown(link, SFL_SHUT_RD | SFL_SHUT_WR))
return ECONNREFUSED;
if (link->uds_queued >= link->uds_backlog)
return ECONNREFUSED;
/*
* The behavior of connect(2) now depends on whether LOCAL_CONNWAIT is
* set on either the connecting or the listening socket. If it is not,
* the socket will be connected to a new as-yet invisible socket, which
* will be the one returned from accept(2) later. If it was, the
* socket will be put in the connecting state.
*/
if (!((uds->uds_flags | link->uds_flags) & UDSF_CONNWAIT)) {
if ((r = uds_attach(link, uds)) != OK)
return r;
assert(uds_is_connected(uds));
} else {
/*
* Disconnected sockets now stop being connected. Any pending
* data can still be received, though.
*/
uds->uds_flags &= ~UDSF_CONNECTED;
r = SUSPEND;
}
/* Obtain credentials for the socket. */
uds_get_cred(uds, user_endpt);
/* Add the socket at the end of the listening socket's queue. */
uds_add_queue(link, uds);
assert(r != SUSPEND || uds_is_connecting(uds));
/*
* Let an accept call handle the rest, which will in turn resume this
* connect call. The sockevent library ensures that this works even if
* the call is non-blocking.
*/
sockevent_raise(&link->uds_sock, SEV_ACCEPT);
return r;
}
/*
* Put a socket in listening mode.
*/
static int
uds_listen(struct sock * sock, int backlog)
{
struct udssock *uds = (struct udssock *)sock;
/* The maximum backlog value must not exceed its field size. */
assert(SOMAXCONN <= USHRT_MAX);
dprintf(("UDS: listen(%d)\n", uds_get_id(uds)));
/* Only connection-oriented types may be put in listening mode. */
if (uds_get_type(uds) == SOCK_DGRAM)
return EOPNOTSUPP;
/* A connecting or connected socket may not listen. */
if (uds_is_connecting(uds) || uds_is_connected(uds))
return EINVAL;
/* POSIX says that this is now the appropriate error code here. */
if (!uds_is_bound(uds))
return EDESTADDRREQ;
/*
* The socket is now entering the listening state. If it was
* previously disconnected, clear the connection flag.
*/
uds->uds_flags &= ~UDSF_CONNECTED;
/*
* We do not remove sockets from the backlog if it is now being dropped
* below the current number of queued sockets. We only refuse newly
* connecting sockets beyond the backlog size.
*/
uds->uds_backlog = backlog;
return OK;
}
/*
* Test whether an accept request would block. Return OK if a socket could be
* accepted, an appropriate error code if an accept call would fail instantly,
* or SUSPEND if the accept request would block waiting for a connection.
*/
static int
uds_test_accept(struct sock * sock)
{
struct udssock *uds = (struct udssock *)sock;
/*
* Ensure that the socket is in listening mode. If not, we must return
* the error code that is appropriate for this socket type.
*/
if (uds_get_type(uds) == SOCK_DGRAM)
return EOPNOTSUPP;
if (!uds_is_listening(uds))
return EINVAL;
/*
* If the socket has been shut down, new connections are no longer
* accepted and accept calls no longer block. This is not a POSIX
* requirement, but rather an application convenience feature.
*/
if (uds->uds_queued == 0) {
if (uds_is_shutdown(uds, SFL_SHUT_RD | SFL_SHUT_WR))
return ECONNABORTED;
return SUSPEND;
}
return OK;
}
/*
* Accept a connection on a listening socket, creating a new socket. On
* success, return the new socket identifier, with the new socket stored in
* 'newsockp'. Otherwise, return an error code.
*/
static sockid_t
uds_accept(struct sock * sock, struct sockaddr * addr, socklen_t * addr_len,
endpoint_t user_endpt __unused, struct sock ** newsockp)
{
struct udssock *uds = (struct udssock *)sock;
struct udssock *link, *conn;
sockid_t r;
dprintf(("UDS: accept(%d)\n", uds_get_id(uds)));
if ((r = uds_test_accept(sock)) != OK)
return r;
/*
* Take the first connecting socket off the listening queue.
*/
assert(!TAILQ_EMPTY(&uds->uds_queue));
link = TAILQ_FIRST(&uds->uds_queue);
/*
* Depending on the LOCAL_CONNWAIT setting at the time of connect(2),
* the socket may be connecting or connected. In the latter case, its
* attached socket is the socket we will return now. Otherwise we have
* to attach a socket first.
*/
assert(uds_is_connecting(link) || uds_is_connected(link));
if (uds_is_connecting(link)) {
/*
* Attach a new socket. If this fails, return the error but
* leave the connecting socket on the listening queue.
*/
if ((r = uds_attach(uds, link)) != OK)
return r;
assert(uds_is_connected(link));
/*
* Wake up blocked (connect, send, select) calls on the peer
* socket.
*/
sockevent_raise(&link->uds_sock, SEV_CONNECT);
}
uds_del_queue(uds, link);
/* Return the peer socket's address to the caller. */
uds_make_addr(link->uds_path, link->uds_pathlen, addr, addr_len);
conn = link->uds_conn;
dprintf(("UDS: accept returns %d\n", uds_get_id(conn)));
/*
* We already cloned the sock object, so return its ID but not a
* pointer to it. That tells libsockevent not to reinitialize it.
*/
*newsockp = NULL;
return uds_get_id(conn);
}
/*
* Set socket options.
*/
static int
uds_setsockopt(struct sock * sock, int level, int name,
const struct sockdriver_data * data, socklen_t len)
{
struct udssock *uds = (struct udssock *)sock;
int r, val;
dprintf(("UDS: setsockopt(%d,%d,%d)\n", uds_get_id(uds), level, name));
switch (level) {
case SOL_SOCKET:
switch (name) {
case SO_SNDBUF:
case SO_RCVBUF:
/*
* The send buffer size may not be changed because the
* buffer is the same as the other side's receive
* buffer, and what the other side is may vary from
* send call to send call. Changing the receive buffer
* size would disallow us from even accurately guessing
* the send buffer size in getsockopt calls. Therefore
* both are hardcoded and cannot actually be changed.
* In order to support applications that want at least
* a certain minimum, we do accept requests to shrink
0