phunix/minix/net/uds/uds.c

/*
 * Unix Domain Sockets Implementation (PF_UNIX, PF_LOCAL)
 * This code handles requests generated by operations on /dev/uds
 *
 * The interface to UNIX domain sockets is similar to the interface to network
 * sockets. There is a character device (/dev/uds) and this server is a
 * 'driver' for that device.
 */

#include "uds.h"

static ssize_t uds_perform_write(devminor_t, endpoint_t, cp_grant_id_t, size_t,
	int);

static int uds_open(devminor_t, int, endpoint_t);
static int uds_close(devminor_t);
static ssize_t uds_read(devminor_t, u64_t, endpoint_t, cp_grant_id_t, size_t,
	int, cdev_id_t);
static ssize_t uds_write(devminor_t, u64_t, endpoint_t, cp_grant_id_t, size_t,
	int, cdev_id_t);
static int uds_ioctl(devminor_t, unsigned long, endpoint_t, cp_grant_id_t, int,
	endpoint_t, cdev_id_t);
static int uds_cancel(devminor_t, endpoint_t, cdev_id_t);
static int uds_select(devminor_t, unsigned int, endpoint_t);

static struct chardriver uds_tab = {
	.cdr_open	= uds_open,
	.cdr_close	= uds_close,
	.cdr_read	= uds_read,
	.cdr_write	= uds_write,
	.cdr_ioctl	= uds_ioctl,
	.cdr_cancel	= uds_cancel,
	.cdr_select	= uds_select
};

/* File Descriptor Table */
uds_fd_t uds_fd_table[NR_FDS];

static unsigned int uds_exit_left;

static int
uds_open(devminor_t UNUSED(orig_minor), int access,
	endpoint_t user_endpt)
{
	devminor_t minor;
	char *buf;
	int i;

	dprintf(("UDS: uds_open() from %d\n", user_endpt));

	/*
	 * Find a slot in the descriptor table for the new descriptor.
	 * The index of the descriptor in the table will be returned.
	 * Subsequent calls to read/write/close/ioctl/etc will use this
	 * minor number.  The minor number must be different from the
	 * the /dev/uds device's minor number (0).
	 */
	for (minor = 1; minor < NR_FDS; minor++)
		if (uds_fd_table[minor].state == UDS_FREE)
			break;

	if (minor == NR_FDS)
		return ENFILE;

	/*
	 * Allocate memory for the ringer buffer.  In order to save on memory
	 * in the common case, the buffer is allocated only when the socket is
	 * in use.  We use mmap instead of malloc to allow the memory to be
	 * actually freed later.
	 */
	if ((buf = mmap(NULL, UDS_BUF, PROT_READ | PROT_WRITE,
	    MAP_ANON | MAP_PRIVATE, -1, 0)) == MAP_FAILED)
		return ENOMEM;

	/*
	 * Allocate the socket, and set its initial parameters.
	 */
	uds_fd_table[minor].state = UDS_INUSE;
	uds_fd_table[minor].owner = user_endpt;
	uds_fd_table[minor].sel_endpt = NONE;
	uds_fd_table[minor].sel_ops = 0;
	uds_fd_table[minor].buf = buf;
	uds_fd_table[minor].pos = 0;
	uds_fd_table[minor].size = 0;
	uds_fd_table[minor].mode = UDS_R | UDS_W;
	uds_fd_table[minor].type = -1;

	for (i = 0; i < UDS_SOMAXCONN; i++)
		uds_fd_table[minor].backlog[i] = -1;
	uds_fd_table[minor].backlog_size = UDS_SOMAXCONN;

	memset(&uds_fd_table[minor].ancillary_data, '\0',
	    sizeof(struct ancillary));
	for (i = 0; i < OPEN_MAX; i++)
		uds_fd_table[minor].ancillary_data.fds[i] = -1;

	uds_fd_table[minor].stale = FALSE;
	uds_fd_table[minor].listening = FALSE;
	uds_fd_table[minor].peer = -1;
	uds_fd_table[minor].child = -1;

	memset(&uds_fd_table[minor].addr, '\0', sizeof(struct sockaddr_un));
	memset(&uds_fd_table[minor].source, '\0', sizeof(struct sockaddr_un));
	memset(&uds_fd_table[minor].target, '\0', sizeof(struct sockaddr_un));

	uds_fd_table[minor].suspended = UDS_NOT_SUSPENDED;

	return CDEV_CLONED | minor;
}

