15 files changed, 333 insertions, 155 deletions

diff --git a/src/faudit/dbus.c b/src/faudit/dbus.c
index 1edce5802..64f5d8ae4 100644
--- a/src/faudit/dbus.c
+++ b/src/faudit/dbus.c
@@ -63,8 +63,6 @@ void dbus_test(void) {
                         if (ptr)
                                 *ptr = '\0';    
                         check_session_bus(sockfile);
-                        
-                        sockfile -= 13;
                 }
                 free(bus);
         }
diff --git a/src/firejail/bandwidth.c b/src/firejail/bandwidth.c
index 34c5ca509..5ff67b644 100644
--- a/src/firejail/bandwidth.c
+++ b/src/firejail/bandwidth.c
@@ -459,13 +459,15 @@ void bandwidth_pid(pid_t pid, const char *command, const char *dev, int down, in
         if (setregid(0, 0))
                 errExit("setregid");
 
+        assert(cfg.shell);
+
         char *arg[4];
-        arg[0] = "/bin/bash";
+        arg[0] = cfg.shell;
         arg[1] = "-c";
         arg[2] = cmd;
         arg[3] = NULL;
-        execvp("/bin/bash", arg);
+        execvp(arg[0], arg);
         
         // it will never get here
-        exit(0);                
+        errExit("execvp");
 }
