程序分析

exec1.c & exect2.c & exect3.c

程序代码 (以exect1.c为例，其他两个结构类似)

  1. #include <stdio.h>
  2. #include <unistd.h>
  4. int main()
  5. {
  6. 	char	*arglist[3];
  8. 	arglist[0] = "ls";
  9. 	arglist[1] = "-l";
  10. 	arglist[2] = 0 ;//NULL
  11. 	printf("* * * About to exec ls -l\n");
  12. 	execvp( "ls" , arglist );
  13. 	printf("* * * ls is done. bye");
  15. 	return 0;
  16. }

运行结果：



结果显示代码“* * * ls is done. bye”没有打印出来。

原因：因为调用execvp,execlp,execv时，内核将新程序载入到当前进程，替代当前进程的代码和数据。

forkdemo1.c

程序代码：

  1. #include	<stdio.h>
  2. #include    <sys/types.h>
  3. #include    <unistd.h>
  4. int main()
  5. {
  6. 	int	ret_from_fork, mypid;
  7. 	mypid = getpid();
  8. 	printf("Before: my pid is %d\n", mypid);
  9. 	ret_from_fork = fork();
  10. 	sleep(1);
  11. 	printf("After: my pid is %d, fork() said %d\n",
  12. 		getpid(), ret_from_fork);
  14. 	return 0;
  15. }

运行结果：

分析：fork()在父进程中返回子进程的pid，在子进程中返回0。

forkdemo2.c

程序代码：

  1. #include <stdio.h>
  2. #include <unistd.h>
  4. int main()
  5. {
  6. 	printf("before:my pid is %d\n", getpid() );
  7. 	fork();
  8. 	fork();
  9. 	printf("aftre:my pid is %d\n", getpid() );
  11. 	return 0;
  12. }

运行结果：

分析：两次fork()共产生3个子进程，加上父进程总共有4个进程。

forkdemo3.c

程序代码：

  1. #include	<stdio.h>
  2. #include    <stdlib.h>
  3. #include    <unistd.h>
  5. int main()
  6. {
  7. 	int	fork_rv;
  9. 	printf("Before: my pid is %d\n", getpid());
  11. 	fork_rv = fork();		/* create new process	*/
  13. 	if ( fork_rv == -1 )		/* check for error	*/
  14. 	perror("fork");
  15. 	else if ( fork_rv == 0 ){
  16. 		printf("I am the child.  my pid=%d\n", getpid());
  18. 		exit(0);
  19. 	}
  20. 	else{
  21. 		printf("I am the parent. my child is %d\n", fork_rv);
  22. 		exit(0);
  23. 	}
  25. 	return 0;
  26. }

运行效果：

forkdemo4.c

程序代码：

  1. #include	<stdio.h>
  2. #include    <stdlib.h>
  3. #include    <unistd.h>
  5. int main()
  6. {
  7. 	int	fork_rv;
  9. 	printf("Before: my pid is %d\n", getpid());
  11. 	fork_rv = fork();		/* create new process	*/
  13. 	if ( fork_rv == -1 )		/* check for error	*/
  14. 		perror("fork");
  16. 	else if ( fork_rv == 0 ){
  17. 		printf("I am the child.  my pid=%d\n", getpid());
  18. 		printf("parent pid= %d, my pid=%d\n", getppid(), getpid());
  19. 		exit(0);
  20. 	}
  22. 	else{
  23. 		printf("I am the parent. my child is %d\n", fork_rv);
  24. 		sleep(10);
  25. 		exit(0);
  26. 	}
  28. 	return 0;
  29. }

运行结果：

forkgdb.c

程序代码：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  5. int  gi=0;
  6. int main()
  7. {
  8. 	int li=0;
  9. 	static int si=0;
  10. 	int i=0;
  12. 	pid_t pid = fork();
  13. 	if(pid == -1){
  14. 		exit(-1);
  15. 	}
  16. 	else if(pid == 0){
  17. 		for(i=0; i<5; i++){
  18. 			printf("child li:%d\n", li++);
  19. 			sleep(1);
  20. 			printf("child gi:%d\n", gi++);
  21. 			printf("child si:%d\n", si++);
  22. 		}
  23. 		exit(0);
  25. 	}
  26. 	else{
  27. 		for(i=0; i<5; i++){
  28. 			printf("parent li:%d\n", li++);
  29. 			printf("parent gi:%d\n", gi++);
  30. 			sleep(1);
  31. 			printf("parent si:%d\n", si++);
  32. 		}
  33. 	exit(0);	
  35. 	}
  36. 	return 0;
  37. }

运行效果：

分析：运行结果说明了子进程与父进程并发运行。

