Using the (Bourne shell) I/O redirection syntax 2>&1 informs the shell that we wish to have standard error (file descriptor 2) redirected to the same place to which standard output (file descriptor 1) is being sent. Thus, the following command would (since the shell evaluates I/O directions from left to right) send both standard output and standard error to the file results.log:
$ ./myscript > results.log 2>&1The shell achieves the redirection of standard error by duplicating file descriptor 2 so that it refers to the same open file description as file descriptor 1 (in the same way that descriptors 1 and 20 of process A refer to the same open file description in Figure 5-2). This effect can be achieved using the dup() and dup2() system calls.
Note that it is not sufficient for the shell simply to open the results.log file twice: once on descriptor 1 and once on descriptor 2. One reason for this is that the two file descriptors would not share a file offset pointer, and hence could end up overwriting each other’s output. Another reason is that the file may not be a disk file. Consider the following command, which sends standard error down the same pipe as standard output:
$ ./myscript 2>&1 | lessThe dup() call takes oldfd, an open file descriptor, and returns a new descriptor that refers to the same open file description. The new descriptor is guaranteed to be the lowest unused file descriptor.
#include <unistd.h>
int dup(int oldfd);Returns (new) file descriptor on success, or -1 on error
Suppose we make the following call:
newfd = dup(1);
Assuming the normal situation where the shell has opened file descriptors 0, 1, and 2 on the program’s behalf, and no other descriptors are in use, dup() will create the duplicate of descriptor 1 using file 3.
If we wanted the duplicate to be descriptor 2, we could use the following technique:
close(2); /* Frees file descriptor 2 */ newfd = dup(1); /* Should reuse file descriptor 2 */
This code works only if descriptor 0 was open. To make the above code simpler, and to ensure we always get the file descriptor we want, we can use dup2().
#include <unistd.h>
int dup2(int oldfd, int newfd);Returns (new) file descriptor on success, or -1 on error
The dup2() system call makes a duplicate of the file descriptor given in oldfd using the descriptor number supplied in newfd. If the file descriptor specified in newfd is already open, dup2() closes it first. (Any error that occurs during this close is silently ignored; safer programming practice is to explicitly close() newfd if it is open before the call to dup2().)
We could simplify the preceding calls to close() and dup() to the following:
dup2(1, 2);
A successful dup2() call returns the number of the duplicate descriptor (i.e., the value passed in newfd).
If oldfd is not a valid file descriptor, then dup2() fails with the error EBADF and newfd is not closed. If oldfd is a valid file descriptor, and oldfd and newfd have the same value, then dup2() does nothing—newfd is not closed, and dup2() returns the newfd as its function result.
A further interface that provides some extra flexibility for duplicating file descriptors is the fcntl() F_DUPFD operation:
newfd = fcntl(oldfd, F_DUPFD, startfd);
This call makes a duplicate of oldfd by using the lowest unused file descriptor greater than or equal to startfd. This is useful if we want a guarantee that the new descriptor (newfd) falls in a certain range of values. Calls to dup() and dup2() can always be recoded as calls to close() and fcntl(), although the former calls are more concise. (Note also that some of the errno error codes returned by dup2() and fcntl() differ, as described in the manual pages.)
From Figure 5-2, we can see that duplicate file descriptors share the same file offset value and status flags in their shared open file description. However, the new file descriptor has its own set of file descriptor flags, and its close-on-exec flag (FD_CLOEXEC) is always turned off. The interfaces that we describe next allow explicit control of the new file descriptor’s close-on-exec flag.
The dup3() system call performs the same task as dup2(), but adds an additional argument, flags, that is a bit mask that modifies the behavior of the system call.
#define _GNU_SOURCE
#include <unistd.h>
int dup3(int oldfd, int newfd, int flags);Returns (new) file descriptor on success, or -1 on error
Currently, dup3() supports one flag, O_CLOEXEC, which causes the kernel to enable the close-on-exec flag (FD_CLOEXEC) for the new file descriptor. This flag is useful for the same reasons as the open() O_CLOEXEC flag described in .
The dup3() system call is new in Linux 2.6.27, and is Linux-specific.
Since Linux 2.6.24, Linux also supports an additional fcntl() operation for duplicating file descriptors: F_DUPFD_CLOEXEC. This flag does the same thing as F_DUPFD, but additionally sets the close-on-exec flag (FD_CLOEXEC) for the new file descriptor. Again, this operation is useful for the same reasons as the open() O_CLOEXEC flag. F_DUPFD_CLOEXEC is not specified in SUSv3, but is specified in SUSv4.