static void
uds_reset(devminor_t minor)
{
	/* Disconnect the socket from its peer. */
	uds_fd_table[minor].peer = -1;

	/* Set an error to pass to the caller. */
	uds_fd_table[minor].err = ECONNRESET;

	/* If a process was blocked on I/O, revive it. */
	if (uds_fd_table[minor].suspended != UDS_NOT_SUSPENDED)
		uds_unsuspend(minor);

	/* All of the peer's calls will fail immediately now. */
	if (uds_fd_table[minor].sel_ops != 0) {
		chardriver_reply_select(uds_fd_table[minor].sel_endpt, minor,
		    uds_fd_table[minor].sel_ops);
		uds_fd_table[minor].sel_ops = 0;
	}
}

static int
uds_close(devminor_t minor)
{
	int i, peer;

	dprintf(("UDS: uds_close(%d)\n", minor));

	if (minor < 0 || minor >= NR_FDS) return ENXIO;

	if (uds_fd_table[minor].state != UDS_INUSE)
		return EINVAL;

	peer = uds_fd_table[minor].peer;
	if (peer != -1 && uds_fd_table[peer].peer == -1) {
		/* Connecting socket: clear from server's backlog. */
		if (!uds_fd_table[peer].listening)
			panic("connecting socket attached to non-server");

		for (i = 0; i < uds_fd_table[peer].backlog_size; i++) {
			if (uds_fd_table[peer].backlog[i] == minor) {
				uds_fd_table[peer].backlog[i] = -1;
				break;
			}
		}
	} else if (peer != -1) {
		/* Connected socket: disconnect it. */
		uds_reset(peer);
	} else if (uds_fd_table[minor].listening) {
		/* Listening socket: disconnect all sockets in the backlog. */
		for (i = 0; i < uds_fd_table[minor].backlog_size; i++)
			if (uds_fd_table[minor].backlog[i] != -1)
				uds_reset(uds_fd_table[minor].backlog[i]);
	}

	if (uds_fd_table[minor].ancillary_data.nfiledes > 0)
		uds_clear_fds(minor, &uds_fd_table[minor].ancillary_data);

	/* Release the memory for the ring buffer. */
	munmap(uds_fd_table[minor].buf, UDS_BUF);

	/* Set the socket back to its original UDS_FREE state. */
	memset(&uds_fd_table[minor], '\0', sizeof(uds_fd_t));

	/* If terminating, and this was the last open socket, exit now. */
	if (uds_exit_left > 0) {
		if (--uds_exit_left == 0)
			chardriver_terminate();
	}

	return OK;
}

static int
uds_select(devminor_t minor, unsigned int ops, endpoint_t endpt)
{
	unsigned int ready_ops;
	int i, bytes, watch;

	dprintf(("UDS: uds_select(%d)\n", minor));

	if (minor < 0 || minor >= NR_FDS) return ENXIO;

	if (uds_fd_table[minor].state != UDS_INUSE)
		return EINVAL;

	watch = (ops & CDEV_NOTIFY);
	ops &= (CDEV_OP_RD | CDEV_OP_WR | CDEV_OP_ERR);

	ready_ops = 0;

	/* Check if there is data available to read. */
	if (ops & CDEV_OP_RD) {
		bytes = uds_perform_read(minor, NONE, GRANT_INVALID, 1, 1);
		if (bytes > 0) {
			ready_ops |= CDEV_OP_RD;	/* data available */
		} else if (uds_fd_table[minor].listening == TRUE) {
			/* Check for pending connections. */
			for (i = 0; i < uds_fd_table[minor].backlog_size; i++)
			{
				if (uds_fd_table[minor].backlog[i] != -1) {
					ready_ops |= CDEV_OP_RD;
					break;
				}
			}
		} else if (bytes != EDONTREPLY) {
			ready_ops |= CDEV_OP_RD;	/* error */
		}
	}

	/* Check if we can write without blocking. */
	if (ops & CDEV_OP_WR) {
		bytes = uds_perform_write(minor, NONE, GRANT_INVALID, 1, 1);
		if (bytes != 0 && bytes != EDONTREPLY)
			ready_ops |= CDEV_OP_WR;
	}

	/*
	 * If not all requested ops were ready, and the caller requests to be
	 * notified about changes, we add the remaining ops to the saved set.
	 */
	ops &= ~ready_ops;
	if (ops && watch) {
		uds_fd_table[minor].sel_endpt = endpt;
		uds_fd_table[minor].sel_ops |= ops;
	}

	return ready_ops;
}