psh1.c

  1. #include	<stdio.h>
  2. #include	<stdlib.h>
  3. #include	<string.h>
  4. #include    <unistd.h>
  6. #define	MAXARGS		20
  7. #define	ARGLEN		100				
  9. //将字符串内容当做命令来执行。
  10. int execute( char *arglist[] )
  11. {
  12. 	execvp(arglist[0], arglist);
  13. 	perror("execvp failed");
  14. 	exit(1);
  15. }
  17. char * makestring( char *buf )
  18. {
  19. 	char	*cp;
  21. 	buf[strlen(buf)-1] = '\0';
  22. 	cp = malloc( strlen(buf)+1 );
  23. 	if ( cp == NULL ){
  24. 		fprintf(stderr,"no memory\n");
  25. 		exit(1);
  26. 	}
  27. 	strcpy(cp, buf);
  28. 	return cp;
  29. }
  31. int main()
  32. {
  33. 	char	*arglist[MAXARGS+1];
  34. 	int		numargs;
  35. 	char	argbuf[ARGLEN];			
  37. 	numargs = 0;
  38. 	while ( numargs < MAXARGS )
  39. 	{
  40. 		printf("Arg[%d]? ", numargs);
  41. 		if ( fgets(argbuf, ARGLEN, stdin) && *argbuf != '\n' )
  42. 			arglist[numargs++] = makestring(argbuf);
  43. 		else
  44. 		{
  45. 			if ( numargs > 0 ){
  46. 				arglist[numargs]=NULL;
  47. 				execute( arglist );	//将arglist中的字符串当做命令来执行。
  48. 				numargs = 0;
  49. 			}
  50. 		}
  51. 	}
  52. 	return 0;
  53. }

运行结果：

程序功能：输入字符串并将其当做命令执行。

psh2.c

程序代码：

  1. #include	<stdio.h>
  2. #include    <stdlib.h>
  3. #include    <string.h>
  4. #include    <sys/types.h>
  5. #include    <sys/wait.h>
  6. #include    <unistd.h>
  7. #include	<signal.h>
  9. #define	MAXARGS		20
  10. #define	ARGLEN		100				
  12. char *makestring( char *buf )
  13. {
  14. 	char	*cp;
  16. 	buf[strlen(buf)-1] = '\0';
  17. 	cp = malloc( strlen(buf)+1 );
  18. 	if ( cp == NULL ){
  19. 		fprintf(stderr,"no memory\n");
  20. 		exit(1);
  21. 	}
  22. 	strcpy(cp, buf);
  23. 	return cp;
  24. }
  26. void execute( char *arglist[] )
  27. {
  28. 	int	pid,exitstatus;				
  30. 	pid = fork();
  31. 	switch( pid ){
  32. 		case -1:
  33. 			perror("fork failed");
  34. 			exit(1);
  35. 		case 0:
  36. 			execvp(arglist[0], arglist);
  37. 			perror("execvp failed");
  38. 			exit(1);
  39. 		default:
  40. 			while( wait(&exitstatus) != pid )
  41. 				;
  42. 			printf("child exited with status %d,%d\n",
  43. 					exitstatus>>8, exitstatus&0377);
  44. 	}
  45. }
  47. int main()
  48. {
  49. 	char	*arglist[MAXARGS+1];
  50. 	int		numargs;
  51. 	char	argbuf[ARGLEN];			
  53. 	numargs = 0;
  54. 	while ( numargs < MAXARGS )
  55. 	{
  56. 		printf("Arg[%d]? ", numargs);
  57. 		if ( fgets(argbuf, ARGLEN, stdin) && *argbuf != '\n' )
  58. 			arglist[numargs++] = makestring(argbuf);
  59. 		else
  60. 		{
  61. 			if ( numargs > 0 ){
  62. 				arglist[numargs]=NULL;
  63. 				execute( arglist );
  64. 				numargs = 0;
  65. 			}
  66. 		}
  67. 	}
  68. 	return 0;
  69. }

运行结果：

程序功能：不断产生新的子进程输入字符串命令。

testbuf1

程序代码：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. int main()
  4. {
  5. 	printf("hello");
  6. 	fflush(stdout);
  7. 	while(1);
  8. }

运行效果：

testbuf2

程序代码：

  1. #include <stdio.h>
  2. int main()
  3. {
  4. 	printf("hello\n");
  5. 	while(1);
  6. }

运行效果：

testbuf3

程序代码：

  1. #include <stdio.h>
  3. int main()
  4. {
  5. 	fprintf(stdout, "1234", 5);
  6. 	fprintf(stderr, "abcd", 4);
  7. }

运行效果：

分析：在默认情况下，stdout是行缓冲的，他的输出会放在一个buffer里面，只有到换行的时候，才会输出到屏幕。而stderr是无缓冲的，会直接输出。所以输出结果为：abcd1234

testpid.c

程序代码：

  1. #include <stdio.h>
  2. #include <unistd.h>
  4. #include <sys/types.h>
  6. int main()
  7. {
  8. 	printf("my pid: %d \n", getpid());//获取当前进程pid
  9. 	printf("my parent's pid: %d \n", getppid());//获取当前进程父进程pid
  10. 	return 0;
  11. }

运行效果：

testpp.c

程序代码：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. int main()
  4. {
  5. 	char **pp;
  6. 	pp[0] = malloc(20);
  8. 	return 0;
  9. }

运行效果：

testsystem.c

程序代码：

  1. #include	<stdlib.h>
  3. int main ( int argc, char *argv[] )
  4. {
  6. 	system(argv[1]);
  7. 	system(argv[2]);
  8. 	return EXIT_SUCCESS;
  9. }
  • system函数：

