Given I was asked the question without having enough Linux knowledge to answer, I try it here.

Is it possible to use a re-direct ">" to send standard output to a device in /dev, while also using a "<" to have incoming standard input from the same device arrive in a file, or maybe program controlled buffer, without needing to install any special kernel modules or devices?

We already know that if we use the "|" pipe command, the outgoing stream is immediately returned to the input stream. For us, the need is to have some sort of node, hopefully a standard device like /dev/TTYn, which can take standard output, and also accept external event input directed into a different buffer.

Thanks for any suggestions.

If I were going down this path I'd probably look into doing a named pipe setup.

If you do a search for named pipe you can find many hits including this one that may give you ideas:
http://www.linuxjournal.com/content/...pes-fifos-bash

I don't understand the question. You want some device that will read data from stdin and do what with it? You want output from this device to then go to a file, but what output? What is this device doing? What are you sending it and what are you expecting to get out of it?

The ">" redirect operator transfers one of the process's standard inputs or outputs to/from an external file. Only one process exists.

The "|" pipe operator actually creates two simultaneous processes, and creates a FIFO-queue (a "pipe") which connects the STDOUT of the left-hand process to the STDIN of the right-hand process. Two processes exist, running simultaneously. Eventually the "writer" finishes writing and closes the pipe. The "reader," upon consuming the rest of the information in the pipe, is notified that the pipe has been closed and terminates also.

Pipes provide automatic synchronization and buffering: if the writer writes "too much" and the pipe becomes full, it is suspended until the reader consumes some of it. Likewise, if the reader finds that, at the moment, there's no information there, it is suspended until the writer writes (or, closes the pipe).

Both of these are examples of "redirecting the STDIN, STDOUT, and STDERR streams," but one uses a disk-file while the other uses a pipe.

Also note that, to the user of a pipe, a pipe works just like a (non-seek()-able) disk file.

It really is "quite elegant."

1 members found this post helpful.

Thanks to all for the replies.

I get it that the ">" redirect always interfaces to a file, which is not what we need.
Clearly the pipe operator is the more useful in this case.

The original sketch showed a program using two FIFO buffers, one for output, another for input, both going to a node which was the interface to the outside world, likely a UDP transfer.

I think the issue was that if an outgoing "|" pipe transfer happened to the node (a device like TTYn ??), then the data was immediately sent back up the other FIFO.

Given there is "automatic" FIFO property inherent in the "|" pipe operator, we may now know enough. Certainly I have learned something new. My colleague is much more skilled at programming than I am, and I have made him aware of this thread.

Pipes
Introduction to Pipes
I/O Redirection

Working with Named Pipes
Still have this "sketch"?