ssize_t
uds_perform_read(devminor_t minor, endpoint_t endpt, cp_grant_id_t grant,
	size_t size, int pretend)
{
	size_t pos, subsize;
	int r, peer;

	dprintf(("UDS: uds_perform_read(%d)\n", minor));

	peer = uds_fd_table[minor].peer;

	/* Skip reads of zero bytes. */
	if (size == 0)
		return 0;

	/* Check if the socket isn't shut down for reads. */
	if (!(uds_fd_table[minor].mode & UDS_R))
		return EPIPE;

	if (uds_fd_table[minor].size == 0) {
		if (peer == -1) {
			/*
			 * We're not connected. That's only a problem when this
			 * socket is connection oriented.
			 */
			if (uds_fd_table[minor].type == SOCK_STREAM ||
			    uds_fd_table[minor].type == SOCK_SEQPACKET) {
				if (uds_fd_table[minor].err == ECONNRESET) {
					if (!pretend)
						uds_fd_table[minor].err = 0;
					return ECONNRESET;
				} else
					return ENOTCONN;
			}
		}

		/* Check if process is reading from a closed pipe. */
		if (peer != -1 && !(uds_fd_table[peer].mode & UDS_W) &&
		    uds_fd_table[minor].size == 0)
			return 0;

		if (pretend)
			return EDONTREPLY;

		if (peer != -1 &&
			uds_fd_table[peer].suspended == UDS_SUSPENDED_WRITE)
			panic("writer blocked on empty socket");

		dprintf(("UDS: suspending read request on %d\n", minor));

		/* Process is reading from an empty pipe.  Suspend it. */
		return EDONTREPLY;
	}

	/* How much can we get from the ring buffer? */
	if (size > uds_fd_table[minor].size)
		size = uds_fd_table[minor].size;

	if (pretend)
		return size;

	/* Get the data from the tail of the ring buffer. */
	pos = uds_fd_table[minor].pos;

	subsize = UDS_BUF - pos;
	if (subsize > size)
		subsize = size;

	if ((r = sys_safecopyto(endpt, grant, 0,
	    (vir_bytes) &uds_fd_table[minor].buf[pos], subsize)) != OK)
		return r;

	if (subsize < size) {
		if ((r = sys_safecopyto(endpt, grant, subsize,
		    (vir_bytes) uds_fd_table[minor].buf,
		    size - subsize)) != OK)
			return r;
	}

	/* Advance the buffer tail. */
	uds_fd_table[minor].pos = (pos + size) % UDS_BUF;
	uds_fd_table[minor].size -= size;

	/* Reset position if the buffer is empty (it may save a copy call). */
	if (uds_fd_table[minor].size == 0)
		uds_fd_table[minor].pos = 0;

	/* See if we can wake up a blocked writer. */
	if (peer != -1 && uds_fd_table[peer].suspended == UDS_SUSPENDED_WRITE)
		uds_unsuspend(peer);

	/* See if we can satisfy an ongoing select. */
	if (peer != -1 && (uds_fd_table[peer].sel_ops & CDEV_OP_WR) &&
	    uds_fd_table[minor].size < UDS_BUF) {
		/* A write on the peer is possible now. */
		chardriver_reply_select(uds_fd_table[peer].sel_endpt, peer,
		    CDEV_OP_WR);
		uds_fd_table[peer].sel_ops &= ~CDEV_OP_WR;
	}

	return size; /* number of bytes read */
}