system()会调用fork()产生子进程，由子进程来调用/bin/sh-c string来执行参数string字符串所代表的命令，此命令执行完后随即返回原调用的进程。在调用system()期间SIGCHLD 信号会被暂时搁置，SIGINT和SIGQUIT 信号则会被忽略。 返回值 =-1:出现错误 =0:调用成功但是没有出现子进程 >0:成功退出的子进程的id 如果system()在调用/bin/sh时失败则返回127，其他失败原因返回-1。若参数string为空指针(NULL)，则返回非零值>。如果system()调用成功则最后会返回执行shell命令后的返回值，但是此返回值也有可能为 system()调用/bin/sh失败所返回的127，因此最好能再检查errno 来确认执行成功。

运行效果：

waitdemo1.c

程序代码：

  1. #include	<stdio.h>
  2. #include    <stdlib.h>
  3. #include    <sys/types.h>
  4. #include    <sys/wait.h>
  5. #include    <unistd.h>
  7. #define	DELAY	4
  9. void child_code(int delay)
  10. {
  11. 	printf("child %d here. will sleep for %d seconds\n", getpid(), delay);
  12. 	sleep(delay);
  13. 	printf("child done. about to exit\n");
  14. 	exit(17);
  15. }
  17. void parent_code(int childpid)
  18. {
  19. 	int wait_rv=0;		/* return value from wait() */
  20. 	wait_rv = wait(NULL);//子进程成功结束返回子进程PID，没有子进程则返回-1。
  21. 	printf("done waiting for %d. Wait returned: %d\n",
  22. 			childpid, wait_rv);
  23. }
  24. int main()
  25. {
  26. 	int  newpid;
  27. 	printf("before: mypid is %d\n", getpid());
  28. 	if ( (newpid = fork()) == -1 )
  29. 		perror("fork");
  30. 	else if ( newpid == 0 )
  31. 		child_code(DELAY);
  32. 	else
  33. 		parent_code(newpid);
  35. 	return 0;
  36. }

运行效果:

waitdemo2.c

程序代码：

#include <stdio.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <unistd.h>

  1. #define	DELAY	10
  3. void child_code(int delay)
  4. {
  5. 	printf("child %d here. will sleep for %d seconds\n", getpid(), delay);
  6. 	sleep(delay);
  7. 	printf("child done. about to exit\n");
  8. 	exit(27);
  9. }
  11. void parent_code(int childpid)
  12. {
  13. 	int wait_rv;
  14. 	int child_status;
  15. 	int high_8, low_7, bit_7;
  17. 	wait_rv = wait(&child_status);
  18. 	printf("done waiting for %d. Wait returned: %d\n", childpid, wait_rv);
  20. 	high_8 = child_status >> 8;     /* 1111 1111 0000 0000 */
  21. 	low_7  = child_status & 0x7F;   /* 0000 0000 0111 1111 */
  22. 	bit_7  = child_status & 0x80;   /* 0000 0000 1000 0000 */
  23. 	printf("status: exit=%d, sig=%d, core=%d\n", high_8, low_7, bit_7);
  24. }
  26. int main()
  27. {
  28. 	int  newpid;
  30. 	printf("before: mypid is %d\n", getpid());
  32. 	if ( (newpid = fork()) == -1 )
  33. 		perror("fork");
  34. 	else if ( newpid == 0 )
  35. 		child_code(DELAY);
  36. 	else
  37. 		parent_code(newpid);
  38. }

运行结果：

argtest.c

程序代码：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include "argv.h"
  5. int main(int argc, char *argv[]) {
  6. char delim[] = " \t";
  7. int i;
  8. char **myargv;
  9.    int numtokens;
  11.    if (argc != 2) {
  12.      fprintf(stderr, "Usage: %s string\n", argv[0]);
  13. 	  return 1;
  14. }
  15. if ((numtokens = makeargv(argv[1], delim, &myargv)) == -1) {
  16. 	  fprintf(stderr, "Failed to construct an argument array for %s\n", argv[1]);
  17.  	 return 1;
  18. }
  19. printf("The argument array contains:\n");
  20. for (i = 0; i < numtokens; i++)
  21. 	  printf("%d:%s\n", i, myargv[i]);
  23.    execvp(myargv[0], myargv);
  25.    return 0;
  26. }

功能：将输入字符串当做系统命令执行。

运行结果：

environ.c

程序代码：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. int main(void)
  5. {
  6. 	printf("PATH=%s\n", getenv("PATH"));
  7. 	setenv("PATH", "hello", 1);
  8. 	printf("PATH=%s\n", getenv("PATH"));
  9. #if 0
  10. 	printf("PATH=%s\n", getenv("PATH"));
  11. 	setenv("PATH", "hellohello", 0);
  12. 	printf("PATH=%s\n", getenv("PATH"));
  14. 	printf("MY_VER=%s\n", getenv("MY_VER"));
  15. 	setenv("MY_VER", "1.1", 0);
  16. 	printf("MY_VER=%s\n", getenv("MY_VER"));
  17. 	#endif
  18. 	return 0;
  19. }

运行效果：

environvar.c

运行代码：

  1. #include <stdio.h>
  2. int main(void)
  3. {
  4. 	extern char **environ;
  5. 	int i;
  6. 	for(i = 0; environ[i] != NULL; i++)
  7. 		printf("%s\n", environ[i]);
  9. 	return 0;
  10. }

功能：打印环境变量。

