Linux: What is Dash ( /bin/dash ) Shell?

不点

Linux: What is Dash ( /bin/dash ) Shell?


https://www.cyberciti.biz/faq/debian-ubuntu-linux-binbash-vs-bindash-vs-binshshell/


May 28, 2011in Categories BASH Shell, Debian / Ubuntu last updated May 28, 2011

What is /bin/dash? I noticed that the default system shell /bin/sh was changed to /bin/dash. Why was this change made?

Dash is an acronym for Debian Almquist shell (dash). It is a Unix and Linux shell which is much smaller than bash but still aiming at POSIX-compliancy. dash is a POSIX-compliant implementation of /bin/sh that aims to be as small as possible. dash is a direct descendant of the NetBSD version of ash (the Almquist SHell), ported to Linux in early 1997. It was renamed to dash in 2002.

From the dash man page:

    dash is the standard command interpreter for the Linux system. The current version of dash is in the process of being changed to conform with the POSIX 1003.2 and 1003.2a specifications for the shell. This version has many features which make it appear similar in some respects to the Korn shell, but it is not a Korn shell clone. Only features designated by POSIX, plus a few Berkeley extensions, are being incorporated into this shell.

Starting with DebianSqueeze and Ubuntu 6.10, the default shell will be dash. The default system shell, /bin/sh, was changed to /bin/dash due to the following technical reasons:

    To speed up the system boot time. The reason is that dash starts faster than bash, and the shell is started quite a lot of times during boot. Measurements showed that they run equally fast, so the improved boot time must be due to dash doing less work during initialization.
    It requires less disk space but is also less feature-rich.
    It depends on fewer libraries.
    It is believed to be more reliable in the case of upgrade problems or disk failures.

A Note About Bash Specific Scripts

It is recommend that to avoid errors with your own Bash-specific scripts you can use the shebang line as follows:
#!/usr/bin/env bash.

OR
#!/path/to/real/bash.binary

OR
#!/usr/local/bin/bash

However, Ubuntu wiki recommends that:

    Developers of shell scripts adhere to the POSIX standard, omitting those items flagged as XSI extensions. Doing so will improve portability to a variety of Unix systems, and will provide assurance that problems you encounter will be treated as bugs rather than as undocumented features.

Test all your scripts and see if they will break once /bin/sh defaults to /bin/dash using virtualization or test machine.
References:

    Dash page from the Debian wiki.
    Dash as /bin/sh page from the Ubuntu wiki.
    Proposed release goal: Switch to dash as /bin/sh to speed up the boot.
    man dash

project page http://gondor.apana.org.au/~herbert/dash/

git repository http://git.kernel.org/?p=utils/dash/dash.git;a=summary

files http://gondor.apana.org.au/~herbert/dash/files/

不点

谢谢您提供见解。我是被 zsh 的代码搅糊涂了，才转到 bash，然而 bash 的代码也还是太乱，折腾了一两个月，最终发现还是折腾不动，彻底服气了。所以，被迫来折腾一个没有什么功能的、纯粹的 shell 软件。

我已经下载了 dash，它的代码果然很简练，至少比 bash 简练多了。感觉这可能是适合我的那种软件。

njlyf2011

之前看过DASH源码，应该是从FreeBSD里面提取出来的。

不点

njlyf2011 发表于 2018-1-8 21:19
之前看过DASH源码，应该是从FreeBSD里面提取出来的。

谢谢。请谈谈 dash 的源码，它是否容易阅读和理解？

bash 的源码太乱了，我是已经受不了了，才被迫转向 dash。

我还没开始下载 dash。

我是看到 debian 和 ubuntu 采用 dash 来取代 bash，所以才想到应该关注 dash 的。

njlyf2011

不点 发表于 2018-1-8 22:12
谢谢。请谈谈 dash 的源码，它是否容易阅读和理解？

bash 的源码太乱了，我是已经受不了了，才被迫转 ...

那个……不好意思……我目前不会编程所以代码并不能看懂……

njlyf2011

另外如果您不想用bash的话，试试zsh之类的吧……dash功能实在不多，连自动补全也没有

不点

费了九牛二虎之力，终于让 dash 能够用 g++ 编译了。

不点

找到一个最小的 shell，感觉很有启发性，适合入门。

http://bbs.21ic.com/icview-1614664-1-1.html
http://www.samiam.org/software/yash.html

Yash: Yet another shell

This is a simple thought experiment: How small can we make a usable*NIX command shell?  This program, only 127 lines long (complete withdocumentation), is a very basic *NIX command shell.  It can be downloaded here
Since the program is so small, I am including its source below.  Note that there are ways to make this smaller by, say, using strtok to parse the line, and strcmp to handle the "cd" command.  However, this code style makes extending the shell easier; the smallest shell that one can make is actually

1. main(){char i[99];for(;;){gets(i);system(i);}}

复制代码

Without further ado, the code:

1. /* Placed in the public domain 2009 by Sam Trenholme */
   
2. 
   
