Practical use for moving file descriptors

According to the bash man page:

The redirection operator

   [n]<&digit-

moves the file descriptor digit to file descriptor n, or the standard input
(file descriptor 0) if n is not specified. digit is closed after being dupli‐cated to n.

What does it mean to “move” a file descriptor to another one? What are the typical situations for such practice?

Answers:

Thank you for visiting the Q&A section on Magenaut. Please note that all the answers may not help you solve the issue immediately. So please treat them as advisements. If you found the post helpful (or not), leave a comment & I’ll get back to you as soon as possible.

Method 1

3>&4- is a ksh93 extension also supported by bash and that is short for 3>&4 4>&-, that is 3 now points to where 4 used to, and 4 is now closed, so what was pointed to by 4 has now moved to 3.

Typical usage would be in cases where you’ve duplicated stdin or stdout to save a copy of it and want to restore it, like in:

Suppose you want to capture the stderr of a command (and stderr only) while leaving stdout alone in a variable.

Command substitution var=$(cmd), creates a pipe. The writing end of the pipe becomes cmd‘s stdout (file descriptor 1) and the other end is read by the shell to fill up the variable.

Now, if you want stderr to go to the variable, you could do: var=$(cmd 2>&1). Now both fd 1 (stdout) and 2 (stderr) go to the pipe (and eventually to the variable), which is only half of what we want.

If we do var=$(cmd 2>&1-) (short for var=$(cmd 2>&1 >&-), now only cmd‘s stderr goes to the pipe, but fd 1 is closed. If cmd tries to write any output, that would return with a EBADF error, if it opens a file, it will get the first free fd and the open file will be assigned it to stdout unless the command guards against that! Not what we want either.

If we want the stdout of cmd to be left alone, that is to point to the same resource that it pointed to outside the command substitution, then we need somehow to bring that resource inside the command substitution. For that we can do a copy of stdout outside the command substitution to take it inside.

{
  var=$(cmd)
} 3>&1

Which is a cleaner way to write:
exec 3>&1
var=$(cmd)
exec 3>&-

(which also has the benefit of restoring fd 3 instead of closing it in the end).

Then upon the { (or the exec 3>&1) and up to the }, both fd 1 and 3 point to the same resource fd 1 pointed to initially. fd 3 will also point to that resource inside the command substitution (command substitution only redirects the fd 1, stdout). So above, for cmd, we’ve got for fds 1, 2, 3:

  1. the pipe to var
  2. untouched
  3. same as what 1 points to outside the command substitution

If we change it to:

{
  var=$(cmd 2>&1 >&3)
} 3>&1-

Then it becomes:
  1. same as what 1 points to outside the command substitution
  2. the pipe to var
  3. same as what 1 points to outside the command substitution

Now, we’ve got what we wanted: stderr goes to the pipe and stdout is left untouched. However, we’re leaking that fd 3 to cmd.

While commands (by convention) assume fds 0 to 2 to be open and be standard input, output and error, they don’t assume anything of other fds. Most likely they will leave that fd 3 untouched. If they need another file descriptor, they’ll just do an open()/dup()/socket()... which will return the first available file descriptor. If (like a shell script that does exec 3>&1) they need to use that fd specifically, they will first assign it to something (and in that process, the resource held by our fd 3 will be released by that process).

It’s good practice to close that fd 3 since cmd doesn’t make use of it, but it’s no big deal if we leave it assigned before we call cmd. The problems may be: that cmd (and potentially other processes that it spawns) has one fewer fd available to it. A potentially more serious problem is if the resource that that fd points to may end up held by a process spawned by that cmd in background. It can be a concern if that resource is a pipe or other inter-process communication channel (like when your script is being run as script_output=$(your-script)), as that will mean the process reading from the other end will never see end-of-file until that background process terminates.

So here, it’s better to write:

{
  var=$(cmd 2>&1 >&3 3>&-)
} 3>&1

Which, with bash can be shorten to:
{
  var=$(cmd 2>&1 >&3-)
} 3>&1

To sum up the reasons why it’s rarely used:
  1. it’s non-standard and just syntactic sugar. You’ve got to balance saving a few keystrokes with making your script less portable and less obvious to people not used to that uncommon feature.
  2. The need to close the original fd after duplicating it is often overlooked because most of the time, we don’t suffer from the consequence, so we just do >&3 instead of >&3- or >&3 3>&-.

Proof that it’s rarely used, as you found out is that it is bogus in bash. In bash compound-command 3>&4- or any-builtin 3>&4- leaves fd 4 closed even after compound-command or any-builtin has returned. A patch to fix the issue is now (2013-02-19) available.

Method 2

It means to make it point to the same place the other file descriptor does. You need to do this very rarely, apart from the obvious separate handling of the standard error descriptor (stderr, fd 2, /dev/stderr -> /proc/self/fd/2). It can come handy in some complex cases.

The Advanced Bash Scripting guide has this longer log level example and this snippet:

# Redirecting only stderr to a pipe.
exec 3>&1                              # Save current "value" of stdout.
ls -l 2>&1 >&3 3>&- | grep bad 3>&-    # Close fd 3 for 'grep' (but not 'ls').
#              ^^^^   ^^^^
exec 3>&-                              # Now close it for the remainder of the script.

In Source Mage’s Sorcery we for example use it to discern different outputs from the same code block:
  (
    # everything is set, so run the actual build infrastructure
    run_build
  ) 3> >(tee -a $C_LOG >> /dev/stdout) 
    2> >(tee -a $C_LOG 1>&2 > $VOYEUR_STDERR) 
     > >(tee -a $C_LOG > $VOYEUR_STDOUT)

It has extra process substitution appended for logging reasons (VOYEUR decides whether the data should be shown on screen or just log), but some messages need to always be presented. To achieve that, we print them to file descriptor 3 and then handle it specially.

Method 3

In Unix, files are handled by file descriptors (smallish integers, for example standard input is 0, standard output is 1, standard error is 2; as you open other files they normally get assigned the smallest unused descriptor). So if you know the inards of the program, and you want to send the output that goes to file descriptor 5 to the standard output, you’d move descriptor 5 to 1. That’s where the 2> errors comes from, and constructions like 2>&1 to duplicate errors into the output stream.

So, hardly ever used (I vaguely remember using it once or twice in anger in my 25+ years of almost exclusive Unix use), but when needed absolutely essential.


All methods was sourced from stackoverflow.com or stackexchange.com, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0

0 0 votes
Article Rating
Subscribe
Notify of
guest
0 Comments
Inline Feedbacks
View all comments