Specific Code Implementation of shell with basic functions

Specific Code Implementation of shell with basic functions

I have been interacting with shell for the last few months, and I feel shell is full of mystery. I accidentally saw an article explaining the implementation of shell, and it was not very difficult, so I began to develop my own minishell, by the way, it also reinforces the knowledge of linux programming that I learned some time ago.

First, let's take a look at the functions implemented by my minishell:

1. Supports External commands such as ls, touch, and wc.
2. Support for input and output redirection characters

3. Support for pipeline commands

4. Support for background jobs

5. Supports Internal commands such as cd, jobs, kill, and exit (You have also written an about command ^ _ ^)

6. Support for ctrl + c and ctrl + z Signal Processing

Next, we will analyze them one by one according to the writing steps:

(1) Command Parsing

Parsing input commands accounts for a large proportion in this program, although such a program for parsing Common commands (regular expressions are too difficult ..) The interpreter is not difficult, but the robustness and comprehensiveness still need to be fully considered.
Here we use segment resolution, first remove the starting space, tabs, and so on, and use this and some '|', '<' as the Division boundary to parse the COMMAND to the COMMAND structure. Let's look at the code. The comments are very detailed!

[Cpp] view plaincopy

1. /*
2. * Parsing command
3. * If the number of parsed commands is returned successfully,-1 is returned if the command fails to be parsed.
4. */
5. Intparse_command (void)
6. {
7. /* Cat <test.txt | grep-npublic> test2.txt &*/
8. If (check ("\ n "))
9. Return0;
11. /* Determine whether the command is internal and execute it */
12. If (builtin ())
13. Return0;
16. /* 1. parse the first simple command */
18. Get_command (0 );
19. /* 2. Determine whether there is an input redirection character */
20. If (check ("<"))
21. Getname (infile );
22. /* 3. Determine whether a media transcoding queue exists */
23. Inti;
24. For (I = 1; I <PIPELINE; ++ I)
25. {
26. If (check ("| "))
27. Get_command (I );
28. Else
29. Break;
30. }
31. /* 4. determine whether an output redirection character exists */
32. If (check ("> "))
33. {
34. If (check ("> "))
35. Append = 1;
36. Getname (outfile );
37. }
38. /* 5. Determine whether the background job is used */
39. If (check ("&"))
40. Backgnd = 1;
41. /* 6. Determine whether the command ends '\ n '*/
42. If (check ("\ n "))
43. {
44. Pai_count = I;
45. Return1__count;
46. }
47. Else
48. {
49. Fprintf (stderr, "Commandlinesyntaxerror \ n ");
50. Return-1;
51. }
52. }
54. /*
55. * Parse simple commands to cmd [I]
56. * Extract the command parameters in cmdline to the avline array,
57. * And point each pointer in the args [] in the COMMAND structure to these strings
58. */
59. Voidget_command (inti)
60. {
61. /* Cat <test.txt | grep-npublic> test2.txt &*/
63. Intj = 0;
64. Intinword;
65. While (* lineptr! = '\ 0 ')
66. {
67. /* Remove Spaces */
68. While (* lineptr = ''| * lineptr = '\ t ')
69. Lineptr ++;
71. /* Point the j parameter of the I command to avptr */
72. Cmd [I]. args [j] = avptr;
73. /* Extract parameters */
74. While (* lineptr! = '\ 0'
75. & * Lineptr! =''
76. & * Lineptr! = '\ T'
77. & * Lineptr! = '>'
78. & * Lineptr! = '<'
79. & * Lineptr! = '|'
80. & * Lineptr! = '&'
81. & * Lineptr! = '\ N ')
82. {
83. /* Extract the parameter to the avline array directed by the avptr pointer */
84. * Avptr ++ = * lineptr ++;
85. Inword = 1;
86. }
87. * Avptr ++ = '\ 0 ';
88. Switch (* lineptr)
89. {
90. Case '':
91. Case '\ t ':
92. Inword = 0;
93. J ++;
94. Break;
95. Case '<':
96. Case '> ':
97. Case '| ':
98. Case '&':
99. Case '\ N ':
100. If (inword = 0)
101. Cmd [I]. args [j] = NULL;
102. Return;
103. Default:/* for '\ 0 '*/
104. Return;
105. }
106. }
107. }
109. /*
110. * Match the string in lineptr with str
111. * 1 is returned. lineptr is removed from the matched string.
112. * 0 is returned for failure, and lineptr remains unchanged.
113. */
114. Intcheck (constchar * str)
115. {
116. Char * p;
117. While (* lineptr = ''| * lineptr = '\ t ')
118. Lineptr ++;
120. P = lineptr;
121. While (* str! = '\ 0' & * str = * p)
122. {
123. Str ++;
124. P ++;
125. }
127. If (* str = '\ 0 ')
128. {
129. Lineptr = p;/* lineptr shifts the matched string */
130. Return1;
131. }
133. /* Keep lineptr unchanged */
134. Return0;
135. }
137. Voidgetname (char * name)
138. {
139. While (* lineptr = ''| * lineptr = '\ t ')
140. Lineptr ++;
142. While (* lineptr! = '\ 0'
143. & * Lineptr! =''
144. & * Lineptr! = '\ T'
145. & * Lineptr! = '>'
146. & * Lineptr! = '<'
147. & * Lineptr! = '|'
148. & * Lineptr! = '&'
149. & * Lineptr! = '\ N ')
150. {
151. * Name ++ = * lineptr ++;
152. }
153. * Name = '\ 0 ';
154. }