运行效果：

sigactdemo.c

程序代码：

  1. #include	<stdio.h>
  2. #include    <unistd.h>
  3. #include	<signal.h>
  4. #define	INPUTLEN	100
  5. void inthandler();
  6. int main()
  7. {
  8. 	struct sigaction newhandler;
  9. 	sigset_t blocked;
  10. 	char x[INPUTLEN];
  11. 	newhandler.sa_handler = inthandler;//新的信号处理函数效果与signal（）类似
  12. 	newhandler.sa_flags = SA_RESTART|SA_NODEFER
  13. 	|SA_RESETHAND;//设置信号处理相关操作
  14. 	sigemptyset(&blocked);	//将blocked信号集初始化，并清空。
  15. 	sigaddset(&blocked, SIGQUIT);//将SIGQUIT信号加入参数blocked信号集。
  16. 	newhandler.sa_mask = blocked;//暂时将block信号阻塞
  17. 	if (sigaction(SIGINT, &newhandler, NULL) == -1)
  18. 		perror("sigaction");
  19. 	else
  20. 		while (1) {
  21. 			fgets(x, INPUTLEN, stdin);
  22. 			printf("input: %s", x);
  23. 		}
  24. 	return 0;
  25. }
  26. void inthandler(int s)
  27. {
  28. 	printf("Called with signal %d\n", s);
  29. 	sleep(s * 4);
  30. 	printf("done handling signal %d\n", s);
  31. }

sigation结构体：

  1. struct sigaction {
  3. void (*sa_handler)(int);
  4. void (*sa_sigaction)(int, siginfo_t *, 	void *);
  5. sigset_t sa_mask;
  6. int sa_flags;
  7. void (*sa_restorer)(void);
  8. }
  • sa_handler此参数和signal()的参数handler相同，代表新的信号处理函数，其他意义请参考signal()。
  • sa_mask 指定在信号处理程序执行过程中，哪些信号应当被阻塞。默认当前信号本身被阻塞。
  • sa_restorer 已过时，POSIX不支持它，不应再使用。
  • sa_flags 用来设置信号处理的其他相关操作，下列的数值可用。
  • sa_flags还可以设置其他标志：
    • SA_RESETHAND：当调用信号处理函数时，将信号的处理函数重置为缺省值SIG_DFL
    • SA_RESTART：如果信号中断了进程的某个系统调用，则系统自动启动该系统调用
    • SA_NODEFER ：一般情况下， 当信号处理函数运行时，内核将阻塞该给定信号。但是如果设置了 SA_NODEFER标记， 那么在该信号处理函数运行时，内核将不会阻塞该信号

运行效果：

sigactdemo2.c

  1. #include <unistd.h>
  2. #include <signal.h>
  3. #include <stdio.h>
  5. void sig_alrm( int signo )
  6. {
  7. 	/*do nothing*/
  8. }
  10. unsigned int mysleep(unsigned int nsecs)
  11. {
  12. 	struct sigaction newact, oldact;
  13. 	unsigned int unslept;
  15. 	newact.sa_handler = sig_alrm;//设置处理函数
  16. 	sigemptyset( &newact.sa_mask );//清空newact的阻塞信号集
  17. 	newact.sa_flags = 0;//设置信号处理的其它操作为空
  18. 	sigaction( SIGALRM, &newact, &oldact );//显式取消阻塞信号
  20. 	alarm( nsecs );//设置闹钟
  21. 	pause();
  23. 	unslept = alarm ( 0 );//取消闹钟，并返回剩余时间
  24. 	sigaction( SIGALRM, &oldact, NULL );
  26. 	return unslept;
  27. }
  29. int main( void )
  30. {
  31. 	while( 1 )
  32. 	{
  33. 		mysleep( 2 );
  34. 		printf( "Two seconds passed\n" );
  35. 	}
  37. 	return 0;
  38. }

运行效果：

sigdemo1.c

  1. #include	<stdio.h>
  2. #include	<signal.h>
  3. void	f(int);
  4. int main()
  5. {
  6. 	int	i;
  7. 	signal( SIGINT, f );//改变键盘ctril+C处理函数
  8. 	for(i=0; i<5; i++ ){
  9. 		printf("hello\n");
  10. 		sleep(2);
  11. 	}
  13. 	return 0;
  14. }
  16. void f(int signum)
  17. {
  18. 	printf("OUCH!\n");
  19. }

运行效果：

sigdemo2.c

  1. #include	<stdio.h>
  2. #include	<signal.h>
  4. main()
  5. {
  6. 	signal( SIGINT, SIG_IGN );//设置忽略Ctrl+C中断信号。
  8. 	printf("you can't stop me!\n");
  9. 	while( 1 )
  10. 	{
  11. 		sleep(1);
  12. 		printf("haha\n");
  13. 	}
  14. }

运行效果：

sigdemo3.c

