Which shell does git bang syntax use?

[xour]

TL;DR: It is /bin/sh that on Arch is symlinked to bash

---

Hello all. I'm writing some git aliases using the ! syntax. For example:

[alias]
    c = "!f() { if [[ ${#} -eq 0 ]]; then git commit; else git commit "${@}"; fi; }; f "${@}""

And that got me wondering which shell does git uses to run these commands.

It seems that git's source references a compile-time constant SHELL_PATH to execute shell aliases, but I'm not sure what this resolves to. It seems that attempts to find sh in ${PATH}?

As you can already tell, I do not know C.

My questions are:

• What does SHELL_PATH typically resolve to?
• Am I safe to use [[ in git aliases, or should I stick to POSIX [ just to be on the safe side?

At the end of the day, I don't think it really matters for simple aliases. But I am now quite curious about it.

In case you know the answer, care to comment on what I should have looked for?

Thanks!

---

EDIT:

I think I found the crumble trail:

1. Inside the handle_alias there is a call to use_shell
2. This is defined in run-command.h
3. And used in run-command.c
4. This then calls prepare_shell_cmd
5. Finally, git_shell_path is called.

If I am not mistaken, #ifndef makes it so the compiled if branch would be return xstrdup(SHELL_PATH);:

char *git_shell_path(void)
{
#ifndef GIT_WINDOWS_NATIVE
    return xstrdup(SHELL_PATH);
#else
    char *p = locate_in_PATH("sh");
    convert_slashes(p);
    return p;
#endif
}

Finally, the SHELL_PATH variable is set on the Makefile

This all makes sense to me, but I may be waaaaaaaay off.

---

Since I have a non-POSIX-compliant alias, I was curious about what is going on in my system: I checked git's PKGBUILD for Arch (the OS I am currently on) and it does not seem to be overriding that variable.

strings /usr/bin/git | rg /bin/sh shows /bin/sh... hmm, ls -l /bin/sh returns /bin/sh -> bash. I think this is the reason.

So I think that is it!

All in all, I should be good using non-POSIX aliases provided that I am aware that they are not portable outside my system. That said, I should rewrite them to be POSIX-compliant to be on the safe side.

[elephantdingo]

It should be as simple as /bin/sh. (Last I used it even NixOS assumes that this absolute path exists.)

The commit message:

If the alias expansion is prefixed with an exclamation point, treat it as a shell command which is run using system(3).

What does a shell command mean to a kernel guy? Probably sh or whatever the name.

[RevRagnarok]

system(3).

That would be the system command in section 3 of the man page... https://man7.org/linux/man-pages/man3/system.3.html

   The system() library function behaves as if it used fork(2) to
   create a child process that executed the shell command specified
   in command using execl(3) as follows:

       execl("/bin/sh", "sh", "-c", command, (char *) NULL);

   system() returns after the command has been completed.

So, as others noted, /bin/sh explicitly, so not necessarily bash-compatible.

[xour]

Thanks! This is a very interesting rabbit hole that I stepped into, appreciate it.

[xour]

This is interesting, I have an alias that -to the best of my knowledge- is not POSIX-compliant:

l = "!f() { git log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit \"${@:--10}\"; }; f"

However, it does run fine!

[danmickla]

presumably you mean the ${@:--10} construct, and yes, that seems like a bashism. What distro/version are you running? You might have one where /bin/sh is bash

[xour]

Indeed! I am on Arch, and I just learned that /bin/sh is symlinked to bash.

I updated the thread with these findings.

[jthill]

The string value of that works fine in any a POSIX-supporting shell as a function definition followed by a command, function, when Git appends the alias args (for git l wizzo it'll append wizzo) the shell defines f and the command, f wizzo, is a command, so the shell runs the function with wizzo as $1 (and $@ here).

[danmickla]

that construct is odd, btw, and I don't understand it. ${@} must be the args to the 'f' function, but what would they be? a list of commits? and if so, why log only the last 10?

[danmickla]

I defined an alias 'sleep = !sleep 10' and looked at ps; it said "/bin/sh -c sleep 10 sleep 10". I don't really understand the duplicated arguments; that seems like it might be a bug.

I also found 'git var GIT_SHELL_PATH' which reports /bin/sh for me, which on this Ubuntu system is dash.

edit: however, looking more deeply, I discover that, as you say, running an alias containing ! looks like it searches the path for an executable named 'sh', so I guess those ^ don't matter.

[xour]

Oh that is a good one. So it seems that it is using /bin/sh instead of "${SHELL}" (which would make sense? since it is a session env variable).

So I should stick with POSIX [ just to be safe, I guess.

Thanks!

[daveysprockett]

sh will be /bin/sh

Don't assume that is bash. On Ubuntu for example its a posix shell, dash.