8

I'm writing a bash script and it throws an error when using "sh" command in Ubuntu (it seems it's not compatible with dash, I'm learning on this subject). So I would like to detect if dash is being used instead of bash to throw an error.

How can I detect it in a script context?. Is it even possible?

Roger W.
  • 327
  • 1
  • 4
  • 15
  • 3
    What you can do is to define the interpreter in the first line of your script: `#!/bin/bash` will make it be executed with `/bin/bash` when called with `./script.sh`. Also, good to see Pink Floyd around :) – fedorqui Apr 11 '14 at 11:31
  • Where are you playing live next? – devnull Apr 11 '14 at 11:46
  • `bash`'s features are a _superset_ of `dash`'s features; `dash` is smaller and faster, but is mostly limited to POSIX features - see https://en.wikipedia.org/wiki/Debian_Almquist_shell – mklement0 Apr 11 '14 at 11:49

4 Answers4

13

You can check for the presence of shell-specific variables:

For instance, bash defines $BASH_VERSION. Since that variable won't be defined while running in dash, you can use it to make the distinction:

[ -n "$BASH_VERSION" ] && isBash=1

Afterthought: If you wanted to avoid relying on variables (which, conceivably, could be set incorrectly), you could try to obtain the ultimate name of the shell executable running your script, by determining the invoking executable and, if it is a symlink, following it to its (ultimate) target.

The shell function getTrueShellExeName() below does that; for instance, it would return 'dash' on Ubuntu for a script run with sh (whether explicitly or via shebang #!/bin/sh), because sh is symlinked to dash there.

Note that the function's goal is twofold:

  • Be portable:
    • Work with all POSIX-compatible (Bourne-like) shells,
    • across at least most platforms, with respect to what utilities and options are used - see caveats below.
  • Work in all invocation scenarios:
    • sourced (whether from a login shell or not)
    • executed stand-alone, via the shebang line
    • executed by being passed as a filename argument to a shell executable
    • executed by having its contents piped via stdin to a shell executable

Caveats:

  • On at least one platform - macOS - sh is NOT a symlink, even though it is effectively bash. There, the function would return 'sh' in a script run with sh.

  • The function uses readlink, which, while not mandated by POSIX, is present on most modern platforms - though with differing syntax and features. Therefore, using GNU readlink's -f option to find a symlink's ultimate target is not an option.
    (The only modern platform I'm personally aware of that does not have a readlink utility is HP-UX - see https://stackoverflow.com/a/24114056/45375 for a recursive-readlink implementation that should work on all POSIX platforms.)

  • The function uses the which utility (except in zsh, where it's a builtin), which, while not mandated by POSIX, is present on most modern platforms.

  • Ideally, ps -p $$ -o comm= would be sufficient to determine the path of the executable underlying the process, but that doesn't work as intended when directly executing shell scripts with shebang lines on Linux, at least when using the ps implementation from the procps-ng package, as found on Ubuntu, for instance: there, such scripts report the script's file name rather than the underlying script engine's.Tip of the hat to ferdymercury for his help.
    Therefore, the content of special file /proc/$$/cmdline is parsed on Linux, whose first NUL-separated field contains the true executable path.

Example use of the function:

[ "$(getTrueShellExeName)" = 'bash' ] && isBash=1

Shell function getTrueShellExeName():

getTrueShellExeName() {
  local trueExe nextTarget 2>/dev/null # ignore error in shells without `local`
  # Determine the shell executable filename.
  if [ -r /proc/$$/cmdline ]; then
    trueExe=$(cut -d '' -f1 /proc/$$/cmdline) || return 1
  else
    trueExe=$(ps -p $$ -o comm=) || return 1
  fi
  # Strip a leading "-", as added e.g. by macOS for login shells.
  [ "${trueExe#-}" = "$trueExe" ] || trueExe=${trueExe#-}
  # Determine full executable path.
  [ "${trueExe#/}" != "$trueExe" ] || trueExe=$([ -n "$ZSH_VERSION" ] && which -p "$trueExe" || which "$trueExe")
  # If the executable is a symlink, resolve it to its *ultimate*
  # target.
  while nextTarget=$(readlink "$trueExe"); do trueExe=$nextTarget; done
  # Output the executable name only.
  printf '%s\n' "$(basename "$trueExe")"
}
mklement0
  • 382,024
  • 64
  • 607
  • 775
  • You can use `readlink -f` to get the ultimate destination of a symlink, so in a sourced shell script (started with `. ./script`) one could use `BIN="$(readlink -f $0)"; BIN="${BIN##*/}"` to get the name of the shell without its path. In an executed script (started with `./script`) one would have to extract the shebang, and follow that for symlinks... – zrajm Jul 23 '14 at 23:57
  • @zrajm: The purpose of my shell function is twofold: (a) be _portable_ and (b) work in _all_ invocation scenarios. I've updated my answer to clarify. Your suggestion doesn't satisfy (a), because `readlink -f` is a GNU extension that doesn't work on OSX, for instance. It doesn't satisfy (b), because analyzing the shebang line is insufficient - for instance, your script could have been passed as a direct argument to _any_ shell executable instead. – mklement0 Jul 24 '14 at 02:15
  • @zrajm: Furthermore, there is no simple, shell-neutral way that I know of to determine if a script is being _sourced_ (do tell me if you know a way). Also, OSX, for instance, prepends `-` to the shell executable name reported in `$0` in a login shell (on OSX, all shells created in a terminal are login shells), so you'd have to account for that (that's the easy part). – mklement0 Jul 24 '14 at 02:19
  • Good idea, @ferdymercury - thanks; answer updated. – mklement0 Apr 26 '22 at 13:40
5

Use $0 (that is the name of the executable of the shell being called).The command for example

echo $0

gives 

/usr/bin/dash

for the dash and 

/bin/bash

for a bash.The parameter substitution 

${0##*/}

gives just 'dash' or 'bash'. This can be used in a test.

Fritz G. Mehner
  • 16,550
  • 2
  • 34
  • 41
  • 2
    This isn't reliable. What if the script is executable and invoked as `./script`? What if the script is sourced? – kojiro Apr 11 '14 at 15:07
  • $0 is set to an arbitrary string by whatever invokes the shell. It's _almost_ always right... – jthill Apr 11 '14 at 15:14
2

An alternative approach might be to test if a shell feature is available, for example to give an idea...

[[ 1 ]] 2>/dev/null && echo could be bash || echo not bash, maybe dash
Scrutinizer
  • 9,608
  • 1
  • 21
  • 22
-1
echo $0 and [[ 1 ]] 2>/dev/null && echo

could be bash || echo not bash, maybe bash worked for me running Ubuntu 19.

Done slight Pascal, Fortran and C in school, but need to become fluent in shell script.

Lore
  • 1,286
  • 1
  • 22
  • 57
DonaldA
  • 1