程序代码：

  1. #include	<stdio.h>
  2. #include    <string.h>
  3. #include	<signal.h>
  4. #include    <unistd.h>
  6. #define	INPUTLEN	100
  8. int main(int argc, char *argv[])
  9. {
  10. 	void inthandler(int);
  11. 	void quithandler(int);
  12. 	char input[INPUTLEN];
  13. 	int nchars;
  15. 	signal(SIGINT, inthandler);//^C
  16. 	signal(SIGQUIT, quithandler);//^\
  18. 	do {
  19. 		printf("\nType a message\n");
  20. 		nchars = read(0, input, (INPUTLEN - 1));
  21. 		if (nchars == -1)
  22. 			perror("read returned an error");
  23. 		else {
  24. 			input[nchars] = '\0';
  25. 			printf("You typed: %s", input);
  26. 		}
  27. 	}
  28. 	while (strncmp(input, "quit", 4) != 0);
  29. 	return 0;
  30. }
  32. void inthandler(int s)
  33. {
  34. 	printf(" Received signal %d .. waiting\n", s);
  35. 	sleep(2);
  36. 	printf("  Leaving inthandler \n");
  37. }
  39. void quithandler(int s)
  40. {
  41. 	printf(" Received signal %d .. waiting\n", s);
  42. 	sleep(3);
  43. 	printf("  Leaving quithandler \n");
  44. }

运行效果：

listargs.c

程序代码

  1. #include	<stdio.h>
  3. main( int ac, char *av[] )
  4. {
  5. 	int	i;
  7. 	printf("Number of args: %d, Args are:\n", ac);//ac为传入参数的个数。
  8. 	for(i=0;i<ac;i++)
  9. 		printf("args[%d] %s\n", i, av[i]);
  11. 	fprintf(stderr,"This message is sent to stderr.\n");
  12. }

运行效果：



pipe.c

  1. #include	<stdio.h>
  2. #include    <stdlib.h>
  3. #include	<unistd.h>
  5. #define	oops(m,x)	{ perror(m); exit(x); }
  7. int main(int ac, char **av)
  8. {
  9. 	int	thepipe[2],
  10. 		newfd,
  11. 		pid;
  12. 	//判断管道输入格式是否正确
  13. 	if ( ac != 3 ){
  14. 		fprintf(stderr, "usage: pipe cmd1 cmd2\n");
  15. 		exit(1);
  16. 	}
  17. 	//管道建立失败，输出错误信息
  18. 	if ( pipe( thepipe ) == -1 )
  19. 		oops("Cannot get a pipe", 1);
  20. 	//子进程创建失败，输出错误信息
  21. 	if ( (pid = fork()) == -1 )
  22. 		oops("Cannot fork", 2);
  24. 	if ( pid > 0 ){
  25. 		close(thepipe[1]);	
  27. 		if ( dup2(thepipe[0], 0) == -1 )//将thepipe[0]重定向到标准输入
  28. 			oops("could not redirect stdin",3);
  30. 		close(thepipe[0]);
  31. 		execlp( av[2], av[2], NULL);//试着执行av[2]中的命令
  32. 		oops(av[2], 4);
  33. 	}
  35. 	close(thepipe[0]);		
  37. 	if ( dup2(thepipe[1], 1) == -1 )//将thepipe[1]重定向到标准输出
  38. 		oops("could not redirect stdout", 4);
  40. 	close(thepipe[1]);
  41. 	execlp( av[1], av[1], NULL);//试着执行av[1]中的命令
  42. 	oops(av[1], 5);
  43. }

  • pipe()：

    1. 头文件 #include<unistd.h>

    2. 定义函数： int pipe(int filedes[2]);

    3. 函数说明： pipe()会建立管道，并将文件描述词由参数filedes数组返回。

      filedes[0]为管道里的读取端

      filedes[1]则为管道的写入端。

    4. 返回值： 若成功则返回零，否则返回-1，错误原因存于errno中。

execlp()：

从PATH 环境变量所指的目录中查找符合参数file的文件名，找到后便执行该文件，然后将第二个以后的参数当做该文件的argv[0]、argv[1]……，最后一个参数必须用空指针(NULL)作结束。如果用常数0来表示一个空指针，则必须将它强制转换为一个字符指针，否则将它解释为整形参数，如果一个整形数的长度与char * 的长度不同，那么exec函数的实际参数就将出错。如果函数调用成功,进程自己的执行代码就会变成加载程序的代码,execlp()后边的代码也就不会执行了。

返回值：

如果执行成功则函数不会返回，执行失败则直接返回-1，失败原因存于errno 中。

运行效果：

pipedemo2.c

  1. #include	<stdio.h>
  2. #include    <stdlib.h>
  3. #include    <string.h>
  4. #include    <unistd.h>
  6. #define	CHILD_MESS	"I want a cookie\n"
  7. #define	PAR_MESS	"testing..\n"
  8. #define	oops(m,x)	{ perror(m); exit(x); }
  10. main()
  11. {
  12. 	int	pipefd[2];
  13. 	int	len;
  14. 	char	buf[BUFSIZ];
  15. 	int	read_len;
  17. 	if ( pipe( pipefd ) == -1 )
  18. 		oops("cannot get a pipe", 1);
  20. 	switch( fork() ){
  21. 		case -1:
  22. 			oops("cannot fork", 2);
  24. 		case 0:
  25. 			len = strlen(CHILD_MESS);
  26. 			while ( 1 ){
  27. 				if (write( pipefd[1], CHILD_MESS, len) != len )
  28. 					oops("write", 3);
  29. 				sleep(5);
  30. 			}
  32. 		default:
  33. 			len = strlen( PAR_MESS );
  34. 			while ( 1 ){
  35. 				if ( write( pipefd[1], PAR_MESS, len)!=len )
  36. 					oops("write", 4);
  37. 				sleep(1);
  38. 				read_len = read( pipefd[0], buf, BUFSIZ );
  39. 				if ( read_len <= 0 )
  40. 					break;
  41. 				write( 1 , buf, read_len );
  42. 			}
  43. 	}
  44. }