static ssize_t
uds_perform_write(devminor_t minor, endpoint_t endpt, cp_grant_id_t grant,
	size_t size, int pretend)
{
	size_t subsize, pos;
	int i, r, peer;

	dprintf(("UDS: uds_perform_write(%d)\n", minor));

	/* Skip writes of zero bytes. */
	if (size == 0)
		return 0;

	/* Check if the socket isn't shut down for writes. */
	if (!(uds_fd_table[minor].mode & UDS_W))
		return EPIPE;

	/* Datagram messages must fit in the buffer entirely. */
	if (size > UDS_BUF && uds_fd_table[minor].type != SOCK_STREAM)
		return EMSGSIZE;

	if (uds_fd_table[minor].type == SOCK_STREAM ||
	    uds_fd_table[minor].type == SOCK_SEQPACKET) {
		/*
		 * If we're writing to a connection-oriented socket, then it
		 * needs a peer to write to.  For disconnected sockets, writing
		 * is an error; for connecting sockets, writes should suspend.
		 */
		peer = uds_fd_table[minor].peer;

		if (peer == -1) {
			if (uds_fd_table[minor].err == ECONNRESET) {
				if (!pretend)
					uds_fd_table[minor].err = 0;
				return ECONNRESET;
			} else
				return ENOTCONN;
		} else if (uds_fd_table[peer].peer == -1) /* connecting */
			return EDONTREPLY;
	} else /* uds_fd_table[minor].type == SOCK_DGRAM */ {
		peer = -1;

		/* Locate the "peer" we want to write to. */
		for (i = 0; i < NR_FDS; i++) {
			/*
			 * Look for a SOCK_DGRAM socket that is bound on
			 * the target address.
			 */
			if (uds_fd_table[i].type == SOCK_DGRAM &&
			    uds_fd_table[i].stale == FALSE &&
			    uds_fd_table[i].addr.sun_family == AF_UNIX &&
			    !strncmp(uds_fd_table[minor].target.sun_path,
			    uds_fd_table[i].addr.sun_path,
			    sizeof(uds_fd_table[i].addr.sun_path))) {
				peer = i;
				break;
			}
		}

		if (peer == -1)
			return ENOENT;
	}

	/* Check if we write to a closed pipe. */
	if (!(uds_fd_table[peer].mode & UDS_R))
		return EPIPE;

	/*
	 * We have to preserve the boundary for DGRAM.  If there's already a
	 * packet waiting, discard it silently and pretend it was written.
	 */
	if (uds_fd_table[minor].type == SOCK_DGRAM &&
	    uds_fd_table[peer].size > 0)
		return size;

	/*
	 * Check if the ring buffer is already full, and if the SEQPACKET
	 * message wouldn't write to an empty buffer.
	 */
	if (uds_fd_table[peer].size == UDS_BUF ||
	    (uds_fd_table[minor].type == SOCK_SEQPACKET &&
	    uds_fd_table[peer].size > 0)) {
		if (pretend)
			return EDONTREPLY;

		if (uds_fd_table[peer].suspended == UDS_SUSPENDED_READ)
			panic("reader blocked on full socket");

		dprintf(("UDS: suspending write request on %d\n", minor));

		/* Process is reading from an empty pipe.  Suspend it. */
		return EDONTREPLY;
	}

	/* How much can we add to the ring buffer? */
	if (size > UDS_BUF - uds_fd_table[peer].size)
		size = UDS_BUF - uds_fd_table[peer].size;

	if (pretend)
		return size;

	/* Put the data at the head of the ring buffer. */
	pos = (uds_fd_table[peer].pos + uds_fd_table[peer].size) % UDS_BUF;

	subsize = UDS_BUF - pos;
	if (subsize > size)
		subsize = size;

	if ((r = sys_safecopyfrom(endpt, grant, 0,
	    (vir_bytes) &uds_fd_table[peer].buf[pos], subsize)) != OK)
		return r;

	if (subsize < size) {
		if ((r = sys_safecopyfrom(endpt, grant, subsize,
		    (vir_bytes) uds_fd_table[peer].buf, size - subsize)) != OK)
			return r;
	}

	/* Advance the buffer head. */
	uds_fd_table[peer].size += size;

	/* Fill in the source address to be returned by recvfrom, recvmsg. */
	if (uds_fd_table[minor].type == SOCK_DGRAM)
		memcpy(&uds_fd_table[peer].source, &uds_fd_table[minor].addr,
		    sizeof(struct sockaddr_un));

	/* See if we can wake up a blocked reader. */
	if (uds_fd_table[peer].suspended == UDS_SUSPENDED_READ)
		uds_unsuspend(peer);

	/* See if we can satisfy an ongoing select. */
	if ((uds_fd_table[peer].sel_ops & CDEV_OP_RD) &&
	    uds_fd_table[peer].size > 0) {
		/* A read on the peer is possible now. */
		chardriver_reply_select(uds_fd_table[peer].sel_endpt, peer,
		    CDEV_OP_RD);
		uds_fd_table[peer].sel_ops &= ~CDEV_OP_RD;
	}

	return size; /* number of bytes written */
}

