UNIX环境高级编程1-5从标准输入读命令并执行

从标准输入读命令并执行 

隐藏行号 复制代码 ？

1. // program 1-5 proc/shell1.c
   

1.   // proc/shell1.c

2. #include "apue.h"
   

3. #include <sys/wait.h>
   

4. int main(void)
   

5. {
   

6.     char buf[MAXLINE]; /* from apue.h */
   

7.     pid_t pid;
   

8.     int status;
   

9.     printf("%% "); /* print prompt (printf requires %% to print %) */
   

10.     // We use the standard I/O function fgets to read one line at a time from the
    

11.     // standard input. When we type the end-of-file character (which is often
    

12.     // Control-D) as the first character of a line, fgets returns a null pointer, the loop
    

13.     // stops, and the process terminates. In Chapter 18, we describe all the special
    

14.     // terminal characters--end of file, backspace one character, erase entire line, and
    

15.     // so on -- and how to change them.
    

16.     // Because each line returned by fgets is terminated with a newline character,
    

17.     // followed by a null byte, we use the standard C function strlen to calculate the
    

18.     // length of the string, and then replace the newline with a null byte. We do this
    

19.     // because the execlp function wants a null-terminated argument, not a
    

20.     // newline-terminated argument.
    

21.     // We call fork to create a new process, which is a copy of the caller. We say that
    

22.     // the caller is the parent and that the newly created process is the child. Then
    

23.     // fork returns the non-negative process ID of the new child process to the parent,
    

24.     // and returns 0 to the child. Because fork creates a new process, we say that it is
    

25.     // called once--by the parent--but returns twice--in the parent and in the child.
    

26.     // In the child, we call execlp to execute the command that was read from the
    

27.     // standard input. This replaces the child process with the new program file. The
    

28.     // combination of fork followed by exec is called spawning a new process on
    

29.     // some operating systems. In the UNIX System, the two parts are separated into
    

30.     // individual functions. We'll say a lot more about these functions in Chapter 8.
    

31.     // Because the child calls execlp to execute the new program file, the parent
    

32.     // wants to wait for the child to terminate. This is done by calling waitpid,
    

33.     // specifying which process to wait for: the pid argument, which is the process ID
    

34.     // of the child. The waitpid function also returns the termination status of the
    

35.     // child--the status variable--but in this simple program, we don't do anything
    

36.     // with this value. We could examine it to determine how the child terminated
    

37.     // The most fundamental limitation of this program is that we can't pass
    

38.     // arguments to the command we execute. We can't, for example, specify the name
    

39.     // of a directory to list. We can execute ls only on the working directory. To allow
    

40.     // arguments would require that we parse the input line, separating the arguments
    

41.     // by some convention, probably spaces or tabs, and then pass each argument as a
    

42.     // separate parameter to the execlp function. Nevertheless, this program is still a
    

43.     // useful demonstration of the UNIX System's process control functions.
    

44. while (fgets(buf, MAXLINE, stdin) != NULL)
    

45.     {
    

46.         if (buf[strlen(buf) - 1] == '\n')
    

47.         {
    

48.             buf[strlen(buf) - 1] = 0; /* replace newline with null */
    

49. }
    

50.         if ((pid = fork()) < 0)
    

51.         {
    

52.             err_sys("fork error");
    

53.         }
    

54.         else if (pid == 0)
    

55.         {   /* child */
    

56.             // if the execlp execute successfully, execlp will not return
    

57.             // if it execute failed, return -1, and the error number store in errno variable
    

58. execlp(buf, buf, (char *)0);
    

59.             err_ret("couldn't execute: %s", buf);
    

60.             exit(127);
    

61.         }
    

62.         /* parent */
    

63. if ((pid = waitpid(pid, &status, 0)) < 0)
    

64.         {
    

65.             err_sys("waitpid error");
    

66.         }
    

67.         printf("%% ");
    

68.     }
    

69.     return 0;
    

70. }
    

 

all: shell1
shell1: shell1.c
	g++ -g -Wall shell1.c ../lib/libapue.a -I ../include -o shell1
clean:
	rm shell1