运行结果：

pipedemo.c

  1. #include	<stdio.h>
  2. #include    <stdlib.h>
  3. #include    <string.h>
  4. #include	<unistd.h>
  6. int main()
  7. {
  8. 	int	len, i, apipe[2];
  9. 	char	buf[BUFSIZ];		
  11. 	if ( pipe ( apipe ) == -1 ){
  12. 		perror("could not make pipe");
  13. 		exit(1);
  14. 	}
  15. 	printf("Got a pipe! It is file descriptors: { %d %d }\n",
  16. 						apipe[0], apipe[1]);
  18. 	while ( fgets(buf, BUFSIZ, stdin) ){
  19. 		len = strlen( buf );
  20. 		if (  write( apipe[1], buf, len) != len ){
  21. 			perror("writing to pipe");
  22. 			break;
  23. 		}
  24. 		for ( i = 0 ; i<len ; i++ )
  25. 			buf[i] = 'X' ;
  26. 		len = read( apipe[0], buf, BUFSIZ ) ;
  27. 		if ( len == -1 ){
  28. 			perror("reading from pipe");
  29. 			break;
  30. 		}
  31. 		if ( write( 1 , buf, len ) != len ){	//将标准输入写到标准输出
  32. 			perror("writing to stdout");
  33. 			break;
  34. 		}
  35. 	}
  36. }

运行结果：


stdinerdir1.c

程序代码：

  1. #include	<stdio.h>
  2. #include	<fcntl.h>
  4. int main()
  5. {
  6. 	int	fd ;
  7. 	char	line[100];
  9. 	fgets( line, 100, stdin ); printf("%s", line );
  10. 	fgets( line, 100, stdin ); printf("%s", line );
  11. 	fgets( line, 100, stdin ); printf("%s", line );
  13. 	close(0);
  14. 	fd = open("/etc/passwd", O_RDONLY);//读取passwd文件到stdin
  15. 	if ( fd != 0 ){
  16. 		fprintf(stderr,"Could not open data as fd 0\n");
  17. 		exit(1);
  18. 	}
  20. 	fgets( line, 100, stdin ); printf("%s", line );
  21. 	fgets( line, 100, stdin ); printf("%s", line );
  22. 	fgets( line, 100, stdin ); printf("%s", line );
  23. }

stdinredir2.c

  1. #include		<stdio.h>
  2. #include    <stdlib.h>
  3. #include	<fcntl.h>
  5. //#define	CLOSE_DUP
  6. //#define	USE_DUP2	
  8. main()
  9. {
  10. 	int	fd ;
  11. 	int	newfd;
  12. 	char	line[100];
  14. 	fgets( line, 100, stdin ); printf("%s", line );
  15. 	fgets( line, 100, stdin ); printf("%s", line );
  16. 	fgets( line, 100, stdin ); printf("%s", line );
  18. 	fd = open("data", O_RDONLY);
  19. #ifdef CLOSE_DUP
  20. 	close(0);
  21. 	newfd = dup(fd);
  22. #else
  23. 	newfd = dup2(fd,0);	//将fd重定向到标准输入
  24. #endif
  25. 	if ( newfd != 0 ){
  26. 		fprintf(stderr,"Could not duplicate fd to 0\n");
  27. 		exit(1);
  28. 	}
  29. 	close(fd);			
  31. 	fgets( line, 100, stdin ); printf("%s", line );
  32. 	fgets( line, 100, stdin ); printf("%s", line );
  33. 	fgets( line, 100, stdin ); printf("%s", line );
  34. }

运行效果：(没有data文件，无法获取文件描述符，重定向失败)

testtty.c

  1. #include <unistd.h>
  3. int main()
  4. {
  5. 	char *buf = "abcde\n";
  6. 	write(0, buf, 6);//将字符串写到标准输入
  7. }

运行效果：

whotofile.c

  1. #include	<stdio.h>
  2. #include    <stdlib.h>
  3. #include    <unistd.h>
  5. int main()
  6. {
  7. 	int	pid ;
  8. 	int	fd;
  10. 	printf("About to run who into a file\n");
  12. 	if( (pid = fork() ) == -1 ){
  13. 		perror("fork"); exit(1);
  14. 	}
  15. 	if ( pid == 0 ){
  16. 		close(1);				/* close, */
  17. 		fd = creat( "userlist", 0644 );		/* then open *///以写的方式创建一个文件，因为前面关闭了文件描述符1，所以fd=1，为标准输出。
  18. 		execlp( "who", "who", NULL );		/* and run	*///执行who命令，输出到文件表描述符1中。
  19. 		perror("execlp");
  20. 		exit(1);
  21. 	}
  22. 	if ( pid != 0 ){
  23. 		wait(NULL);
  24. 		printf("Done running who.  results in userlist\n");
  25. 	}
  27. 	return 0;
  28. }

