lib/shell.c

   1 /*
   2    Provides a functions for working with shell.
   3
   4    Copyright (C) 2006-2024
   5    Free Software Foundation, Inc.
   6
   7    Written by:
   8    Slava Zanko <slavazanko@gmail.com>, 2015.
   9
  10    This file is part of the Midnight Commander.
  11
  12    The Midnight Commander is free software: you can redistribute it
  13    and/or modify it under the terms of the GNU General Public License as
  14    published by the Free Software Foundation, either version 3 of the License,
  15    or (at your option) any later version.
  16
  17    The Midnight Commander is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24  */
  25
  26 /** \file shell.c
  27  *  \brief Source: provides a functions for working with shell.
  28  */
  29
  30 #include <config.h>
  31
  32 #include <pwd.h>                /* for username in xterm title */
  33 #include <stdarg.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36
  37 #include "global.h"
  38 #include "util.h"
  39
  40 /*** global variables ****************************************************************************/
  41
  42 /*** file scope macro definitions ****************************************************************/
  43
  44 /*** file scope type declarations ****************************************************************/
  45
  46 /*** forward declarations (file scope functions) *************************************************/
  47
  48 /*** file scope variables ************************************************************************/
  49
  50 static char rp_shell[PATH_MAX];
  51
  52 /* --------------------------------------------------------------------------------------------- */
  53 /*** file scope functions ************************************************************************/
  54 /* --------------------------------------------------------------------------------------------- */
  55 /**
  56  * Get a system shell.
  57  *
  58  * @return newly allocated mc_shell_t object with shell name
  59  */
  60
  61 static mc_shell_t *
  62 mc_shell_get_installed_in_system (void)
  63 {
  64     mc_shell_t *mc_shell;
  65
  66     mc_shell = g_new0 (mc_shell_t, 1);
  67
  68     /* 3rd choice: look for existing shells supported as MC subshells.  */
  69     if (access ("/bin/bash", X_OK) == 0)
  70         mc_shell->path = g_strdup ("/bin/bash");
  71     else if (access ("/bin/ash", X_OK) == 0)
  72         mc_shell->path = g_strdup ("/bin/ash");
  73     else if (access ("/bin/dash", X_OK) == 0)
  74         mc_shell->path = g_strdup ("/bin/dash");
  75     else if (access ("/bin/busybox", X_OK) == 0)
  76         mc_shell->path = g_strdup ("/bin/busybox");
  77     else if (access ("/bin/zsh", X_OK) == 0)
  78         mc_shell->path = g_strdup ("/bin/zsh");
  79     else if (access ("/bin/tcsh", X_OK) == 0)
  80         mc_shell->path = g_strdup ("/bin/tcsh");
  81     else if (access ("/bin/csh", X_OK) == 0)
  82         mc_shell->path = g_strdup ("/bin/csh");
  83     /* No fish as fallback because it is so much different from other shells and
  84      * in a way exotic (even though user-friendly by name) that we should not
  85      * present it as a subshell without the user's explicit intention. We rather
  86      * will not use a subshell but just a command line.
  87      * else if (access("/bin/fish", X_OK) == 0)
  88      *     mc_global.tty.shell = g_strdup ("/bin/fish");
  89      */
  90     else
  91         /* Fallback and last resort: system default shell */
  92         mc_shell->path = g_strdup ("/bin/sh");
  93
  94     return mc_shell;
  95 }
  96
  97 /* --------------------------------------------------------------------------------------------- */
  98
  99 static char *
 100 mc_shell_get_name_env (void)
 101 {
 102     const char *shell_env;
 103     char *shell_name = NULL;
 104
 105     shell_env = g_getenv ("SHELL");
 106     if ((shell_env == NULL) || (shell_env[0] == '\0'))
 107     {
 108         /* 2nd choice: user login shell */
 109         struct passwd *pwd;
 110
 111         pwd = getpwuid (geteuid ());
 112         if (pwd != NULL)
 113             shell_name = g_strdup (pwd->pw_shell);
 114     }
 115     else
 116         /* 1st choice: SHELL environment variable */
 117         shell_name = g_strdup (shell_env);
 118
 119     return shell_name;
 120 }
 121
 122 /* --------------------------------------------------------------------------------------------- */
 123
 124 static mc_shell_t *
 125 mc_shell_get_from_env (void)
 126 {
 127     mc_shell_t *mc_shell = NULL;
 128
 129     char *shell_name;
 130
 131     shell_name = mc_shell_get_name_env ();
 132
 133     if (shell_name != NULL)
 134     {
 135         mc_shell = g_new0 (mc_shell_t, 1);
 136         mc_shell->path = shell_name;
 137     }
 138
 139     return mc_shell;
 140 }
 141
 142 /* --------------------------------------------------------------------------------------------- */
 143
 144 static void
 145 mc_shell_recognize_real_path (mc_shell_t *mc_shell)
 146 {
 147     if (strstr (mc_shell->path, "/zsh") != NULL || strstr (mc_shell->real_path, "/zsh") != NULL
 148         || getenv ("ZSH_VERSION") != NULL)
 149     {
 150         /* Also detects ksh symlinked to zsh */
 151         mc_shell->type = SHELL_ZSH;
 152         mc_shell->name = "zsh";
 153     }
 154     else if (strstr (mc_shell->path, "/tcsh") != NULL
 155              || strstr (mc_shell->real_path, "/tcsh") != NULL)
 156     {
 157         /* Also detects csh symlinked to tcsh */
 158         mc_shell->type = SHELL_TCSH;
 159         mc_shell->name = "tcsh";
 160     }
 161     else if (strstr (mc_shell->path, "/csh") != NULL
 162              || strstr (mc_shell->real_path, "/csh") != NULL)
 163     {
 164         mc_shell->type = SHELL_TCSH;
 165         mc_shell->name = "csh";
 166     }
 167     else if (strstr (mc_shell->path, "/fish") != NULL
 168              || strstr (mc_shell->real_path, "/fish") != NULL)
 169     {
 170         mc_shell->type = SHELL_FISH;
 171         mc_shell->name = "fish";
 172     }
 173     else if (strstr (mc_shell->path, "/dash") != NULL
 174              || strstr (mc_shell->real_path, "/dash") != NULL)
 175     {
 176         /* Debian ash (also found if symlinked to by ash/sh) */
 177         mc_shell->type = SHELL_DASH;
 178         mc_shell->name = "dash";
 179     }
 180     else if (strstr (mc_shell->real_path, "/busybox") != NULL)
 181     {
 182         /* If shell is symlinked to busybox, assume it is an ash, even though theoretically
 183          * it could also be a hush (a mini shell for non-MMU systems deactivated by default).
 184          * For simplicity's sake we assume that busybox always contains an ash, not a hush.
 185          * On embedded platforms or on server systems, /bin/sh often points to busybox.
 186          * Sometimes even bash is symlinked to busybox (CONFIG_FEATURE_BASH_IS_ASH option),
 187          * so we need to check busybox symlinks *before* checking for the name "bash"
 188          * in order to avoid that case. */
 189         mc_shell->type = SHELL_ASH_BUSYBOX;
 190         mc_shell->name = mc_shell->path;
 191     }
 192     else
 193         mc_shell->type = SHELL_NONE;
 194 }
 195
 196 /* --------------------------------------------------------------------------------------------- */
 197
 198 static void
 199 mc_shell_recognize_path (mc_shell_t *mc_shell)
 200 {
 201     /* If shell is not symlinked to busybox, it is safe to assume it is a real shell */
 202     if (strstr (mc_shell->path, "/bash") != NULL || getenv ("BASH") != NULL)
 203     {
 204         mc_shell->type = SHELL_BASH;
 205         mc_shell->name = "bash";
 206     }
 207     else if (strstr (mc_shell->path, "/sh") != NULL || getenv ("SH") != NULL)
 208     {
 209         mc_shell->type = SHELL_SH;
 210         mc_shell->name = "sh";
 211     }
 212     else if (strstr (mc_shell->path, "/ash") != NULL || getenv ("ASH") != NULL)
 213     {
 214         mc_shell->type = SHELL_ASH_BUSYBOX;
 215         mc_shell->name = "ash";
 216     }
 217     else
 218         mc_shell->type = SHELL_NONE;
 219 }
 220
 221 /* --------------------------------------------------------------------------------------------- */
 222 /*** public functions ****************************************************************************/
 223 /* --------------------------------------------------------------------------------------------- */
 224
 225 void
 226 mc_shell_init (void)
 227 {
 228     mc_shell_t *mc_shell;
 229
 230     mc_shell = mc_shell_get_from_env ();
 231
 232     if (mc_shell == NULL)
 233         mc_shell = mc_shell_get_installed_in_system ();
 234
 235     mc_shell->real_path = mc_realpath (mc_shell->path, rp_shell);
 236
 237     /* Find out what type of shell we have. Also consider real paths (resolved symlinks)
 238      * because e.g. csh might point to tcsh, ash to dash or busybox, sh to anything. */
 239
 240     if (mc_shell->real_path != NULL)
 241         mc_shell_recognize_real_path (mc_shell);
 242
 243     if (mc_shell->type == SHELL_NONE)
 244         mc_shell_recognize_path (mc_shell);
 245
 246     if (mc_shell->type == SHELL_NONE)
 247         mc_global.tty.use_subshell = FALSE;
 248
 249     mc_global.shell = mc_shell;
 250 }
 251
 252 /* --------------------------------------------------------------------------------------------- */
 253
 254 void
 255 mc_shell_deinit (void)
 256 {
 257     if (mc_global.shell != NULL)
 258     {
 259         g_free (mc_global.shell->path);
 260         MC_PTR_FREE (mc_global.shell);
 261     }
 262 }
 263
 264 /* --------------------------------------------------------------------------------------------- */