27

I know that dup, dup2, dup3 "create a copy of the file descriptor oldfd"(from man pages). However I can't digest it.

As I know file descriptors are just numbers to keep track of file locations and their direction(input/output). Wouldn't it be easier to just

fd=fd2;

Whenever we want to duplicate a file descriptor?

And something else..

dup() uses the lowest-numbered unused descriptor for the new descriptor.

Does that mean that it can also take as value stdin, stdout or stderr if we assume that we have close()-ed one of those?

Pithikos
  • 18,827
  • 15
  • 113
  • 136
  • 3
    For the first question you need to remember that the kernel keeps track of the number of open file handles. `dup` is your way of telling the kernel that you want it to keep track track of another one of those file handles (referring to the same file) until you `close` it. – user786653 Oct 22 '11 at 18:17

8 Answers8

25

Just wanted to respond to myself on the second question after experimenting a bit.

The answer is YES. A file descriptor that you make can take a value 0, 1, 2 if stdin, stdout or stderr are closed.

Example:

close(1);     //closing stdout
newfd=dup(1); //newfd takes value of least available fd number

Where this happens to file descriptors:

0 stdin     .--------------.     0 stdin     .--------------.     0 stdin
1 stdout   =|   close(1)   :=>   2 stderr   =| newfd=dup(1) :=>   1 newfd
2 stderr    '--------------'                 '--------------'     2 stderr
Pithikos
  • 18,827
  • 15
  • 113
  • 136
  • 1
    A question arose again: How can I `dup()` a file descriptor that I already closed? – Pithikos Aug 19 '14 at 09:19
  • From the definition, dup() uses the lowest-numbered unused descriptor for the new descriptor. And when you close a file descriptor, this means that it is available for use. – Raghu Srikanth Reddy Aug 25 '14 at 06:52
15

A file descriptor is a bit more than a number. It also carries various semi-hidden state with it (whether it's open or not, to which file description it refers, and also some flags). dup duplicates this information, so you can e.g. close the two descriptors independently. fd=fd2 does not.

n. m. could be an AI
  • 112,515
  • 14
  • 128
  • 243
  • 1
    This. The "number" is an index into a data structure maintained by the kernel. The `dup` family of function clone the state of a node in that data structure and hand you the index to the new node. – dmckee --- ex-moderator kitten Oct 22 '11 at 19:46
  • 3
    @dmckee: "Kernel" and "index" are implementation details. There's some data associated with "the number" which cannot be manipulated directly by the program, and which is cloned by `dup()`. That's all the programmer needs to know. By the way it is not a very interesting piece of data, it's just a couple of flags and an index to the really interesting data (the open file description) which is **not** cloned by `dup()`. – n. m. could be an AI Oct 22 '11 at 20:10
7

The single most important thing about dup() is it returns the smallest integer available for a new file descriptor. That's the basis of redirection:

int fd_redirect_to = open("file", O_CREAT);
close(1); /* stdout */
int fd_to_redirect = dup(fd_redirect_to); /* magically returns 1: stdout */
close(fd_redirect_to); /* we don't need this */

After this anything written to file descriptor 1 (stdout), magically goes into "file".

SzG
  • 12,333
  • 4
  • 28
  • 41
  • Assuming (not unreasonably) that file descriptor 0 is currently open. Support for redirections such as `200>somefile` is very inconvenient without `dup2()` (or `dup3()`, but that is a recent addition to systems). – Jonathan Leffler Aug 03 '13 at 09:18
7

Let's say you're writing a shell program and you want to redirect stdin and stdout in a program you want to run. It could look something like this:

fdin = open(infile, O_RDONLY);
fdout = open(outfile, O_WRONLY);
// Check for errors, send messages to stdout.
...
int pid = fork(0);
if(pid == 0) {
    close(0);
    dup(fdin);
    close(fdin);
    close(1);
    dup(fdout);
    close(fdout);
    execvp(program, argv);
}
// Parent process cleans up, maybe waits for child.
...

dup2() is a little more convenient way to do it the close() dup() can be replaced by:

dup2(fdin, 0);
dup2(fdout, 1);

The reason why you want to do this is that you want to report errors to stdout (or stderr) so you can't just close them and open a new file in the child process. Secondly, it would be a waste to do the fork if either open() call returned an error.

Richard Pennington
  • 19,673
  • 4
  • 43
  • 72
4

Example:

close(1);     //closing stdout
newfd=dup(1); //newfd takes value of least available fd number

Where this happens to file descriptors:

0 stdin     .--------------.     0 stdin     .--------------.     0 stdin
1 stdout   =|   close(1)   :=>   2 stderr   =| newfd=dup(1) :=>   1 newfd
2 stderr    '--------------'                 '--------------'     2 stderr

A question arose again: How can I dup() a file descriptor that I already closed?

I doubt that you conducted the above experiment with the shown result, because that would not be standard-conforming - cf. dup:

The dup() function shall fail if:

[EBADF]
The fildes argument is not a valid open file descriptor.

So, after the shown code sequence, newfd must be not 1, but rather -1, and errno EBADF.

Armali
  • 18,255
  • 14
  • 57
  • 171
2

see this page, stdout can be aliased as dup(1)...

Karel Frajták
  • 4,389
  • 1
  • 23
  • 34
1

Just a tip about "duplicating standard output".

On some Unix Systems (but not GNU/Linux)

fd = open("/dev/fd/1", O_WRONLY);

it is equivalent to:

fd = dup(1);
b3h3m0th
  • 1,330
  • 1
  • 11
  • 22
0

dup() and dup2() system call

•The dup() system call duplicates an open file descriptor and returns the new file descriptor.

•The new file descriptor has the following properties in common with the original file descriptor: 1. refers to the same open file or pipe. 2. has the same file pointer -- that is, both file descriptors share one file pointer. 3. has the same access mode, whether read, write, or read and write.

• dup() is guaranteed to return a file descriptor with the lowest integer value available.It is because of this feature of returning the lowest unused file descriptor available that processes accomplish I/O redirection.

int dup(file_descriptor)

int dup2(file_descriptor1, file_descriptor2)

Mahendra suthar
  • 401
  • 5
  • 18