运行结果：

consumer.c

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <fcntl.h>
  5. #include <limits.h>
  6. #include <sys/types.h>
  7. #include <sys/stat.h>
  9. #define FIFO_NAME "/tmp/myfifo"
  10. #define BUFFER_SIZE PIPE_BUF
  12. int main()
  13. {
  14. 	int pipe_fd;
  15. 	int res;
  17. 	int open_mode = O_RDONLY;
  18. 	char buffer[BUFFER_SIZE + 1];
  19. 	int bytes = 0;
  21. 	memset(buffer, 0, sizeof(buffer));//数组置零
  23. 	printf("Process %d opeining FIFO O_RDONLY \n", getpid());
  24. 	pipe_fd = open(FIFO_NAME, open_mode);
  25. 	printf("Process %d result %d\n", getpid(), pipe_fd);
  27. 	if (pipe_fd != -1) {
  28. 		do {
  29. 			res = read(pipe_fd, buffer, BUFFER_SIZE);
  30. 			bytes += res;
  31. 		} while (res > 0);
  32. 		close(pipe_fd);
  33. 	} else {
  34. 		exit(EXIT_FAILURE);
  35. 	}
  37. 	printf("Process %d finished, %d bytes read\n", getpid(), bytes);
  38. 	exit(EXIT_SUCCESS);
  39. }

运行效果：

文件不存在，打开失败。

文件存在读取成功。

producer.c

程序代码：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <fcntl.h>
  5. #include <limits.h>
  6. #include <sys/types.h>
  7. #include <sys/stat.h>
  9. #define FIFO_NAME "/tmp/myfifo"
  10. #define BUFFER_SIZE PIPE_BUF
  11. #define TEN_MEG (1024 * 1024 * 10)
  13. int main()
  14. {
  15. 	int pipe_fd;
  16. 	int res;
  17. 	int open_mode = O_WRONLY;
  19. 	int bytes = 0;
  20. 	char buffer[BUFFER_SIZE + 1];
  21. 	//判断文件是否存在。
  22. 	if (access(FIFO_NAME, F_OK) == -1) {
  23. 		res = mkfifo(FIFO_NAME, 0777);//创建一个FIFO文件
  24. 		if (res != 0) {
  25. 			fprintf(stderr, "Could not create fifo %s \n",
  26. 			FIFO_NAME);
  27. 			exit(EXIT_FAILURE);
  28. 		}
  29. 	}
  31. 	printf("Process %d opening FIFO O_WRONLY\n", getpid());
  32. 	pipe_fd = open(FIFO_NAME, open_mode);
  33. 	printf("Process %d result %d\n", getpid(), pipe_fd);
  35. 	if (pipe_fd != -1) {
  36. 		while (bytes < TEN_MEG) {
  37. 			res = write(pipe_fd, buffer, BUFFER_SIZE);
  38. 			if (res == -1) {
  39. 				fprintf(stderr, "Write error on pipe\n");
  40. 				exit(EXIT_FAILURE);
  41. 			}
  42. 			bytes += res;
  43. 		}
  44. 		close(pipe_fd);
  45. 	} else {
  46. 		exit(EXIT_FAILURE);
  47. 	}
  49. 	printf("Process %d finish\n", getpid());
  50. 	exit(EXIT_SUCCESS);
  51. }

access()：

判断是否具有存取文件的权限

相关函数

stat，open，chmod，chown，setuid，setgid

表头文件

include<unistd.h>

定义函数

int access(const char * pathname, int mode);

函数说明

access()会检查是否可以读/写某一已存在的文件。参数mode有几种情况组合:

R_OK，W_OK，X_OK 和F_OK。

R_OK，W_OK与X_OK用来检查文件是否具有读取、写入和执行的权限。

F_OK则是用来判断该文件是否存在。由于access()只作权限的核查，并不理会文件形态或文件内容，因此，如果一目录表示为“可写入”，表示可以在该目录中建立新文件等操作，而非意味此目录可以被当做文件处理。例如，你会发现DOS的文件都具有“可执行”权限，但用execve()执行时则会失败。

返回值

若所有欲查核的权限都通过了检查则返回0值，表示成功，只要有一权限被禁止则返回-1。

mkfifo()

mkfifo函数的作用是在文件系统中创建一个文件(该文件之前必须不存在)，该文件用于提供FIFO功能，即命名管道。前边讲的那些管道都没有名字，因此它们被称为匿名管道，或简称管道。

#include <sys/types.h>

  1.   #include <sys/stat.h>
  2.   int mkfifo( const char *pathname, mode_t mode );

mkfifo函数需要两个参数，第一个参数（pathname）是将要在文件系统中创建的一个专用文件。第二个参数（mode）用来规定FIFO的读写权限。Mkfifo函数如果调用成功的话，返回值为0；如果调用失败返回值为-1。

运行结果：

遇到的问题及解决

1.sigactdemo.c中的inthandler中的参数int s是怎么传进去的？

解决方法：在博客园提问。

inthandler被当做函数指针传给了newhandler.sa_handler

后面调用int sigaction(int signum,const struct sigaction *act ,struct sigaction *oldact);

它的第一个参数signum指定的信号编号就是用来设置这个信号的处理函数的。信号SIGINT序号为2。