static ssize_t
uds_read(devminor_t minor, u64_t position, endpoint_t endpt,
	cp_grant_id_t grant, size_t size, int flags, cdev_id_t id)
{
	ssize_t rc;

	dprintf(("UDS: uds_read(%d)\n", minor));

	if (minor < 0 || minor >= NR_FDS) return ENXIO;

	if (uds_fd_table[minor].state != UDS_INUSE)
		return EINVAL;

	rc = uds_perform_read(minor, endpt, grant, size, 0);

	/* If the call couldn't complete, suspend the caller. */
	if (rc == EDONTREPLY) {
		uds_fd_table[minor].suspended = UDS_SUSPENDED_READ;
		uds_fd_table[minor].susp_endpt = endpt;
		uds_fd_table[minor].susp_grant = grant;
		uds_fd_table[minor].susp_size = size;
		uds_fd_table[minor].susp_id = id;

		/* If the call wasn't supposed to block, cancel immediately. */
		if (flags & CDEV_NONBLOCK) {
			uds_cancel(minor, endpt, id);

			rc = EAGAIN;
		}
	}

	return rc;
}

static ssize_t
uds_write(devminor_t minor, u64_t position, endpoint_t endpt,
	cp_grant_id_t grant, size_t size, int flags, cdev_id_t id)
{
	ssize_t rc;

	dprintf(("UDS: uds_write(%d)\n", minor));

	if (minor < 0 || minor >= NR_FDS) return ENXIO;

	if (uds_fd_table[minor].state != UDS_INUSE)
		return EINVAL;

	rc = uds_perform_write(minor, endpt, grant, size, 0);

	/* If the call couldn't complete, suspend the caller. */
	if (rc == EDONTREPLY) {
		uds_fd_table[minor].suspended = UDS_SUSPENDED_WRITE;
		uds_fd_table[minor].susp_endpt = endpt;
		uds_fd_table[minor].susp_grant = grant;
		uds_fd_table[minor].susp_size = size;
		uds_fd_table[minor].susp_id = id;

		/* If the call wasn't supposed to block, cancel immediately. */
		if (flags & CDEV_NONBLOCK) {
			uds_cancel(minor, endpt, id);

			rc = EAGAIN;
		}
	}

	return rc;
}

static int
uds_ioctl(devminor_t minor, unsigned long request, endpoint_t endpt,
	cp_grant_id_t grant, int flags, endpoint_t user_endpt, cdev_id_t id)
{
	int rc, s;

	dprintf(("UDS: uds_ioctl(%d, %lu)\n", minor, request));

	if (minor < 0 || minor >= NR_FDS) return ENXIO;

	if (uds_fd_table[minor].state != UDS_INUSE)
		return EINVAL;

	/* Update the owner endpoint. */
	uds_fd_table[minor].owner = user_endpt;

	/* Let the UDS ioctl subsystem handle the actual request. */
	rc = uds_do_ioctl(minor, request, endpt, grant);

	/* If the call couldn't complete, suspend the caller. */
	if (rc == EDONTREPLY) {
		/* The suspension type is already set by the IOCTL handler. */
		if ((s = uds_fd_table[minor].suspended) == UDS_NOT_SUSPENDED)
			panic("IOCTL did not actually suspend?");
		uds_fd_table[minor].susp_endpt = endpt;
		uds_fd_table[minor].susp_grant = grant;
		uds_fd_table[minor].susp_size = 0; /* irrelevant */
		uds_fd_table[minor].susp_id = id;

		/* If the call wasn't supposed to block, cancel immediately. */
		if (flags & CDEV_NONBLOCK) {
			uds_cancel(minor, endpt, id);
			if (s == UDS_SUSPENDED_CONNECT)
				rc = EINPROGRESS;
			else
				rc = EAGAIN;
		}
	}

	return rc;
}