(2) Command Execution and Implementation

1. Program Framework:

After the command is parsed, let's consider two major directions: External commands or internal commands?

For external commands, we only need to fork a sub-process and execvp () for execution. For internal commands, we need to implement them by ourselves.

Two questions are raised: first, why execvp ()? Second, why do we need to fork a sub-process to implement it? Isn't a direct while loop possible?

Answer:

(1) We use execvp () because the prototype of the function is int execvp (const char * file, char * const argv []). The first parameter is the command file name, the second is the parameter, which is inconvenient to execute commands.

(2) Once execvp () is executed, the current process will be replaced by the execvp process, and the program will end after execution. Therefore, the while loop is not feasible, you must fork a sub-process for execution.

[Cpp] view plaincopy

1. While (1) {/* repeatforever */
2. Type_prompt ();/* displaypromptonthescreen */
3. Read_command (command, parameters);/* readinputfromterminal */
4. If (fork ()! = 0) {/* forkoffchildprocess */
5. /* Parentcode */
6. Waitpid (-1, & status, 0);/* waitforchildtoexit */
7. } Else {
8. /* Childcode */
9. Execvp (command, parameters);/* executecommand */
10. }
12. }

Using this framework, the functions of External commands (executable files) can be basically implemented (vi, top, ps, etc ).

2. Input/Output redirection

When the analysis shows that there is a redirection symbol of input and output, we need to use the dup () function. For more information about functions, see my blog.

We use a struct to save the input syntactic analysis results:

[Cpp] view plaincopy

1. Typedefstructcommand
2. {
3. Char * args [MAXARG + 1];/* List of parsed command parameters */
4. Intinfd;
5. Intoutfd;
6. } COMMAND;

Basic Process:

[Cpp] view plaincopy

1. /* Sub-process */
2. If (cmd [I]. infd! = 0)
3. {
4. Close (0 );
5. Dup (cmd [I]. infd );
6. }
7. If (cmd [I]. outfd! = 1)
8. {
9. Close (1 );
10. Dup (cmd [I]. outfd );
11. }
14. Intj;
15. For (j = 3; j <OPEN_MAX; ++ j)
16. Close (j );

Cmd [I]. infd and cmd [I]. outfd are the global variables of the resolved redirection location.

3. Pipeline commands

Pipeline commands are implemented using the pipe () function. For more information about pipelines, see my blog.

If we have a | B | c command, we need to create two pipelines, and so on.

[Cpp] view plaincopy

1. Inti;
2. Intfd;
3. Intfds [2];
4. For (I = 0; I <distinct _count; ++ I)
5. {
6. /* If it is not the last command, create an MPS queue */
7. If (I <cmd_count-1)
8. {
9. Pipe (fds );
10. Cmd [I]. outfd = fds [1];
11. Cmd [I + 1]. infd = fds [0];
12. }
14. Forkexec (I );
16. If (fd = cmd [I]. infd )! = 0)
17. Close (fd );
19. If (fd = cmd [I]. outfd )! = 1)
20. Close (fd );
21. }
23. If (backgnd = 0)
24. {
25. /* Foreground job. Wait for the last command in the MPs queue to exit */
26. While (wait (NULL )! = Lastpid)
27. ;
28. }