3. /* Yash: A usable command shell in under 4k (yet another shell)
   
4. *
   
5. * This is a simple thought experiment: How small can we make a *NIX command
   
6. * line shell?  This is as simple as it gets; it will run a command typed
   
7. * in if it's an external command like "ls" or "cc", with arguments separated
   
8. * by space; if one types in "-cd {directory}", it will go to that directory.
   
9. *
   
10. * CNTL-C exits the shell
    
11. *
    
12. * BUGS: CNTL-D reruns the previous command instead of exiting the shell.
    
13. */
    
14. 
    
15. #define LINEMAX 80
    
16. #define ARGMAX 16
    
17. 
    
18. #include <stdio.h>
    
19. #include <unistd.h>
    
20. 
    
21. /* Given a pointer to arguments, destroy the string */
    
22. void yash_zap_args(char **zap) {
    
23.         int a = 0;
    
24. 
    
25.         if(zap == 0) {
    
26.                 return;
    
27.         }
    
28. 
    
29.         for(a = 0; a < ARGMAX; a++) {
    
30.                 if(zap[a] != 0) {
    
31.                         free(zap[a]);
    
32.                         zap[a] = 0;
    
33.                 }
    
34.         }
    
35. 
    
36.         free(zap);
    
37. }
    
38. 
    
39. /* Given a line separated by whitespace, return an array of strings
    
40. * of the individual arguments */
    
41. 
    
42. char **yash_args(char *in) {
    
43.         char **out = 0;
    
44.         int a = 0, b = 0;
    
45. 
    
46.         /* Sanity checks */
    
47.         if(in == 0) {
    
48.                 return 0;
    
49.         }
    
50. 
    
51.         out = malloc(ARGMAX * sizeof(char *));
    
52.         for(a = 0; a < ARGMAX; a++) {
    
53.                 out[a] = 0;
    
54.         }
    
55.         a = 0;
    
56. 
    
57.         if(out == 0) {
    
58.                 return 0;
    
59.         }
    
60. 
    
61.         while(*in != 0) {
    
62.                 if(*in != ' ' && *in != '\n') {
    
63.                         if((out[a] = malloc(LINEMAX)) == 0) {
    
64.                                 goto catch_yash_args;
    
65.                         }
    
66.                         b = 0;
    
67.                         while(b < LINEMAX - 2 && *in != ' ' && *in != 0 &&
    
68.                               *in != '\n') {
    
69.                                 out[a][b] = *in;
    
70.                                 b++;
    
71.                                 in++;
    
72.                         }
    
73.                         out[a][b] = 0;
    
74.                         a++;
    
75.                         if(a >= ARGMAX) {
    
76.                                 goto catch_yash_args;
    
77.                         }
    
78.                 }
    
79.                 in++;
    
80.         }       
    
81. 
    
82.         return out;
    
83.                
    
84. catch_yash_args:
    
85.         yash_zap_args(out);
    
86.         return 0;
    
87. }
    
88. 
    
89. /* Meta commands for yash; right now this is just the cd command */
    
90. void yash_meta(char **args) {
    
91.         if(args == 0 || args[0] == 0) {
    
92.                 return;
    
93.         }
    
94. 
    
95.         if(args[0][1] == 'c' && args[0][2] == 'd') {
    
96.                 if(args[1] == 0) {
    
97.                         chdir("/"); /* Should be $HOME, isn't */
    
98.                 } else {
    
99.                         chdir(args[1]);
    
100.                 }
     
101.                 return;
     
102.         }
     
103. }
     
104.                
     
105. main() {
     
106.         char in[LINEMAX], **args = 0;
     
107. 
     
108.         for(;;) {
     
109.                 printf("$ ");
     
110.                 fgets(in,LINEMAX,stdin);
     
111.                 args = yash_args(in);
     
112.                 if(args != 0 && args[0] != 0) {
     
113.                         if(*args[0] == '-') {
     
114.                                 yash_meta(args);
     
115.                         }
     
116.                         else if(fork()) {
     
117.                                 wait(0);
     
118.                         } else {
     
119.                                 execvp(args[0],args);
     
120.                                 printf("Command not found\n");
     
121.                                 exit(-1);
     
122.                         }
     
123.                 }               
     
124.                 yash_zap_args(args);
     
125.         }
     
126. }

复制代码

不点

上述最小 shell —— yash 确实很棒，入门级最佳途径。

下面是另外一个 shell —— msh，只有 5K：

http://ibiblio.org/pub/linux/system/shells/!INDEX.html

1. 
   
2. /* Minimal shell C source - (c) 1999, Spock (Oscar Portela Arjona) */
   
3. 
   
4. #include <sys/wait.h>
   
5. #include <unistd.h>
   
6. #include <fcntl.h>
   
7. #include <stdlib.h>
   
8. #include <signal.h>
   
9. #include <string.h>
   
10. #include <stdio.h>
    
11. 
    
12. #define chkerr(c,msg) if (c < 0) {perror("ERROR (" msg ")"); exit(-1);}
    
