Shell Programming and Scripting

Hi there,

I'm in a coding mood!
I've come through many ways of conditionally redirect the output of a script like:

Code:

[[ $verbose ]] || exec &> /dev/null

But my goal is slightly different. I would like to conditionally redirect the output of a command depending on the status of the command itself:

Code:

if ! mycommand; then exec &>/dev/null; fi

Obviously this does NOT work. The output of mycommand is printed whatever the status of mycommand is. The output is silenced if mycommand fails but it only applies to subsequent commands.

Any idea how I can achieve this?

Best regards
Santiago

---------- Post updated at 15:24 ---------- Previous update was at 15:15 ----------

I have two extra conditions:

1. I cannot store the output of mycommand in a variable:

Code:

if output=$(mycommand); then echo "$output"; fi

The problem is that mycommand outputs binary data including the null character.

2. I' rather not use a temporary file:

Code:

if mycommand > /tmp/file; then cat /tmp/file; fi

Just because I don't like it

You can't have your cake and eat it. The exit code of a program is available when the program is finished running. The output redirection has to be done before the program produces its output.

You could try to write a wrapper around your program, which catches it standard output internally, and after the program is executed, decides what to do with it. Such a wrapper could, for example, be written with `expect`, if the output is large, or you can stuff it into a shell variable. Of course in both cases it means that the interim output is stored somewhere, be it in a variable or in a file.

Thanks rovf for the explanation about the fact that redirecting has to be done before the program produces its output.

Again I had a problem using a variable because myprogram produces binary output including the nul character. So I came up with this wrapper that stores the output in a variable in plain hexadecimal.

Code:

if output="$(
    (
        (
            (
                mycommand && echo 0 >&3 || echo $? >&3
            ) | xxd -p | tr -d $'\n' >&4
        ) 3>&1 | ( read xs; exit $xs )
    ) 4>&1
)"; then
    echo -ne "$output" | xxd -r -p
else
    return $?
fi

What do you think?

It is a bit odd (though not forbidden) to use stdout as a binary stream. What are you doing with the data afterwards? It is most likely that this data - being not human-readable - will be processed by another program eventually, and since it is binary data, it will be read blockwise. Unless you pipe it immediately into another program, the most likely case is to store it into a file. That's what files are for, after all.

The NUL character by itself should not be a problem, because every program where the stdout of your original program is piped in, should set its stdin to binary and read the data blockwise.

mycommand outputs a list of files in a human readable form (newline separated). But I might run into weird filenames so I added the option --null to mycommand so it prints files separated by the NUL character. What I do with the data is:

Code:

mycommand --null | xargs --null cp --target-directory="$mydir"

mycommand fails in specific situations and I don't want any output to be piped to cp in such a case.

I could for sure use a temporary file but I like (as a personal fanciness) to avoid that.

Does it make any sense in your opinion?

Not really. As I said before, in order to recommend any approach, one needs to know what you are eventually going to do with the binary output of your program. You didn't say anything about this.

Running a command substitution invoking three external processes storing an unspecified amount of data into a variable that might cause an ARG_MAX overflow error when decoding it seems to me to be a slow, convoluted, and dangerous replacement for a much simpler script using a temp file as in:

Code:

$!/bin/bash
mycommand --null > mycommand.tmp.$$ && xargs --null cp --target-directory="$mydir" < mycommand.tmp.$$
xs=$?
rm -f mycommand.tmp.$$
exit $xs