4. background jobs and signal processing

To judge the background, we only need to parse the command to check whether "&" exists. If yes, backgnd = 1 and no wait is performed on background processes. To avoid zombie processes, we chose to use signal () to process SIGCHLD, ignore it, and ignore SIGINT and SIGQUIT signals (the background does not respond to ctrl + c, ctrl + z ). However, when backgnd is set to 0, you need to set the two signals to the default processing. Otherwise, the front-end cannot respond to the signals.

5. Internal commands

1. cd command implementation
The implementation of the cd command mainly depends on the System Call chdir (). We can pass the first parameter to chdir to make a successful cd call. By determining the different return values of chdir (), you can determine whether the directory is successfully changed and the cause of the error can be output.

[Cpp] view plaincopy

1. Voiddo_cd (void)
2. {
3. Get_command (0 );
4. Intfd;
5. Fd = open (* (cmd [0]. args), O_RDONLY );
6. Fchdir (fd );
7. Close (fd );
8. }

2. Implementation of the jobs command
The jobs Command maintains a linked list. Each time a background process is run, a data table must be added to the linked list. When the child process ends, it will send a SIGCHLD signal to the parent process. The parent process, that is, Shell, needs to process the signal and processes the corresponding processes in the linked list of the background process, that is, remove it.

[Cpp] view plaincopy

1. /* Parent process */
2. If (backgnd = 1)
3. {
4. /* Add the linked list of jobs */
5. NODE * p = (NODE *) malloc (sizeof (NODE ));
6. P-> npid = pid;
7. Printf ("% s", cmd [0]. args [0]);
8. Strcpy (p-> backcn, cmd [0]. args [0]);
9. // Printf ("% s", p-> backcn );
11. NODE * tmp = head-> next;
12. Head-> next = p;
13. P-> next = tmp;
14. }

3. Implementation of the exit command
The exit command is implemented in two parts. First, you can directly call the system to call exit () when the lexical analysis reaches exit. Second, before exiting, determine whether there are still unfinished tasks in the Linked List of background processes. If there are unfinished tasks, notify the user and wait for the user to select.

[Cpp] view plaincopy

1. Voiddo_exit (void)
2. {
3. IntPgnum = 0;
4. NODE * tmp = head-> next;
5. While (tmp! = NULL)
6. {
7. Pgnum ++;
8. Tmp = tmp-> next;
9. }
10. If (Pgnum! = 0)
11. {
12. Printf ("Thereareprogramsinthebackground, areyousuretoexit? Y/N \ n ");
13. Charc = getchar ();
14. If (c = 'n ')
15. Return;
16. Else
17. Gotoloop;
18. }
19. Loop:
20. Printf ("exit \ n ");
21. Exit (EXIT_SUCCESS );
22. }

4. kill command implementation
The implementation of the kill command is implemented by signal. We use kill-9 + pid to force the end Of the background process, use a kill system call to send a SIGQUIT signal to the corresponding process to force the process to exit.

[Cpp] view plaincopy

1. Voiddo_kill (void)
2. {
3. Get_command (0 );
4. Intnum = atoi (cmd [0]. args [1]);
5. Signal (SIGQUIT, SIG_DFL );
6. Kill (num, SIGQUIT );
7. Signal (SIGQUIT, SIG_IGN );
8. NODE * bng = head-> next;
9. NODE * pre = head;
10. While (bng! = NULL)
11. {
12. If (bng-> npid = num)
13. {
14. NODE * nxt = bng-> next;
15. Pre-> next = nxt;
16. Break;
17. }
18. Pre = bng;
19. Bng = bng-> next;
20. }
21. }

By now, the functions of this program have been basically implemented, and the results are quite good.

Note: The specific source code of this program is hosted on Github. Thank you for your attention!

However, there are still some shortcomings:

1. Due to the lack of time and test, there must be bugs.

2. Unable to support complex command parsing such as regular expressions

3. shell scripts cannot be executed.

4. The upper/lower key Viewing History command is not enabled.

In general, I have gained a lot and hope to help you!