13. #define mvdesc(d1,d2) {close(d1); dup(d2); close(d2);}
    
14. #define redir(n,f)    {close(n); chkerr(open(fv[n],f,0666),"open");}
    
15. #define size(v,s,u,n,t) {(v = (t)realloc(v,s))[u] = n;}
    
16. #define l2            l1[vc]
    
17. #define l3            l2[p[0]]
    
18. 
    
19. int main(void) {
    
20.     char ***l1 = NULL, *fv[3] ,dir[50] ,c;
    
21.     int vc, bg, id, p[2], d;
    
22.     void *ttt = 0;
    
23.     ttt = ttt;
    
24. 
    
25.     signal(SIGINT, SIG_IGN);       
    
26.     signal(SIGQUIT,SIG_IGN);
    
27. 
    
28.     while (1) {
    
29.         getcwd(dir,50);
    
30.         write(1,dir,strlen(dir));
    
31.         write(1," $ ",d = bg = 3);
    
32.         for (;bg; fv[bg] = NULL)
    
33.             ttt=realloc(fv[--bg],0);
    
34.         size(l1,4,0,NULL,char ***);
    
35.         for (vc = p[0] = 0; read(0,&c,1) && (c != '\n');)
    
36.             switch(c) {
    
37.                 case '<':
    
38.                     d = 0; break;
    
39.                 case '>':
    
40.                     d = 1; break;
    
41.                 case '|':
    
42.                     if (l2) {
    
43.                         vc++;
    
44.                         p[0] = 0;
    
45.                     }
    
46.                     d = 3; break;
    
47.                 case '&':
    
48.                     if (d < 3)
    
49.                         d++;
    
50.                     else
    
51.                         bg = 1; break;
    
52.                 case ' ':
    
53.                     if (d < 3) {
    
54.                         if (fv[d])
    
55.                             d = 3;
    
56.                     } else if (l2 && l3)
    
57.                         p[0]++; break;
    
58.                 default:  
    
59.                     if (d < 3) {
    
60.                         if (!fv[d])
    
61.                             size(fv[d],1,0,'\0',char *);
    
62.                         id=strlen(fv[d]);
    
63.                         size(fv[d],id+2,id,c,char *);
    
64.                         fv[d][id+1]='\0';
    
65.                     }else {
    
66.                         if (!l2) {
    
67.                             size(l1,vc*4+8,vc+1,NULL,char ***);
    
68.                             size(l2,4,0,NULL, char **);
    
69.                         }
    
70.                         if (!l3) {
    
71.                             size(l2,p[0]*4+8,p[0]+1,NULL,char **);
    
72.                             size(l3,1,0,'\0', char *);
    
73.                         }
    
74.                         id=strlen(l3);
    
75.                         size(l3,id+2,id,c, char *);
    
76.                         l3[id+1] = '\0';
    
77.                     }
    
78.             }
    
79.         for (vc = 0; l2;) {
    
80.             if (!vc)
    
81.                 d = dup(0);
    
82.             if (l1[vc+1])
    
83.                 chkerr(pipe(p),"pipe");
    
84.             if (!strcmp(l2[0],"exit"))
    
85.                 exit(0);
    
86.             if (!strcmp(l2[0],"cd")) {
    
87.                 if (chdir(l2[1]) < 0)
    
88.                     chdir(getenv("HOME"));
    
89.             } else {
    
90.                 if (!(id = fork())) {
    
91.                         if (fv[0] && !vc)
    
92.                             redir(0,O_RDONLY)
    
93.                         else
    
94.                             mvdesc(0,d);
    
95.                         if (fv[1])
    
96.                             redir(1,O_CREAT|O_WRONLY|O_TRUNC);
    
97.                         if (fv[2])
    
98.                             redir(2,O_CREAT|O_WRONLY|O_TRUNC);
    
99.                         if (l1[vc+1]) {
    
100.                             mvdesc(1,p[1]);
     
101.                             close(p[0]);
     
102.                         }
     
103.                         if (!bg) {
     
104.                             signal(SIGINT,SIG_DFL);
     
105.                             signal(SIGQUIT,SIG_DFL);
     
106.                         }
     
107.                         chkerr(execvp(l2[0],l2),"exec");
     
108.                     }
     
109.                 if (!l1[vc+1] && !bg)
     
110.                     while (wait(NULL) != id);
     
111.             }
     
112.             for (id = 0; l2[id]; ttt = realloc(l2[id++],0));
     
113.             ttt = realloc(l2,0);
     
114.             close(d);
     
115.             if (l1[++vc]) {
     
116.                 d = dup(p[0]);
     
117.                 close(p[0]);
     
118.                 close(p[1]);
     
119.             }
     
120.         } //for (vc = 0; l2;)
     
121.     } //while (1)
     
122. }
     

复制代码

下面这个叫做 “s” 的 shell，还在活跃开发中：

https://www.reddit.com/r/tinycode/comments/64m8lc/s_minimal_shell/