determine shell in script during runtime

Question

As per my knowledge, to determine the current shell we use echo $0 in the shell. Rather I want my script to check in which shell it is running. So, I tried to print $0 in the script and it returns the name of the script as it should. So, my question is how can I find which shell is my script running in during runtime?

Answer 1

Maybe not what you're asking for, but this should work to some extent to identify the interpreter currently interpreting it for a few like

1. Thompson shell (osh),
2. Bourne shell,
3. Bourne-again shell (bash),
4. Korn shell (ksh88, ksh93, pdksh, mksh),
5. zsh,
6. Policy-compliant Ordinary shell (posh),
7. Yet Another shell (yash),
8. rc shell,
9. akanga shell,
10. es shell,
11. wish TCL interpreter,
12. tclsh TCL interpreter,
13. expect TCL interpreter,
14. Perl,
15. Python,
16. Ruby,
17. PHP,
18. JavaScript (nodejs, SpiderMonkey shell and JSPL at least)
19. MS/Wine cmd.exe, command.com (MSDOS, FreeDOS...).

'echo' +"'[{<?php echo chr(13)?>php <?php echo PHP_VERSION.chr(10);exit;?>}\
@GOTO DOS [exit[set 1 [[set 2 package] names];set 3 Tcl\ [info patchlevel];\
if {[lsearch -exact $1 Expect]>=0} {puts expect\ [$2 require Expect]\ ($3)} \
elseif {[lsearch -exact $1 Tk]>=0} {puts wish\ ($3,\ Tk\ [$2 require Tk])} \
else {puts $3}]]]' >/dev/null ' {\">/dev/null \
">"/dev/null" +"\'";q="#{",1//2,"}";a=+1;q='''=.q,';q=%{\"
'echo' /*>/dev/null
echo ">/dev/null;status=0;@ {status=1};*=(" '$' ");~ $status 1&&{e='"\
"';eval catch $2 ^'&version {eval ''echo <='^ $2 ^'&version''}';exit};e='"\
"';if (eval '{let ''a^~a''} >[2] /dev/null'){e='"\
"';exec echo akanga};eval exec echo rc $2 ^ version;\" > /dev/null
: #;echo possibly pre-Bourne UNIX V1-6 shell;exit
if (! $?version) set version=csh;exec echo $version
:DOS
@CLS
@IF NOT "%DOSEMU_VERSION%"=="" ECHO DOSEMU %DOSEMU_VERSION%
@ECHO %OS% %COMSPEC%
@VER
@GOTO FIN
", unless eval 'printf "perl %vd\n",$^V;exit;'> "/dev/null";eval ': "\'';
=S"';f=false e=exec\ echo n=/dev/null v=SH_VERSION;`(eval "f() { echo :
};f")2>$n` $f||$e Bourne-like shell without function
case `(: ${_z_?1}) 2>&1` in 1) $e ash/BSD sh;;esac;t(){
eval "\${$1$v+:} $f &&exec echo ${2}sh \$$1$v";};t BA ba;t Z z;t PO po;t YA ya
case `(typeset -Z2 b=0;$e $b)2>$n` in 00) (eval ':${.}')2>$n&&eval '
$e ksh93 ${.sh.version}';t K pdk;$e ksh88;;esac;case `(eval '$e ${f#*s}$($e 1
)$((1+1))')2>$n` in e12)$e POSIX shell;;esac;$e Bourne-like shell;: }
print "ruby ",RUBY_VERSION,"\n";exit;' ''';import sys
print("python "+sys.version);z='''*/;
s="";j="JavaScript";if(typeof process=="object"){p=console.log;p(process.title
,process.version)}else{p=print;p((f="function")==(t=typeof version)?"string"==
typeof(v=version())?v:(typeof build!=f?"":s= "SpiderMonkey ")+j+" "+v:(t==
"undefined"?j+"?":version)+"\n");if(s)build()}/*
:FIN } *///'''

I posted the initial version of that which_interpreter script circa 2004 on usenet. Sven Mascheck has a (probably more useful to you) script called whatshell that focuses on identifying Bourne-like shells. You can also find a merged version of our two scripts there.

Answer 2

On linux you can use /proc/PID/exe.

Example:

# readlink /proc/$$/exe
/bin/zsh

Answer 3

This is what I use in my .profile to check for various shells on the systems I work on. It doesn't make fine distinctions between ksh88 and ksh93, but it has never failed me.

Note that it doesn't require a single fork or pipe.

# Determine what (Bourne compatible) shell we are running under. Put the result
# in $PROFILE_SHELL (not $SHELL) so further code can depend on the shell type.

if test -n "$ZSH_VERSION"; then
  PROFILE_SHELL=zsh
elif test -n "$BASH_VERSION"; then
  PROFILE_SHELL=bash
elif test -n "$KSH_VERSION"; then
  PROFILE_SHELL=ksh
elif test -n "$FCEDIT"; then
  PROFILE_SHELL=ksh
elif test -n "$PS3"; then
  PROFILE_SHELL=unknown
else
  PROFILE_SHELL=sh
fi

Answer 4

You could try

ps -o args= -p "$$"

which will give you the name of the command associated with the script's pid.

Answer 5

If there is the lsof command available on your system, you can get the full path of the parent shell executable by getting the parent PID via ps and parsing the ouput of lsof -p $ppid (see How to determine the current shell i'm working on?).

#!/bin/sh
ppid="`ps -p "$$" -o ppid=`"
lsof -nP -p "$ppid" | awk 'NR==3 {print $NF; exit}'

Answer 6

Portable solution (tested in Linux and MacOS):

ps -o args= -p $$ | egrep -m 1 -o '\w{0,5}sh'

where:

• ps -o args= retrieves the command line arguments
• $$ gives you the current PID
• -m 1 to finish searching after the first match
• -o to only display matching portion
• \w{0,5}sh regular expression to find things like bash in /bin/bash or ksh in -ksh or sh in sh (Maximum 5 characters+sh)

Answer 7

Outside of Linux land or lacking access to the /proc filesystem or equivelent, you can make use of pstree:

Assuming you have the pid of

On a Mac:

./test.sh 
16012
-+= 00001 root /sbin/launchd
 \-+= 00245 wingwong /sbin/launchd
   \-+= 04670 wingwong /Applications/Utilities/Terminal.app/Contents/MacOS/Terminal -psn_0_2052597
     \-+= 11816 root login -pf wingwong
       \-+= 11817 wingwong -bash
         \-+= 16012 wingwong ksh ./test.sh
           \-+- 16013 wingwong pstree -p 16012

On a Linux box:

./test.sh 
14981
bash(14981)---pstree(14982)

The format and style of the output from pstree differs, depending on your environment, but you can enforce ASCII output and then sed/tr/awk/etc. filter the output to get the shell that is running the script.

So a cleaned up output version(works for Mac or Linux OS runs):

#!/usr/bin/env sh
pstree  -p $$  | tr ' ()' '\012\012\012' | grep -i "sh$" | grep -v "$0" | tail -1

On run yields:

./test.sh 
sh

And when run with a different shell:

#!/usr/bin/env ksh
pstree  -p $$  | tr ' ()' '\012\012\012' | grep -i "sh$" | grep -v "$0" | tail -1

Yields:

./test.sh 
ksh

No root or special filesystem required. Note, my filtering assumes that the shell binary name ends with sh and that there are no intermediate entries which end with sh. Also assumes that you didn't name your script "sh" or some unfortunate grep pattern that will obliterate information. :) Will require some customization for your own environment to ensure a higher degree of foolproofing.

Answer 8

You can use the command:

$ echo $SHELL

to find out the shell from within the script.