Ubuntu – How to get dialog box input directed to a variable

bashdialog

I have been teaching myself bash scripting and have run into an issue. I have written a script to take input from the user, using the 'read' command, and make that input a variable to use later in the script. The script works, but….

I would like to be able to get it setup using 'dialog'. I found out that

'dialog –inputbox' will direct the output to 'stderr' and in order to get that input as a variable you have to direct it to a file and then retrieve it. The code I found to explain this is:

#!/bin/bash
dialog --inputbox \

"What is your username?" 0 0 2> /tmp/inputbox.tmp.$$

retval=$?

input=`cat /tmp/inputbox.tmp.$$`

rm -f /tmp/inputbox.tmp.$$

case $retval in
0)

echo "Your username is '$input'";;
1)

echo "Cancel pressed.";;

esac

I see that it is sending the sdterr to the /tmp/inputbox.tmp.$$ with 2>, but the output file looks like 'inputbox.tmp.21661'. When I try and cat the file it gives me an error. So I am still unable to get the user input from the –inputbox as a variable.

Example Script:

echo "  What app would you like to remove? "

read dead_app

sudo apt-get remove --purge $dead_app

So as you can see it is a basic script. Is it even possible to get the variable as a word from dialog --inputbox?

Best Answer

:D I can't explain it!!! If you can understand what they are saying in Advanced Bash-Scripting Guide: Chapter 20. I/O Redirection, write a new answer and I will give you 50rep:
exec 3>&1;
result=$(dialog --inputbox test 0 0 2>&1 1>&3);
exitcode=$?;
exec 3>&-;
echo $result $exitcode;
Reference: Dialog in bash is not grabbing variables correctly

^{^ answer from @Sneetsher (Jul 4, 2014)}

As requested, I will try to explain what this snippet is doing line by line.

Note that I will simplify it by omitting all the ; semicolons at the line ends, because they're not necessary if we write one command per line.

I/O - Streams:

First, you need to understand the communication streams. There are 10 streams, numbered from 0 to 9:

Stream 0 ("STDIN"):
"Standard input", the default input stream to read data from the keyboard.
Stream 1 ("STDOUT"):
"Standard output", the default output stream used to show normal text in the terminal.
Stream 2 ("STDERR"): "Standard error", the default output stream used to display errors or other text for special purposes in the terminal.
Streams 3-9:
Additional, freely usable streams. They're not used by default and do not exist until something attempts to use them.

Note that all "streams" are internally represented by file descriptors in /dev/fd (which is a symbolic link to /proc/self/fd which contains another symbolic link for every stream... it's a bit complicated and not important for their behaviour, so I stop here.). The standard streams also have /dev/stdin, /dev/stdout and /dev/stderr (which are symbolic links again, etc...).

The script:

```
exec 3>&1
```
The Bash built-in exec can be used to apply a stream redirection to the shell, that means it affects all following commands. For more info, run help exec in your terminal.

In this special case, the stream 3 gets redirected to stream 1 (STDOUT), that means everything we send to stream 3 later will appear in our terminal as if it was normally printed to STDOUT.
```
result=$(dialog --inputbox test 0 0 2>&1 1>&3)
```
This line consists of many parts and syntactical structures:
- result=$(...)
  This structure executes the command in the brackets and assigns the output (STDOUT) to the bash variable result. It's readable through $result. All this is described somehow in the veeeery looong man bash.
- dialog --inputbox TEXT HEIGHT WIDTH
  This command shows a TUI box with the given TEXT, a text input field and two buttons OK and CANCEL. If OK gets selected, the command exits with status 0 and prints the entered text to STDERR, if CANCEL gets selected, it will exit with code 1 and print nothing. For more info, read man dialog.
- 2>&1 1>&3
  These are two redirection commands. They will be interpreted from right to left:
  
  1>&3 redirects the command's stream 1 (STDOUT) to the custom stream 3.
  
  2>&1 redirects afterwards the command's stream 2 (STDERR) to stream 1 (STDOUT).
  
  That means that everything the command prints to STDOUT now appears in stream 3, while everything that was intended to show up on STDERR now gets redirected to STDOUT.
So the entire line displays a text prompt (on STDOUT, which got redirected to stream 3, which the shell again redirects back to STDOUT in the end - see the exec 3>&1 command) and assigns the entered data (returned through STDERR, then redirected to STDOUT) to the Bash variable result.
```
exitcode=$?
```
This code retrieves the previously executed command's exit code (here from dialog) through the reserved Bash variable $? (always holds the last exit code) and simply stores it in our own Bash variable exitcode. It can be read through $exitcode again. You can search for more info on this in man bash, but that might take a while...
```
exec 3>&-
```
The Bash built-in exec can be used to apply a stream redirection to the shell, that means it affects all following commands. For more info, run help exec in your terminal.

In this special case, the stream 3 gets redirected to "stream -", which just means it should be closed. Data sent to stream 3 will not get redirected anywhere any more from now on.
```
echo $result $exitcode
```
This simple echo command (more info on man echo) just prints the content of the two Bash variables result and exitcode to the STDOUT. As we have no explicit or implicit stream redirections here any more, they will really appear on STDOUT and therefore simply get displayed in the terminal. What a miracle! ;-)

Summary:

First, we set the shell up to redirect everything we send to the custom stream 3 back to STDOUT, so that it shows up in our terminal.