void
uds_unsuspend(devminor_t minor)
{
	int r;
	uds_fd_t *fdp;

	fdp = &uds_fd_table[minor];

	switch (fdp->suspended) {
	case UDS_SUSPENDED_READ:
		r = uds_perform_read(minor, fdp->susp_endpt, fdp->susp_grant,
		    fdp->susp_size, 0);

		if (r == EDONTREPLY)
			return;

		break;

	case UDS_SUSPENDED_WRITE:
		r = uds_perform_write(minor, fdp->susp_endpt, fdp->susp_grant,
		    fdp->susp_size, 0);

		if (r == EDONTREPLY)
			return;

		break;

	case UDS_SUSPENDED_CONNECT:
	case UDS_SUSPENDED_ACCEPT:
		/*
		 * In both cases, the caller already set up the connection.
		 * The only thing to do here is unblock.
		 */
		r = fdp->err;
		fdp->err = 0;

		break;

	default:
		panic("unknown suspension type %d", fdp->suspended);
	}

	chardriver_reply_task(fdp->susp_endpt, fdp->susp_id, r);

	fdp->suspended = UDS_NOT_SUSPENDED;
}

static int
uds_cancel(devminor_t minor, endpoint_t endpt, cdev_id_t id)
{
	uds_fd_t *fdp;
	int i;

	dprintf(("UDS: uds_cancel(%d)\n", minor));

	if (minor < 0 || minor >= NR_FDS) return EDONTREPLY;

	fdp = &uds_fd_table[minor];

	if (fdp->state != UDS_INUSE) {
		printf("UDS: cancel request for closed minor %d\n", minor);
		return EDONTREPLY;
	}

	/* Make sure the cancel request is for a request we're hanging on. */
	if (fdp->suspended == UDS_NOT_SUSPENDED || fdp->susp_endpt != endpt ||
	    fdp->susp_id != id)
		return EDONTREPLY;	/* this happens. */

	/*
	 * The system call was cancelled, so the socket is not suspended
	 * anymore.
	 */
	switch (fdp->suspended) {
	case UDS_SUSPENDED_ACCEPT:
		/* A partial accept() only sets the server's child. */
		for (i = 0; i < NR_FDS; i++)
			if (uds_fd_table[i].child == minor)
				uds_fd_table[i].child = -1;

		break;

	case UDS_SUSPENDED_CONNECT:
		/* Connect requests should continue asynchronously. */
		break;

	case UDS_SUSPENDED_READ:
	case UDS_SUSPENDED_WRITE:
		/* Nothing more to do. */
		break;

	default:
		panic("unknown suspension type %d", fdp->suspended);
	}

	fdp->suspended = UDS_NOT_SUSPENDED;

	return EINTR;	/* reply to the original request */
}

/*
 * Initialize the server.
 */
static int
uds_init(int UNUSED(type), sef_init_info_t *UNUSED(info))
{
	/* Setting everything to NULL implicitly sets the state to UDS_FREE. */
	memset(uds_fd_table, '\0', sizeof(uds_fd_t) * NR_FDS);

	uds_exit_left = 0;

	/* Announce we are up! */
	chardriver_announce();

	return(OK);
}

static void
uds_signal(int signo)
{
	int i;

	/* Only check for termination signal, ignore anything else. */
	if (signo != SIGTERM) return;

	/* Only exit once all sockets have been closed. */
	uds_exit_left = 0;
	for (i = 0; i < NR_FDS; i++)
		if (uds_fd_table[i].state == UDS_INUSE)
			uds_exit_left++;

	if (uds_exit_left == 0)
		chardriver_terminate();
}

static void
uds_startup(void)
{
	/* Register init callbacks. */
	sef_setcb_init_fresh(uds_init);

	/* Register signal callbacks. */
	sef_setcb_signal_handler(uds_signal);

	/* Let SEF perform startup. */
	sef_startup();
}

/*
 * The UNIX domain sockets driver.
 */
int
main(void)
{
	uds_startup();

	chardriver_task(&uds_tab);

	return(OK);
}