Receiving output from the remote application

Since REXEC uses bi-directional asynchronous connections, incoming data (remote process output) has to be polled for. However, when the data does arrive, it is packaged in packets that only REXEC client routines can understand. Therefore, the user program has to poll the file descriptor used by the REXEC connection (which can be obtained using the rx_fd routine). Once an indication of new data has been received, the data is actually read in by rx_proc_msg. This routine will read in an REXEC packet and handle it appropriately.

int	cnum;			/* connection number */

main()
{
	struct pollfd	pollfd[5];	/* structure for poll() */
	long	talen,		/* returned type-ahead length */
		msg_type,		/* rexec message type */
		ret_code;		/* terminating process' return code */
	.
	.
	.
	pollfd[0].fd = rx_fd(cnum);
	pollfd[0].events = POLLRDNORM;
	nfds = 1;

	if (poll(pollfd, nfds, INFTIM) < 0) {
		if (errno != EINTR) {
			fprintf(stderr, "poll error\n");
			exit(1);
		}

		if ((talen = rx_proc_msg(cnum, &msg_type, &ret_code)) < 0) {
			rxperror(Rx_errno);
			exit(1);
		}

		/* handle special conditions */

		switch(msg_type) {

		case RX_INCOMPLETE:
		case RX_PROTOCOL:
		case RX_DATA:
		case RX_IOCTL:

			/* no additional action required */
			break;

		case RX_SERVICE_DEAD:

			/*
			 * remote process died:
			 * can still receive output, but
			 * should not send any more input
			 *
			 */
			break;

		case RX_TYPEAHEAD:

			/*
			 * process returned type-ahead
			 * and close connection
			 *
			 */
			break;
		}
	}
}

static int
my_write(fd, buf, len)
int	fd;		/* file descriptor */
char	*buf;		/* data buffer */
int	len;		/* data length */
{
	printf("my_write: writing %d bytes to fd %d\n", len, fd);
	return(write(fd, buf, len));
}

main()
{
.
.
.
	(void) set_write_hand(cnum, my_write);
.
.
.
}

If the REXEC message contains an ioctl message, it will be executed using a pre-defined ioctl routine. By default, this is simply the ioctl system call, but it can be changed by using the set_ioctl_hand routine as follows:

static int
my_ioctl(fd, cmd, buf)
int	fd;		/* file descriptor */
int	cmd;		/* ioctl command */
char	*buf;		/* ioctl data buffer */
{
	printf("my_ioctl: sending ioctl cmd #%d to fd #%d\n", cmd, fd);
	return(ioctl(fd, cmd, buf));
}

main()
{
.
.
.
	(void) set_ioctl_hand(cnum, my_ioctl);
.
.
.
}