diff --git a/src/firejail/checkcfg.c b/src/firejail/checkcfg.c
index 3b60dafb6..019b54773 100644
--- a/src/firejail/checkcfg.c
+++ b/src/firejail/checkcfg.c
@@ -50,7 +50,7 @@ int checkcfg(int val) {
                 FILE *fp = fopen(fname, "r");
                 if (!fp) {
 #ifdef HAVE_GLOBALCFG                   
-                        fprintf(stderr, "Warning: Firejail configuration file %s not found\n", fname);
+                        fprintf(stderr, "Error: Firejail configuration file %s not found\n", fname);
                         exit(1);
 #else
                         initialized = 1;
@@ -317,7 +317,7 @@ void print_compiletime_support(void) {
 #endif
                 );
 
-        printf("\t- X11 snadboxing support is %s\n",
+        printf("\t- X11 sandboxing support is %s\n",
 #ifdef HAVE_X11
                 "enabled"
 #else
diff --git a/src/firejail/cmdline.c b/src/firejail/cmdline.c
index 48cbaffb7..cadf4795d 100644
--- a/src/firejail/cmdline.c
+++ b/src/firejail/cmdline.c
@@ -26,7 +26,9 @@
 #include <assert.h>
 #include <errno.h>
 
-int cmdline_length(int argc, char **argv, int index) {
+static int cmdline_length(int argc, char **argv, int index) {
+        assert(index != -1);
+        
         unsigned i,j;
         int len = 0;
         unsigned argcnt = argc - index;
@@ -62,7 +64,9 @@ int cmdline_length(int argc, char **argv, int index) {
         return len;
 }
 
-void quote_cmdline(char *command_line, char *window_title, int len, int argc, char **argv, int index) {
+static void quote_cmdline(char *command_line, char *window_title, int len, int argc, char **argv, int index) {
+        assert(index != -1);
+
         unsigned i,j;
         unsigned argcnt = argc - index;
         bool in_quotes = false;
@@ -131,6 +135,10 @@ void quote_cmdline(char *command_line, char *window_title, int len, int argc, ch
 }
 
 void build_cmdline(char **command_line, char **window_title, int argc, char **argv, int index) {
+        // index == -1 could happen if we have --shell=none and no program was specified
+        // the program should exit with an error before entering this function
+        assert(index != -1);
+
         int len = cmdline_length(argc, argv, index);
         if (len > ARG_MAX) {
                 errno = E2BIG;
diff --git a/src/firejail/env.c b/src/firejail/env.c
index 79d6b81e3..c05abadca 100644
--- a/src/firejail/env.c
+++ b/src/firejail/env.c
@@ -121,19 +121,16 @@ void env_defaults(void) {
                 errExit("setenv");
         if (setenv("container", "firejail", 1) < 0) // LXC sets container=lxc,
                 errExit("setenv");
-        if (arg_zsh && setenv("SHELL", "/usr/bin/zsh", 1) < 0)
-                errExit("setenv");
-        if (arg_csh && setenv("SHELL", "/bin/csh", 1) < 0)
-                errExit("setenv");
         if (cfg.shell && setenv("SHELL", cfg.shell, 1) < 0)
                 errExit("setenv");
         // set prompt color to green
         //export PS1='\[\e[1;32m\][\u@\h \W]\$\[\e[0m\] '
-        if (setenv("PROMPT_COMMAND", "export PS1=\"\\[\\e[1;32m\\][\\u@\\h \\W]\\$\\[\\e[0m\\] \"", 1) < 0)
-                errExit("setenv");
+//      if (setenv("PROMPT_COMMAND", "export PS1=\"\\[\\e[1;32m\\][\\u@\\h \\W]\\$\\[\\e[0m\\] \"", 1) < 0)
+//              errExit("setenv");
 
         // set the window title
-        printf("\033]0;firejail %s\007", cfg.window_title);fflush(0);
+        printf("\033]0;firejail %s\007", cfg.window_title);
+        fflush(0);
 }
 
 // parse and store the environment setting 
diff --git a/src/firejail/firejail.h b/src/firejail/firejail.h
index ee70f19f1..1fed3fcdf 100644
--- a/src/firejail/firejail.h
+++ b/src/firejail/firejail.h
@@ -22,6 +22,8 @@
 #include "../include/common.h"
 #include "../include/euid_common.h"
 
+// debug restricted shell
+//#define DEBUG_RESTRICTED_SHELL
 
 // filesystem
 #define RUN_FIREJAIL_BASEDIR    "/run"
@@ -268,6 +270,7 @@ extern int arg_audit;		// audit
 extern char *arg_audit_prog;    // audit
 extern int arg_apparmor;        // apparmor
 
+extern int login_shell;
 extern int parent_to_child_fds[2];
 extern int child_to_parent_fds[2];
 extern pid_t sandbox_pid;
@@ -278,6 +281,7 @@ extern int fullargc;
 
 // main.c
 void check_user_namespace(void);
+char *guess_shell(void);
 
 // sandbox.c
 int sandbox(void* sandbox_arg);
@@ -358,7 +362,6 @@ void shut(pid_t pid);
 void shut_name(const char *name);
 
 // restricted_shell.c
-extern char *restricted_user;
 int restricted_shell(const char *user);
 
 // arp.c
diff --git a/src/firejail/fs.c b/src/firejail/fs.c
index c152abe0d..484b99537 100644
--- a/src/firejail/fs.c
+++ b/src/firejail/fs.c
@@ -1141,13 +1141,13 @@ int fs_check_chroot_dir(const char *rootdir) {
         free(name);
 
         // check /bin/bash
-        if (asprintf(&name, "%s/bin/bash", rootdir) == -1)
-                errExit("asprintf");
-        if (stat(name, &s) == -1) {
-                fprintf(stderr, "Error: cannot find /bin/bash in chroot directory\n");
-                return 1;
-        }
-        free(name);
+//      if (asprintf(&name, "%s/bin/bash", rootdir) == -1)
+//              errExit("asprintf");
+//      if (stat(name, &s) == -1) {
+//              fprintf(stderr, "Error: cannot find /bin/bash in chroot directory\n");
+//              return 1;
+//      }
+//      free(name);
 
         // check x11 socket directory
         if (getenv("FIREJAIL_X11")) {
diff --git a/src/firejail/fs_home.c b/src/firejail/fs_home.c
index c1e983c16..d328d5f1c 100644
--- a/src/firejail/fs_home.c
+++ b/src/firejail/fs_home.c
@@ -32,8 +32,9 @@
 
 static void skel(const char *homedir, uid_t u, gid_t g) {
         char *fname;
+
         // zsh
-        if (arg_zsh) {
+        if (!arg_shell_none && (strcmp(cfg.shell,"/usr/bin/zsh") == 0 || strcmp(cfg.shell,"/bin/zsh") == 0)) {
                 // copy skel files
                 if (asprintf(&fname, "%s/.zshrc", homedir) == -1)
                         errExit("asprintf");
@@ -63,7 +64,7 @@ static void skel(const char *homedir, uid_t u, gid_t g) {
                 free(fname);
         }
         // csh
-        else if (arg_csh) {
+        else if (!arg_shell_none && strcmp(cfg.shell,"/bin/csh") == 0) {
                 // copy skel files
                 if (asprintf(&fname, "%s/.cshrc", homedir) == -1)
                         errExit("asprintf");
diff --git a/src/firejail/join.c b/src/firejail/join.c
index 0b5b6a34a..632715fea 100644
--- a/src/firejail/join.c
+++ b/src/firejail/join.c
@@ -330,32 +330,15 @@ void join(pid_t pid, int argc, char **argv, int index) {
                         }
                 }
 
-                // run cmdline trough /bin/bash
+                // run cmdline trough shell
                 if (cfg.command_line == NULL) {
+                        assert(cfg.shell);
 
                         // replace the process with a shell
-                        if (cfg.shell)
-                                        execlp(cfg.shell, cfg.shell, NULL);
-                                else if (arg_zsh)
-                                        execlp("/usr/bin/zsh", "/usr/bin/zsh", NULL);
-                                else if (arg_csh)
-                                        execlp("/bin/csh", "/bin/csh", NULL);
-                                else {
-                                        struct stat s;
-                                        if (stat("/bin/bash", &s) == 0)
-                                                execlp("/bin/bash", "/bin/bash", NULL);
-                                        else if (stat("/usr/bin/zsh", &s) == 0)
-                                                execlp("/usr/bin/zsh", "/usr/bin/zsh", NULL);
-                                        else if (stat("/bin/csh", &s) == 0)
-                                                execlp("/bin/csh", "/bin/csh", NULL);
-                                        else if (stat("/bin/sh", &s) == 0)
-                                                execlp("/bin/sh", "/bin/sh", NULL);
-                                }
+                        execlp(cfg.shell, cfg.shell, NULL);
                         
-                        // no shell found, print an error and exit
-                        fprintf(stderr, "Error: no POSIX shell found\n");
-                        sleep(5);
-                        exit(1);
+                        // it should never get here
+                        errExit("execlp");
                 }
                 else {
                         // run the command supplied by the user
@@ -398,19 +381,10 @@ void join(pid_t pid, int argc, char **argv, int index) {
                                 execvp(cfg.original_argv[cfg.original_program_index], &cfg.original_argv[cfg.original_program_index]);
                                 exit(1);
                         } else {
-                                // choose the shell requested by the user, or use bash as default
-                                char *sh;
-                                if (cfg.shell)
-                                        sh = cfg.shell;
-                                else if (arg_zsh)
-                                        sh = "/usr/bin/zsh";
-                                else if (arg_csh)
-                                        sh = "/bin/csh";
-                                else
-                                        sh = "/bin/bash";
-        
+                                assert(cfg.shell);
+
                                 char *arg[5];
-                                arg[0] = sh;
+                                arg[0] = cfg.shell;
                                 arg[1] = "-c";
                                 if (arg_debug)
                                         printf("Starting %s\n", cfg.command_line);
@@ -423,7 +397,10 @@ void join(pid_t pid, int argc, char **argv, int index) {
                                         arg[3] = cfg.command_line;
                                         arg[4] = NULL;
                                 }
-                                execvp("/bin/bash", arg);
+                                execvp(arg[0], arg);
+
+                                // it should never get here
+                                errExit("execvp");
                         }
                 }
 
diff --git a/src/firejail/main.c b/src/firejail/main.c
index 120809456..8de5f9a6e 100644
--- a/src/firejail/main.c
+++ b/src/firejail/main.c
@@ -105,6 +105,7 @@ int arg_appimage = 0;				// appimage
 int arg_audit = 0;                              // audit
 char *arg_audit_prog;                           // audit
 int arg_apparmor;                               // apparmor
+int login_shell = 0;
 
 int parent_to_child_fds[2];
 int child_to_parent_fds[2];
@@ -238,7 +239,8 @@ void check_user_namespace(void) {
             stat("/proc/self/gid_map", &s3) == 0)
                 arg_noroot = 1;
         else {
-                fprintf(stderr, "Warning: user namespaces not available in the current kernel.\n");
+                if (!arg_quiet || arg_debug)
+                        fprintf(stderr, "Warning: user namespaces not available in the current kernel.\n");
                 arg_noroot = 0;
         }
 }
@@ -566,7 +568,18 @@ static void run_cmd_and_exit(int i, int argc, char **argv) {
 #endif
         else if (strncmp(argv[i], "--join=", 7) == 0) {
                 logargs(argc, argv);
-                
+
+                if (arg_shell_none) {
+                        if (argc <= (i+1)) {
+                                fprintf(stderr, "Error: --shell=none set, but no command specified\n");
+                                exit(1);
+                        }
+                        cfg.original_program_index = i + 1;
+                }
+
+                if (!cfg.shell && !arg_shell_none)
+                        cfg.shell = guess_shell();
+
                 // join sandbox by pid or by name
                 pid_t pid;
                 if (read_pid(argv[i] + 7, &pid) == 0)           
@@ -574,6 +587,7 @@ static void run_cmd_and_exit(int i, int argc, char **argv) {
                 else
                         join_name(argv[i] + 7, argc, argv, i + 1);
                 exit(0);
+
         }
 #ifdef HAVE_NETWORK     
         else if (strncmp(argv[i], "--join-network=", 15) == 0) {
@@ -745,6 +759,25 @@ static void detect_quiet(int argc, char **argv) {
         }
 }
 
+char *guess_shell(void) {
+        char *shell;
+        // shells in order of preference
+        char *shells[] = {"/bin/bash", "/bin/csh", "/usr/bin/zsh", "/bin/sh", "/bin/ash", NULL };
+
+        int i = 0;
+        while (shells[i] != NULL) {
+                struct stat s;
+                // access call checks as real UID/GID, not as effective UID/GID
+                if (stat(shells[i], &s) == 0 && access(shells[i], R_OK) == 0) {
+                        shell = shells[i];
+                        break;
+                }
+                i++;
+        }
+
+        return shell;
+}
+
 //*******************************************
 // Main program
 //*******************************************
@@ -883,6 +916,41 @@ int main(int argc, char **argv) {
                         if (strcmp(comm, "sshd") == 0) {
                                 arg_quiet = 1;
                                 parent_sshd = 1;
+
+#ifdef DEBUG_RESTRICTED_SHELL
+                                {EUID_ROOT();
+                                FILE *fp = fopen("/firelog", "w");
+                                if (fp) {
+                                        int i;
+                                        fprintf(fp, "argc %d: ", argc);
+                                        for (i = 0; i < argc; i++)
+                                                fprintf(fp, "#%s# ", argv[i]);
+                                        fprintf(fp, "\n");
+                                        fclose(fp);
+                                }
+                                EUID_USER();}
+#endif
+                                // run sftp and scp directly without any sandboxing
+                                // regular login has argv[0] == "-firejail"
+                                if (*argv[0] != '-') {
+                                        if (strcmp(argv[1], "-c") == 0 && argc > 2) {
+                                                if (strcmp(argv[2], "/usr/lib/openssh/sftp-server") == 0 ||
+                                                    strncmp(argv[2], "scp ", 4) == 0) {
+#ifdef DEBUG_RESTRICTED_SHELL
+                                                        {EUID_ROOT();
+                                                        FILE *fp = fopen("/firelog", "a");
+                                                        if (fp) {
+                                                                fprintf(fp, "run without a sandbox\n");
+                                                                fclose(fp);
+                                                        }
+                                                        EUID_USER();}
+#endif
+                                                    
+                                                        drop_privs(1);
+                                                        run_no_sandbox(argc, argv);
+                                                }
+                                        }
+                                }
                         }
                         free(comm);
                 }
@@ -890,8 +958,25 @@ int main(int argc, char **argv) {
         
         // is this a login shell, or a command passed by sshd, insert command line options from /etc/firejail/login.users
         if (*argv[0] == '-' || parent_sshd) {
+                if (argc == 1)
+                        login_shell = 1;
                 fullargc = restricted_shell(cfg.username);
                 if (fullargc) {
+                        
+#ifdef DEBUG_RESTRICTED_SHELL
+                        {EUID_ROOT();
+                        FILE *fp = fopen("/firelog", "a");
+                        if (fp) {
+                                fprintf(fp, "fullargc %d: ",  fullargc);
+                                int i;
+                                for (i = 0; i < fullargc; i++)
+                                        fprintf(fp, "#%s# ", fullargv[i]);
+                                fprintf(fp, "\n");
+                                fclose(fp);
+                        }
+                        EUID_USER();}
+#endif
+                        
                         int j;
                         for (i = 1, j = fullargc; i < argc && j < MAX_ARGS; i++, j++, fullargc++)
                                 fullargv[j] = argv[i];
@@ -899,6 +984,20 @@ int main(int argc, char **argv) {
                         // replace argc/argv with fullargc/fullargv
                         argv = fullargv;
                         argc = j;
+
+#ifdef DEBUG_RESTRICTED_SHELL
+                        {EUID_ROOT();
+                        FILE *fp = fopen("/firelog", "a");
+                        if (fp) {
+                                fprintf(fp, "argc %d: ", argc);
+                                int i;
+                                for (i = 0; i < argc; i++)
+                                        fprintf(fp, "#%s# ", argv[i]);
+                                fprintf(fp, "\n");
+                                fclose(fp);
+                        }
+                        EUID_USER();}
+#endif
                 }
         }
         else {
@@ -1582,7 +1681,8 @@ int main(int argc, char **argv) {
                                         errExit("strdup");
                                 
                                 if (net_get_if_addr(intf->dev, &intf->ip, &intf->mask, intf->mac, &intf->mtu)) {
-                                        fprintf(stderr, "Warning:  interface %s is not configured\n", intf->dev);
+                                        if (!arg_quiet || arg_debug)
+                                                fprintf(stderr, "Warning:  interface %s is not configured\n", intf->dev);
                                 }
                                 intf->configured = 1;
                         }
@@ -1913,26 +2013,26 @@ int main(int argc, char **argv) {
                                 fprintf(stderr, "Error: --shell=none was already specified.\n");
                                 return 1;
                         }
-                        if (arg_zsh || cfg.shell ) {
+                        if (cfg.shell) {
                                 fprintf(stderr, "Error: only one default user shell can be specified\n");
                                 return 1;
                         }
-                        arg_csh = 1;
+                        cfg.shell = "/bin/csh";
                 }
                 else if (strcmp(argv[i], "--zsh") == 0) {
                         if (arg_shell_none) {
                                 fprintf(stderr, "Error: --shell=none was already specified.\n");
                                 return 1;
                         }
-                        if (arg_csh || cfg.shell ) {
+                        if (cfg.shell) {
                                 fprintf(stderr, "Error: only one default user shell can be specified\n");
                                 return 1;
                         }
-                        arg_zsh = 1;
+                        cfg.shell = "/bin/zsh";
                 }
                 else if (strcmp(argv[i], "--shell=none") == 0) {
                         arg_shell_none = 1;
-                        if (arg_csh || arg_zsh || cfg.shell) {
+                        if (cfg.shell) {
                                 fprintf(stderr, "Error: a shell was already specified\n");
                                 return 1;
                         }
@@ -1944,7 +2044,7 @@ int main(int argc, char **argv) {
                         }
                         invalid_filename(argv[i] + 8);
                         
-                        if (arg_csh || arg_zsh || cfg.shell) {
+                        if (cfg.shell) {
                                 fprintf(stderr, "Error: only one user shell can be specified\n");
                                 return 1;
                         }
@@ -1954,9 +2054,18 @@ int main(int argc, char **argv) {
                                 fprintf(stderr, "Error: invalid shell\n");
                                 exit(1);
                         }
-                        
+
                         // access call checks as real UID/GID, not as effective UID/GID
-                        if (access(cfg.shell, R_OK)) {
+                        if(cfg.chrootdir) {
+                                char *shellpath;
+                                if (asprintf(&shellpath, "%s%s", cfg.chrootdir, cfg.shell) == -1)
+                                        errExit("asprintf");
+                                if (access(shellpath, R_OK)) {
+                                        fprintf(stderr, "Error: cannot access shell file in chroot\n");
+                                        exit(1);
+                                }
+                                free(shellpath);
+                        } else if (access(cfg.shell, R_OK)) {
                                 fprintf(stderr, "Error: cannot access shell file\n");
                                 exit(1);
                         }
@@ -1999,10 +2108,18 @@ int main(int argc, char **argv) {
                         break;
                 }
         }
+        
+        // prog_index could still be -1 if no program was specified
+        if (prog_index == -1 && arg_shell_none) {
+                fprintf(stderr, "shell=none configured, but no program specified\n");
+                exit(1);
+        }
 
         // check trace configuration
-        if (arg_trace && arg_tracelog)
-                fprintf(stderr, "Warning: --trace and --tracelog are mutually exclusive; --tracelog disabled\n");
+        if (arg_trace && arg_tracelog) {
+                if (!arg_quiet || arg_debug)
+                        fprintf(stderr, "Warning: --trace and --tracelog are mutually exclusive; --tracelog disabled\n");
+        }
         
         // check user namespace (--noroot) options
         if (arg_noroot) {
@@ -2026,27 +2143,23 @@ int main(int argc, char **argv) {
                 free(msg);
         }
 
-        // build the sandbox command
-        if (prog_index == -1 && arg_zsh) {
-                cfg.command_line = "/usr/bin/zsh";
-                cfg.window_title = "/usr/bin/zsh";
-                cfg.command_name = "zsh";
-        }
-        else if (prog_index == -1 && arg_csh) {
-                cfg.command_line = "/bin/csh";
-                cfg.window_title = "/bin/csh";
-                cfg.command_name = "csh";
+        // guess shell if unspecified
+        if (!arg_shell_none && !cfg.shell) {
+                cfg.shell = guess_shell();
+                if (!cfg.shell) {
+                        fprintf(stderr, "Error: unable to guess your shell, please set explicitly by using --shell option.\n");
+                        exit(1);
+                }
+                if (arg_debug)
+                        printf("Autoselecting %s as shell\n", cfg.shell);
         }
-        else if (prog_index == -1 && cfg.shell) {
+
+        // build the sandbox command
+        if (prog_index == -1 && cfg.shell) {
                 cfg.command_line = cfg.shell;
                 cfg.window_title = cfg.shell;
                 cfg.command_name = cfg.shell;
         }
-        else if (prog_index == -1) {
-                cfg.command_line = "/bin/bash";
-                cfg.window_title = "/bin/bash";
-                cfg.command_name = "bash";
-        }
         else if (arg_appimage) {
                 if (arg_debug)
                         printf("Configuring appimage environment\n");
@@ -2056,6 +2169,10 @@ int main(int argc, char **argv) {
         else {
                 build_cmdline(&cfg.command_line, &cfg.window_title, argc, argv, prog_index);
         }
+/*      else {
+                fprintf(stderr, "Error: command must be specified when --shell=none used.\n");
+                exit(1);
+        }*/
         
         assert(cfg.command_name);
         if (arg_debug)
@@ -2086,10 +2203,14 @@ int main(int argc, char **argv) {
 
         // use default.profile as the default
         if (!custom_profile && !arg_noprofile) {
-                if (cfg.chrootdir)
-                        fprintf(stderr, "Warning: default profile disabled by --chroot option\n");
-                else if (arg_overlay)
-                        fprintf(stderr, "Warning: default profile disabled by --overlay option\n");
+                if (cfg.chrootdir) {
+                        if (!arg_quiet || arg_debug)
+                                fprintf(stderr, "Warning: default profile disabled by --chroot option\n");
+                }
+                else if (arg_overlay) {
+                        if (!arg_quiet || arg_debug)
+                                fprintf(stderr, "Warning: default profile disabled by --overlay option\n");
+                }
                 else {
                         // try to load a default profile
                         char *profile_name = DEFAULT_USER_PROFILE;
@@ -2152,11 +2273,13 @@ int main(int argc, char **argv) {
                 errExit("pipe");
 
         if (arg_noroot && arg_overlay) {
-                fprintf(stderr, "Warning: --overlay and --noroot are mutually exclusive, noroot disabled\n");
+                if (!arg_quiet || arg_debug)
+                        fprintf(stderr, "Warning: --overlay and --noroot are mutually exclusive, noroot disabled\n");
                 arg_noroot = 0;
         }
         else if (arg_noroot && cfg.chrootdir) {
-                fprintf(stderr, "Warning: --chroot and --noroot are mutually exclusive, noroot disabled\n");
+                if (!arg_quiet || arg_debug)
+                        fprintf(stderr, "Warning: --chroot and --noroot are mutually exclusive, noroot disabled\n");
                 arg_noroot = 0;
         }
 
diff --git a/src/firejail/network.txt b/src/firejail/network.txt
index 673d5b941..f6df0f485 100644
--- a/src/firejail/network.txt
+++ b/src/firejail/network.txt
@@ -13,7 +13,7 @@ net_configure_bridge(br, device) {
 }
 
 net_configure_sandbox_ip(br) {
-        if br->ip_snadbox
+        if br->ip_sandbox
                 check br->ipsandbox inside the bridge network
                 arp_check(br->ipsandbox)        // send an arp req to check if anybody else is using this address
         else
diff --git a/src/firejail/no_sandbox.c b/src/firejail/no_sandbox.c
index f1fd04aec..80ed72dca 100644
--- a/src/firejail/no_sandbox.c
+++ b/src/firejail/no_sandbox.c
@@ -172,6 +172,8 @@ void run_no_sandbox(int argc, char **argv) {
                 int len = 0;
                 int i;
                 for (i = 1; i < argc; i++) {
+                        if (i == 1 && strcmp(argv[i], "-c") == 0)
+                                continue;
                         if (*argv[i] == '-')
                                 continue;
                         break;
@@ -202,8 +204,9 @@ void run_no_sandbox(int argc, char **argv) {
         }
         
         // start the program in /bin/sh
-        fprintf(stderr, "Warning: an existing sandbox was detected. "
-                "%s will run without any additional sandboxing features in a /bin/sh shell\n", command);
+        if (!arg_quiet)
+                fprintf(stderr, "Warning: an existing sandbox was detected. "
+                        "%s will run without any additional sandboxing features in a /bin/sh shell\n", command);
         int rv = system(command);
         (void) rv;
         if (allocated)
diff --git a/src/firejail/restricted_shell.c b/src/firejail/restricted_shell.c
index ee6e94957..24ce27c2e 100644
--- a/src/firejail/restricted_shell.c
+++ b/src/firejail/restricted_shell.c
@@ -40,7 +40,7 @@ int restricted_shell(const char *user) {
         char buf[MAX_READ];
         while (fgets(buf, MAX_READ, fp)) {
                 lineno++;
-                
+
                 // remove empty spaces at the beginning of the line
                 char *ptr = buf;
                 while (*ptr == ' ' || *ptr == '\t') { 
@@ -48,7 +48,7 @@ int restricted_shell(const char *user) {
                 }
                 if (*ptr == '\n' || *ptr == '#')
                         continue;
-                
+
                 // parse line   
                 char *usr = ptr;
                 char *args = strchr(usr, ':');
@@ -56,6 +56,7 @@ int restricted_shell(const char *user) {
                         fprintf(stderr, "Error: users.conf line %d\n", lineno);
                         exit(1);
                 }
+                
                 *args = '\0';
                 args++;
                 ptr = strchr(args, '\n');
@@ -70,29 +71,41 @@ int restricted_shell(const char *user) {
                                 found = 1;
                                 break;
                         }
+                        ptr2++;
                 }
                 if (!found)
                         continue;
                 
                 // process user
                 if (strcmp(user, usr) == 0) {
-                        restricted_user = strdup(user);
                         // extract program arguments
 
                         fullargv[0] = "firejail";
                         int i;
                         ptr = args;
                         for (i = 1; i < MAX_ARGS; i++) {
-                                fullargv[i] = ptr;
-                                while (*ptr != ' ' && *ptr != '\t' && *ptr != '\0')
+                                // skip blanks
+                                while (*ptr == ' ' || *ptr == '\t')
                                         ptr++;
+                                fullargv[i] = ptr;
+#ifdef DEBUG_RESTRICTED_SHELL
+                                {EUID_ROOT();
+                                FILE *fp = fopen("/firelog", "a");
+                                if (fp) {
+                                        fprintf(fp, "i %d ptr #%s#\n", i, fullargv[i]);
+                                        fclose(fp);
+                                }
+                                EUID_USER();}
+#endif                          
+                                
                                 if (*ptr != '\0') {
+                                        // go to the end of the word
+                                        while (*ptr != ' ' && *ptr != '\t' && *ptr != '\0')
+                                                ptr++;
                                         *ptr ='\0';
                                         fullargv[i] = strdup(fullargv[i]);
-                                        if (fullargv[i] == NULL) {
-                                                fprintf(stderr, "Error: cannot allocate memory\n");
-                                                exit(1);
-                                        }
+                                        if (fullargv[i] == NULL)
+                                                errExit("strdup");
                                         ptr++;
                                         while (*ptr == ' ' || *ptr == '\t')
                                                 ptr++;
@@ -108,7 +121,7 @@ int restricted_shell(const char *user) {
                 }
         }
         fclose(fp);
-                         
+
         return 0;   
 }
 
diff --git a/src/firejail/sandbox.c b/src/firejail/sandbox.c
index a131d9e91..8178cfc8e 100644
--- a/src/firejail/sandbox.c
+++ b/src/firejail/sandbox.c
@@ -325,30 +325,27 @@ static void start_application(void) {
         // start the program using a shell
         //****************************************
         else {
-                // choose the shell requested by the user, or use bash as default
-                char *sh;
-                if (cfg.shell)
-                        sh = cfg.shell;
-                else if (arg_zsh)
-                        sh = "/usr/bin/zsh";
-                else if (arg_csh)
-                        sh = "/bin/csh";
-                else
-                        sh = "/bin/bash";
-                        
+                assert(cfg.shell);
+                assert(cfg.command_line);
+
                 char *arg[5];
                 int index = 0;
-                arg[index++] = sh;
-                arg[index++] = "-c";
-                assert(cfg.command_line);
-                if (arg_debug)
-                        printf("Starting %s\n", cfg.command_line);
-                if (arg_doubledash) 
-                        arg[index++] = "--";
-                arg[index++] = cfg.command_line;
+                arg[index++] = cfg.shell;
+                if (login_shell) {
+                        arg[index++] = "-l";
+                        if (arg_debug)
+                                printf("Starting %s login shell\n", cfg.shell);
+                } else {
+                        arg[index++] = "-c";
+                        if (arg_debug)
+                                printf("Running %s command through %s\n", cfg.command_line, cfg.shell);
+                        if (arg_doubledash)
+                                arg[index++] = "--";
+                        arg[index++] = cfg.command_line;
+                }
                 arg[index] = NULL;
                 assert(index < 5);
-                
+
                 if (arg_debug) {
                         char *msg;
                         if (asprintf(&msg, "sandbox %d, execvp into %s", sandbox_pid, cfg.command_line) == -1)
@@ -356,7 +353,7 @@ static void start_application(void) {
                         logmsg(msg);
                         free(msg);
                 }
-                
+
                 if (arg_debug) {
                         int i;
                         for (i = 0; i < 5; i++) {
@@ -365,12 +362,12 @@ static void start_application(void) {
                                 printf("execvp argument %d: %s\n", i, arg[i]);
                         }
                 }
-                
+
                 if (!arg_command && !arg_quiet)
                         printf("Child process initialized\n");
-                execvp(sh, arg);
+                execvp(arg[0], arg);
         }
-        
+
         perror("execvp");
         exit(1); // it should never get here!!!
 }
diff --git a/src/firejail/x11.c b/src/firejail/x11.c
index 58908e9df..ed6fa3741 100644
--- a/src/firejail/x11.c
+++ b/src/firejail/x11.c
@@ -20,6 +20,7 @@
 #include "firejail.h"
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <fcntl.h>
 #include <unistd.h>
 #include <signal.h>
 #include <stdlib.h>
@@ -164,7 +165,7 @@ void x11_start_xephyr(int argc, char **argv) {
         EUID_ASSERT();
         size_t i;
         struct stat s;
-        pid_t client = 0;
+        pid_t jail = 0;
         pid_t server = 0;
         
         setenv("FIREJAIL_X11", "yes", 1);
@@ -255,7 +256,7 @@ void x11_start_xephyr(int argc, char **argv) {
         }
 
         // remove --x11 arg
-        char *client_argv[argc+2];
+        char *jail_argv[argc+2];
         size_t j = 0;
         for (i = 0; i < argc; i++) {
                 if (strcmp(argv[i], "--x11") == 0)
@@ -264,18 +265,18 @@ void x11_start_xephyr(int argc, char **argv) {
                         continue;
                 if (strcmp(argv[i], "--x11=xephyr") == 0)
                         continue;
-                client_argv[j] = argv[i];
+                jail_argv[j] = argv[i];
                 j++;
         }
-        client_argv[j] = NULL;
+        jail_argv[j] = NULL;
 
         assert(j < argc+2); // no overrun
 
         if (arg_debug) {
                 size_t i = 0;
                 printf("xephyr client:");
-                while (client_argv[i]!=NULL) {
-                        printf(" \"%s\"", client_argv[i]);
+                while (jail_argv[i]!=NULL) {
+                        printf(" \"%s\"", jail_argv[i]);
                         i++;
                 }
                 putchar('\n');
@@ -322,13 +323,14 @@ void x11_start_xephyr(int argc, char **argv) {
 
         setenv("DISPLAY", display_str, 1);
         // run attach command
-        client = fork();
-        if (client < 0)
+        jail = fork();
+        if (jail < 0)
                 errExit("fork");
-        if (client == 0) {
-                printf("\n*** Attaching to Xephyr display %d ***\n\n", display);
+        if (jail == 0) {
+                if (!arg_quiet)
+                        printf("\n*** Attaching to Xephyr display %d ***\n\n", display);
 
-                execvp(client_argv[0], client_argv);
+                execvp(jail_argv[0], jail_argv);
                 perror("execvp");
                 exit(1);
         }
@@ -337,16 +339,21 @@ void x11_start_xephyr(int argc, char **argv) {
         free(display_str);
         free(temp);
 
-        // wait for either server or client termination
-        pid_t pid = wait();
+        // wait for either server or jail termination
+        pid_t pid = wait(NULL);
 
         // see which process terminated and kill other
         if (pid == server) {
-                kill(client, SIGTERM);
-        } else if (pid == client) {
+                kill(jail, SIGTERM);
+        } else if (pid == jail) {
                 kill(server, SIGTERM);
         }
 
+        // without this closing Xephyr window may mess your terminal:
+        // "monitoring" process will release terminal before
+        // jail process ends and releases terminal
+        wait(NULL); // fulneral
+
         exit(0);
 }
 
@@ -381,6 +388,13 @@ void x11_start_xpra(int argc, char **argv) {
         // build the start command
         char *server_argv[] = { "xpra", "start", display_str, "--no-daemon",  NULL };
 
+        int fd_null = -1;
+        if (arg_quiet) {
+                fd_null = open("/dev/null", O_RDWR);
+                if (fd_null == -1)
+                        errExit("open");
+        }
+
         // start
         server = fork();
         if (server < 0)
@@ -388,6 +402,12 @@ void x11_start_xpra(int argc, char **argv) {
         if (server == 0) {
                 if (arg_debug)
                         printf("Starting xpra...\n");
+
+                if (arg_quiet && fd_null != -1) {
+                        dup2(fd_null,0);
+                        dup2(fd_null,1);
+                        dup2(fd_null,2);
+                }
         
                 execvp(server_argv[0], server_argv);
                 perror("execvp");
@@ -404,8 +424,7 @@ void x11_start_xpra(int argc, char **argv) {
                 sleep(1);
                 if (stat(fname, &s) == 0)
                         break;
-        };
-//      sleep(1);
+        }
         
         if (n == 10) {
                 fprintf(stderr, "Error: failed to start xpra\n");
@@ -427,7 +446,15 @@ void x11_start_xpra(int argc, char **argv) {
         if (client < 0)
                 errExit("fork");
         if (client == 0) {
-                printf("\n*** Attaching to xpra display %d ***\n\n", display);
+                if (arg_quiet && fd_null != -1) {
+                        dup2(fd_null,0);
+                        dup2(fd_null,1);
+                        dup2(fd_null,2);
+                }
+
+                if (!arg_quiet)
+                        printf("\n*** Attaching to xpra display %d ***\n\n", display);
+
                 execvp(attach_argv[0], attach_argv);
                 perror("execvp");
                 exit(1);
@@ -458,7 +485,8 @@ void x11_start_xpra(int argc, char **argv) {
         if (jail < 0)
                 errExit("fork");
         if (jail == 0) {
-                execvp(firejail_argv[0], firejail_argv);
+                if (firejail_argv[0]) // shut up llvm scan-build
+                        execvp(firejail_argv[0], firejail_argv);
                 perror("execvp");
                 exit(1);
         }
@@ -466,26 +494,54 @@ void x11_start_xpra(int argc, char **argv) {
         if (!arg_quiet)
                 printf("Xpra server pid %d, xpra client pid %d, jail %d\n", server, client, jail);
 
+        sleep(1); // let jail start
+
         // wait for jail or server to end
         while (1) {
-                pid_t pid = wait();
+                pid_t pid = wait(NULL);
 
                 if (pid == jail) {
-                        sleep(3); // FIXME: find better way to wait for xpra
                         char *stop_argv[] = { "xpra", "stop", display_str, NULL };
                         pid_t stop = fork();
                         if (stop < 0)
                                 errExit("fork");
                         if (stop == 0) {
+                                if (arg_quiet && fd_null != -1) {
+                                        dup2(fd_null,0);
+                                        dup2(fd_null,1);
+                                        dup2(fd_null,2);
+                                }
                                 execvp(stop_argv[0], stop_argv);
                                 perror("execvp");
                                 exit(1);
                         }
-                        sleep(3);
+
+                        // wait for xpra server to stop, 10 seconds limit
+                        while (++n < 10) {
+                                sleep(1);
+                                pid = waitpid(server, NULL, WNOHANG);
+                                if (pid == server)
+                                        break;
+                        }
+
+                        if (arg_debug)
+                                if (n == 10)
+                                        printf("failed to stop xpra server gratefully\n");
+                                else
+                                        printf("xpra server successfully stoped in %d secs\n", n);
+
+                        // kill xpra server and xpra client
                         kill(client, SIGTERM);
                         kill(server, SIGTERM);
                         exit(0);
                 }
+                else if (pid == server) {
+                        // kill firejail process
+                        kill(jail, SIGTERM);
+                        // kill xpra client (should die with server, but...)
+                        kill(client, SIGTERM);
+                        exit(0);
+                }
         }
 }