linux 系统编程-学习笔记7-进程/fork/vfork/exec函数族

进程：程序的执行实例被称为进程。

u-boot ==>Image ==>根文件系统==>init进程(1)

==>exec执行进程==>启动代码==>main{==>传入环境变量

exit/return ==>1)刷新缓冲区，2）关闭所有打开的文件描述符，3）调用清理函数 ==>系统
_exit/_Exit ==>系统
}
==================================================================================

进程的操作：
1.进程的创建
2.进程的执行
3.进程的退出

进程的几种状态：
1.等待/就绪态
2.运行态
3.终止态
4.僵尸态


===================================================================================
创建一个新的进程：
pid_t fork(void); (pid_t -->int)
fork之后会有两个返回值：
 > 0 : 返回的值是新建子进程的ID==>返回给父进程
 = 0 : 返回的是子进程
 = -1: 错误
 
父进程fork一个子进程之后，子进程继承父进程的资源空间（几乎所有的）
==>之后，父，子进程自己拥有独立的资源空间
 ___________________________________________
 typedef __kernel_pid_t pid_t;`
 typedef int __kernel_pid_t;
 ___________________________________________
 
pid_t getpid(void);
:获取本进程的进程ID
pid_t getppid(void);
:过去本进程的父进程ID



===============================================
进程间切换条件：
(子进程切换到父进程)
1.时间片结束
2.子进程执行结束
3.子进程被阻塞
4.子进程被中断
5.被优先级高（父进程）抢占

注意：保护现场(目的是能切换回来)

====================================================

#include <sys/types.h>
#include <sys/wait.h>

pid_t wait(int *status);
功能：等待子进程返回,子进程返回的状态保存在变量status中，如果不关系则填NULL,
      wait返回所等待的子进程的进程ID
注意：如果父进程不调用wait/waitpid等待子进程返回，回收其资源，则该子进程变成僵尸进程


僵尸进程：进程结束之后，其所占用的资源没有被释放，则称之为僵尸进程
___________________________________________________________________

通过status中的值可以判断子进程退出的状态:
WIFEXITED(status)
正常返回，返回的值由子进程中exit/_exit/return返回的值确定
WEXITSTATUS(status)
:获取返回的值


WIFSIGNALED(status)
:被信号打断
WTERMSIG(status)
:获取到打断该子进程的信号

==============================================================
pid_t waitpid(pid_t pid, int *status, int options);

waitpid(-1, &status, 0);//功能和wait是一样的

pid_t vfork(void);
1.功能同fork几乎一样

相同点：
1.功能同fork一样，创建一个新的进程
2.vfork之后会有两个返回值：
 > 0 : 返回的值是新建子进程的ID==>返回给父进程
 = 0 : 返回的是子进程
 = -1: 错误

 ___________________________________________
不同点：
1.fork : 父进程fork一个子进程之后，子进程继承父进程的资源空间（几乎所有的）
==>之后，父，子进程自己拥有独立的资源空间
  vfork:父，子进程共享资源空间

2.fork ：父，子进程谁先运行，由内核确定
  vfork: 保证子进程先运行
==>调用exec执行进程
==>所以只有调用exit退出子进程之后父进程才能执行
================================================================================

exec函数族：
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg,
..., char * const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);


l:表示跟上一系列的参数
p:表示可以自动的去匹配路径，不给必绝对路径
e:表示可以传入环境变量参数数组
v:表示所有的参数可以通过数组传递

path/file: 命令　（绝对路径/相对路径）
arg      : 参数列表

===========================================================================================
前面的五个exec函数族都是由execve封装而来的，真正的系统调用是execve
int execve(const char *filename, char *const argv[],
                  char *const envp[]);

filname : 文件命名／命令
argv    : 命令参数选项的字符串数组
envp    : 环境变量数组

/*练习：实现一个简单的shell终端.*/

#include <stdio.h>
#include <sys/types.h>
#include <pwd.h>
#include <shadow.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

struct user
{
	char username[100];		//用户名
	char psd[100];			//原始密码
	char salt[100];			//密码种子
	char cmd[1024];			//命令
};

struct user user;

int login(void);
void show_shell(void);
void get_commond(void);
void do_commond(void);

int main(int argc, char *argv[])
{
	/*用户登录*/
	if(-1 == login())
	{
		printf("\nlogin faild .......\n");
		return -1;
	}

	while(1)
	{
		show_shell();	//显示shell终端
		get_commond();	//获取命令
		do_commond();	//处理命令
	}


	return 0;
}

/********************************************
 *功能：判断用户名和密码是否匹配
 *返回值：
 *  匹配：返回0
 *  错误：返回-1
 * *****************************************/
int login(void)
{
	int ret;
	struct passwd *pw = NULL;
	struct spwd *sp = NULL;
	char *dol = NULL;
	char *pssd = NULL;
	
	system("clear");

	/*输入用户名*/
	write(1,"username : ",strlen("username : "));
	ret= read(0,user.username,sizeof(user.username)-1);
	if(ret > 0)
	{
		user.username[ret-1] = '\0';
	}

	/*输入用户密码**/
	write(1,"passwd : ",strlen("passwd : "));

	system("stty -echo -raw");
	ret = read(0,user.psd,sizeof(user.psd));
	if(ret > 0)
	{
		user.psd[ret-1] = '\0';
	}
	system("stty echo");

	/*判断用户是否有密码*/
	pw = getpwnam(user.username);
	if(NULL == pw)
	{
		return -1;
	}
	if(strcmp(pw->pw_passwd,"x"))
	{
		//没有密码
		return -1;
	}
	
	/*获取用户加密密码*/
	sp = getspnam(user.username);
	if(NULL == sp)
	{
		return -1;
	}
	strcpy(user.salt,sp->sp_pwdp);
	
	dol = strrchr(user.salt,'$');
	if(NULL == dol)
	{
		return -1;
	}
	dol++;
	*dol = '\0';

	/*通过crypt进行密码加密*/
	pssd = (char *)crypt(user.psd,user.salt);
	if(NULL == pssd)
	{
		return -1;
	}

	if(strcmp(pssd,sp->sp_pwdp) == 0)
	{
		system("clear");
		printf("login success.....\n");
		sleep(2);
		return 0;
	}
	else
	{
		return -1;
	}
}

/*显示shell终端*/
void show_shell(void)
{
	char path[100] = {0};
	
	/*获取用户当前的绝对路径*/
	getcwd(path,99);	
	printf("%s@:%s&&& ",user.username,path);
	fflush(stdout);
}

/*获取命令*/
void get_commond(void)
{
	int ret;

	memset(user.cmd,0,sizeof(user.cmd));
	ret = read(0,user.cmd,sizeof(user.cmd));
	if(ret > 0)
	{
		user.cmd[ret-1] = '\0';
	}
}
/**前面的空格处理*/
void eat_white(char *str)
{
	int len;
	int i;

	i = 0;
	len = strlen(str);
	while(1)
	{
		if(isblank(str[i]))
		{
			i++;
		}
		else
		{
			 break;
		}
	}
	memmove((void *)&str[0],(void *)&str[i],len-i+1);
}

/*处理命令*/
void do_commond(void)
{
	pid_t pid;
	
	eat_white(user.cmd);
	if(strncmp(user.cmd,"exit",4) == 0)
	{
		exit(0);	//退出进程
	}
	else if(strncmp(user.cmd,"cd",2) == 0)
	{
		chdir(strchr(user.cmd,' ')+1);	//切换路径
	}
	else
	{
		pid = fork();
		if(0 == pid)
		{//子进程
			execlp("/bin/sh","sh","-c",user.cmd,NULL);
		}
		else if(pid > 0)
		{
			wait(NULL);	
		}
		else
		{
			perror("fork");
			exit(-1);
		}
	}
}


/******************************************************
  char *strchr(const char *s, int c);
  功能是从一个字符串的开头查找字符c,返回第一次查找到的位置
 ******************************************************/