命令kill -l可以查看各信号的序号。

2.运行testpp时遇到段错误（核心已转储）。

解决方法：在博客园提问。

二维数组越界申请空间。

将代码改为

  1. pp=malloc(20);

即可编译成功。

参考资料

《深入理解计算机系统》第8章异常控制流

进程&信号&管道实践学习记录的更多相关文章

  1. PHP 中的多进程使用，进程通信、进程信号等详解

    多进程环境要求 Linux 系统 php-cli 模式 pcntl 扩展 或 swoole 扩展 pcntl 扩展 <?php $str = "hello world!" . ...

  2. linux 进程通信 管道

    1. 管道概述及相关API应用 1.1 管道相关的关键概念 管道是Linux支持的最初Unix IPC形式之一,具有以下特点: 管道是半双工的,数据只能向一个方向流动:需要双方通信时,需要建立起两个管 ...

  3. 进程信号的未决状态（pending status）

    这两天看了apue有关进程信号的部分,觉得未决状态这个词很是不一般,呵呵.一开始当我看到这个词,我不理解,什么意思呢,读了好几遍.不知道是书里面讲的晦涩难懂,还是脑子越来越不行了,就是没有搞明白.后来 ...

  4. Linux 两组信号对比(关闭和停止进程信号)

    之前看信号的时候,没有太注意不同信号的对比．今天再次看到的时候,突然感觉对一些信号,非常相似,乃至非常容易混淆．今天周末就抽空总结一下． 一.关闭进程信号 常见的4中关闭进程信号是SIGKILL,SI ...

  5. 【C】——sigprocmask 阻塞进程信号

    1.有时候不希望在接到信号时就立即停止当前执行,去处理信号,同时也不希望忽略该信号,而是延时一段时间去调用信号处理函数.这种情况是通过阻塞信号实现的. 2.信号阻塞和忽略信号的区别. 阻塞的概念和忽略 ...

  6. 进程通信方式-管道pipe

    管道是两个进程间进行单向通信的机制.因为管道传递数据的单向性,管道又称之为半双工管道. 1.数据只能从一个进程流向另一个进程(其中一个写管道,另一个读管道):如果要进行全双工通信,需要建立两个管道. ...

  7. linux进程的管道通信

    linux进程的管道通信 要求 编程实现进程的管道通信,掌握管道通信的同步和互斥机制. 相关函数 pipe管道 指用于连接一个读进程和一个写进程以实现他们之间通信的一个共享文件,又名pipe文件.向管 ...

  8. Cobalt Strike系列教程第四章：文件/进程管理与键盘记录

    Cobalt Strike系列教程分享如约而至,新关注的小伙伴可以先回顾一下前面的内容: Cobalt Strike系列教程第一章:简介与安装 Cobalt Strike系列教程第二章:Beacon详 ...

  9. 进程-IPC 管道 (一)

    详见:https://github.com/ZhangzheBJUT/linux/blob/master/IPC(%E4%B8%80).md 一 IPC 概述 进程间通信就是在不同进程之间传播或交换信 ...

随机推荐

  1. MYSQL的慢查询两个方法

    对于排查问题找出性能瓶颈来说,最容易发现并解决的问题就是MYSQL的慢查询以及没有得用索引的查询. ================================================== ...

  2. log4net资料收集

    Log4net 日志使用介绍 http://www.cnblogs.com/jys509/p/4699813.html log4net Tutorial http://www.codeproject. ...

  3. Effective Java 09 Always override hashCode when you override equals

    Failure to do so will result in a violation of the general contract for Object.hashCode, which will ...

  4. docker-3 基础命令

    创建镜像 创建镜像的方法有三种: 基于已有的容器创建 基于本地模板导入 基于dockerfile 基于已有的容器创建 主要使用docker commit 命令,命令格式: docker commit ...

  5. Java SWT 做计算器。

    java  --  swt  - -  计算器 环境搭建 安装java.eclipse.以及对应的swt插件. 开始工程 建立工程: 在java下建立一个在其他 —- WindowsBuilder — ...

  6. 用shell脚本批量修改文件后缀名

    早上本想将一些照片上传到相册中,但是由于所有照片的扩展名都是JPG而不是小写的jpg,因此造成了“格式不正确”而不能上传照片.此刻就产生了这样一个问题:使用shell脚本如何批量将所有文件的扩展名JP ...

  7. USACO section1.1 Broken Necklace

    /* ID: vincent63 LANG: C TASK: beads */ #include <stdio.h> #include<stdlib.h> #include&l ...

  8. Listview的点击事件

    上篇文章总结了如何自定义listview的显示内容,然而listview不能只是提供显示功能,还必须能够点击它显示一些东西: listView.setOnItemClickListener(new O ...

  9. CentOS安装Hypernetes相关问题解法

    1.手动编译hyper缺少libdevmapper.h git clone -b v2_02_103 https://git.fedorahosted.org/git/lvm2.git /usr/lo ...

  10. 最小生成树 kruskal hdu 5723 Abandoned country

    题目链接:hdu 5723 Abandoned country 题目大意:N个点,M条边:先构成一棵最小生成树,然后这个最小生成树上求任意两点之间的路径长度和,并求期望 /************** ...