Then we run the dialog command, redirect its original STDOUT to our custom stream 3, because it needs to get displayed in the end, but we temporarily need to use the STDOUT stream for something else.
We redirect the original STDERR of the command, where the dialogue window's user input gets returned, to STDOUT afterwards.
Now we can capture the STDOUT (which holds the redirected data from STDERR) and store it in our variable $result. It contains the wanted user input now!

We also want the dialog command's exit code, which shows us whether OK or CANCEL was clicked. This value is presented in the reserved Bash variable $? and we just copy it to our own variable $exitcode.

After that we close stream 3 again, as we don't need it any more, to stop further redirections of it.

Finally, we normally output the contents of both variables $result (the user input of the dialogue window) and $exitcode (0 for OK, 1 for CANCEL) to the terminal.

Related Solutions

Ubuntu – How to get bash file to echo differently based on user input

The main problem is here:

read $input

In bash, usually, $foo is the value of the variable foo. Here, you don't want the value, but the name of the variable, so it should be just:

read input

Similarly, in the if tests, $yes and $no should be just yes and no, since you just want the strings yes and no there.

You could use a case statement here, which (IMHO) makes it easier to do multiple cases based on input:

case $input in
[Yy]es)    # The first character can be Y or y, so both Yes and yes work
    echo "Hello!"  
    echo "Hello!" | festival --tts
    ;;
[Nn]o)     # no or No
    echo "Are you sure?"
    echo "Are you sure?" | festival --tts
    ;;
*)         # Anything else
    echo "Please answer yes or no."
    echo "Please answer yes or no." | festival --tts
    ;;
esac

You could wrap the two echo statements and the use of festival in a function to avoid repeating yourself:

textAndSpeech ()
{
    echo "$@"
    echo "$@" | festival --tts
}
case $input in
[Yy]es)    # The first character can be Y or y, so both Yes and yes work
    textAndSpeech "Hello!"  
    ;;
[Nn]o)     # no or No
    textAndSpeech "Are you sure?"
    ;;
*)         # Anything else
    textAndSpeech "Please answer yes or no."
    ;;
esac

With $input, bash replaces this with its value, which is nothing initially, so the read command run is:

read

And read by default stores the input in the variable REPLY. So you can, if you want, eliminate the input variable altogether and use $REPLY instead of $input.

Also have a look at the select statement in Bash.

Ubuntu – Create bash script that allows you to choose multiple options instead of just one

From the discussion in the comments it is apparent that your main concern is to create as script with multiple selections, rather than focus on copying/moving files themselves, and the file operations are just an example. This functionality can be achieved via dialog command, which allows creating text user interfaces, with --checklist flag specifically; however there's nothing in the standard shell-only toolbox to achieve what you want. Hence, dialog is an appropriate tool for this job.

Below you will find an example script. While the script implements only 3 options that were discussed, it provides a decent starting point which users can extent further, and also addresses mutually exclusive options as mentioned in the comments. Particularly, the multiple selection is addressed in menu() function, which serves as a wrapper for dialog with --checklist option

To keep things simple, all you really need is this:

output=$(dialog --clear --backtitle "Backtitle. Use <SPACE> to select." --title "My Dialog" \
       --checklist "Select all that apply"  50 50 100 \
       checksum "SHA-256" off \
       copy "Copy only (exclusive with move)" off \
       move "Move only (exclusive with copy)" off 2>&1 > /dev/tty)

This saves the selection of multiple items to variable $output. Note that `2>&1 > /dev/tty) at the end are crucial to saving the return value into variable. But see the script below for more practical example:

#!/bin/bash

puke(){
    # function to exit with specific error message
    # analogous to 'die' in Perl
    printf ">>> Errors were encountered: %s\n" "$1" && exit
} > /dev/stderr

menu(){
    # dialog --help documents the option as follows:
    # --checklist    <text> <height> <width> <list height> <tag1> <item1> <status1>...
    # tags are what the output returns.
    # We can use word-splitting 
    # and iterate over output of this function in order. Of course first option
    # being checksum will always work and is not mutually exclusive with anything else
    dialog --clear --backtitle "Backtitle. Use <SPACE> to select." --title "My Dialog" \
           --checklist "Select all that apply"  50 50 100 \
           checksum "SHA-256" off \
           copy "Copy only (exclusive with move)" off \
           move "Move only (exclusive with copy)" off || puke

} 2>&1 1>/dev/tty

select_file(){
    dialog --backtitle "Choose file by typing or navigating and selecting with <SPACE>" --fselect "/etc/" \
           20 50  || puke
} 2>&1 1>/dev/tty


iter_actions(){
    # variables are available to child functions
    # Since we call iter_actions in main(), this
    # function also knows about main's variable $fselect

    for i ; do 
       case "$i" in
           checksum) sha256sum "$fselect" ;;
           copy) cp "$fselect" /tmp ;;
           move) mv "$fselect" /tmp ;;
       esac
    done
}

main(){
    # here I'm using /etc but you can use $PWD to default to user's 
    # current working directory, or accept positional parameters from command-line
    # as in $1, $2 and so forth
    fselect=$( select_file "/etc" )
    actions=$(menu) 
    printf "\r%b" "\033c" # this clear the screen

    case "$actions" in
       *copy*move|*move*copy) puke "Mutually exclusive options selected" ;;
        *) iter_actions $actions ;; # note here variable is unquoted on purpose
    esac
}

# script entry point
main "$@"