首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >按下ls -l *.py并回车,shell都为我们做了什么?

按下ls -l *.py并回车,shell都为我们做了什么?

作者头像
somenzz
发布2021-12-02 11:11:24
6460
发布2021-12-02 11:11:24
举报
文章被收录于专栏:Python七号Python七号

你是否想过,当你在 shell 上执行一个命令时,unix 的 shell 到底做了哪些事情?shell 是如何理解和解释这些命令的?屏幕的背后都做些什么?比如说,当我们执行 ls -l *.py 的时候,shell 都做了哪些事情?了解了这些,可以更好的使用 Unix 类操作系统,今天我们就来一探究竟。

0、什么是 shell

shell 通常是一个命令行界面,它将操作系统的服务暴露给人类使用或其他程序。在 shell 启动后,shell 通常会通过显示提示来等待用户的输入。下图描述了基本的 UNIX 和 Windows shell 提示。

所以 shell 会提示用户输入命令。现在是用户输入命令的时候了。那么 shell 是如何获取用户输入的命令并进行解释的呢?为了理解这一点,让我们将它们分为 4 个步骤,分别是:

  1. 获取并解析用户输入
  2. 识别命令及命令的参数
  3. 查找命令
  4. 执行命令

现在详细展开:

1、获取并解析用户输入

比如说,在 shell 上输入了 ls -l *.py 并回车,shell 内部会调用一个叫 getline()「声明在#include <stdio.h>中,下同」 的函数来读取用户输入的命令,用户输入的命令字符串作为标准输入流,一旦按下回车,表示一行结束,getline() 就会将输入的字符串存储到缓冲区中。

ssize_t getline(char **restrict lineptr, size_t *restrict n, FILE *restrict stream);

函数参数说明:

  • lineptr: 缓冲区
  • n: 缓冲区大小
  • stream: 流,这里就是标准输入流

现在让我们看一下代码:

char *input_buffer;
size_t b_size;

b_size = 32; // size of the buffer
input_buffer = malloc(sizeof(char) * b_size); // the buffer to store the user input

getline(&input_buffer, &b_size, stdin); // gets the line and stores it in input_buffer

一旦用户按下回车,就会调用 getline() ,将用户输入的字符串或命令将存储在 input_buffer 中。所以现在 shell 已经获取了用户输入,那么下一步是什么?

2、识别命令及命令的参数

现在 shell 已经知道你输入了字符串是 'ls -l *.py' 但是,还需要知道这里面哪个是命令,哪个是命令的参数,谁来做这个事情呢?那就是函数 strtok()#include <string.h>」。

strtok() 将一个字符串标记为分隔符,在这个例子中分隔符是一个空格。所以一个空格告诉 strtok() 它是一个词的结尾。因此 input_buffer 中的第一个标记或单词是命令 (ls),其余的单词或标记(-l 和 *.py)是命令的参数。因此,一旦 shell 标记了字符串,它就会将它们存储在一个变量中,以便以后使用。

char *strtok(char *restrict str, const char *restrict delim);

参数说明:

  • str: 要标记的字符串
  • delim: 分隔符

函数 strtok() 接受字符串和分隔符作为参数,返回一个指向标记字符串的指针。具体的执行代码如下所示:

char *input_buffer, *args, *delim_args, *command_argv[50];
int i;

i = 0;
delim_args = " \t\r\n\v\f"; // the delimeters
args = strtok(input_buffer, delim_args); // stores the token inside args
while (args)
{
 command_argv[i] = args; // stores the token in command_argv
 args = strtok(NULL, delim_args);
 i++;
}
command_argv[i] = NULL; // sets the last entity of command_argv to NULL

command_argv 保存了命令字符串,其内容如下:

command_argv[0] = "ls"
command_argv[1] = "-l"
command_argv[2] = "*.py"
command_argv[3] = NULL

好了,command_argv[0] 是命令,其他的都是它的参数,最后一个是 NULL,表示命令的结束。命令字符串已经拆解完毕了,下一步就是查找命令。

3、查找命令

第二步已经知道,用户要执行的命令就是 ls,那么去哪里查找这个命令呢?shell 回去环境变量 PATH 中去查找,PATH 这个环境变量就是存储可执行命令的位置的。

不过,一个 PATH 存储的路径可不止一个:

如何在这么多路径中高效的查找到 ls 命令呢?这就需要 access()#include <unistd.h>」 函数:

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

参数及返回值说明:

  • pathname: 文件/可执行文件的路径
  • mode: 模式,我们使用 X_OK 来检查文件是否存在
  • 返回值:如果文件存在,返回 0,否则返回 -1
{
 char *path_buff, *path_dup, *paths, *path_env_name, *path[50];
 int i;

 i = 0;
 path_env_name = "PATH";
 path_buff = getenv(path_env_name); /* get the variable of PATH environment */
 path_dup = _strdup(path_buff); /* this function is found below */
 paths = strtok(path_dup, ":"); /* tokenizes it */
 while (paths)
 {
  path[i] = paths;
  paths = strtok(NULL, ":");
  i++;
 }
 path[i] = NULL; /* terminates it with NULL */
}

/**
* _strdup - duplicates a string
* @from: the string to be duplicated
*
* Return: ponter to the duplicated string
*/
char *_strdup(char *from)
{
 int i, len;
 char *dup_str;

 len = _strlen(from) + 1;
 dup_str = malloc(sizeof(int) * len);
 i = 0;

 while (*(from + i) != '\0')
 {
  *(dup_str + i) = *(from + i);
  i++;
 }
 *(dup_str + i) = '\0';

 return (dup_str);
}

上面代码中的 path 数组存储所有 PATH 位置并且以 NULL 终止。因此,可以将每个 PATH 位置与命令连接起来,并使用 access() 函数执行存在性检查:

{
 char *command_file, *command_path, *path[50];
 int i;

 i = 0;
 command_path = malloc(sizeof(char) * 50);
 while (path[i] != NULL)
 {
  _strcat(path[i], command_file, command_path); /* this function is found below */
  stat_f = access(command_path, X_OK); /* and checks if it exists */
  if (stat_f == 0)
   return (command_path); /* returns the concatenated string if found */

  i++;
 }
 return NULL; /* otherwise returns NULL */
}

/**
* _strcat - concatenates two strings and saves it to a blank string
* @path: the path string
* @command: the command
* @command_path: the string to store the concatenation
*
* Return: Always void
*/
void _strcat(char *path, char *command, char *command_path)
{
 int i, j;

 i = 0;
 j = 0;

 while (*(path + i) != '\0')
 {
  *(command_path + i) = *(path + i);
  i++;
 }
 *(command_path + i) = '/';
 i++;

 while (*(command + j) != '\0')
 {
  *(command_path + i) = *(command + j);
  i++;
  j++;
 }
 *(command_path + i) = '\0';
}

一旦找到命令,就会返回命令的完整路径,否则就返回 NULL,然后 shell 会显示命令不存在的错误。

现在假如命令找到了,然后呢?

4、执行命令

命令一旦找到,就是执行它的时候了,问题是怎么执行呢?

执行命令,需要借助函数 execve()#include <unistd.h>」中:

int execve(const char *pathname, char *const argv[],
                  char *const envp[]);

参数说明:

  • pathname: 可执行文件的完整路径
  • argv: 命令的参数
  • envp: 环境变量列表

execve() 会执行找到的命令,返回一个整数表示执行结果。

但是现在如果 shell 只是运行 execve(),就会出现问题。execve() 调用后不返回标准输出的信息,这是不好的,因为用户需要执行的结果。所以为了解决这个问题,shell 在子进程中执行命令。因此,一旦在子进程内执行完成,父进程就会收到信号并且程序流继续。所以为了执行命令,shell 使用 fork() 创建了一个子进程。(fork 声明在#include <unistd.h>中)

pid_t fork(void);

fork() 通过复制调用进程来创建一个新进程。新进程称为子进程。调用进程称为父进程。fork() 在父进程中返回子进程的进程 ID,在子进程中返回 0:

{
 char *command, *command_argv[50], **env;
 pid_t child_pid;
 int status;

 get_each_command_argv(command_argv, input_buffer); /* this function is found below */
 child_pid = fork();
 if (child_pid == -1)
  return (0);

 if (child_pid == 0)
 {
  if (execve(command, command_argv, env) == -1)
   return (0);
 }
 else
  wait(&status);
}

/**
* get_each_command_argv - stores all the arguments \
*             of the input command to the list
* @command_argv: the command argument list
* @input_buffer: the input buffer
*
* Return: Always void
*/
void get_each_command_argv(char **command_argv, char *input_buffer)
{
 char *args, *delim_args;
 int i;

 delim_args = " \t\r\n\v\f";
 args = strtok(input_buffer, delim_args);

 i = 0;
 while (args)
 {
  command_argv[i] = args;
  args = strtok(NULL, delim_args);
  i++;
 }
 command_argv[i] = NULL;
}

shell 使用 wait()(函数声明在#include <sys/wait.h>) 在程序流继续之前等待子进程的状态变化,并再次为用户显示提示。

pid_t wait(int *wstatus);
  • wstatus:是一个指向整数的指针,可以用来标识子进程是如何终止的。

shell 在子进程内执行命令,然后 wait() 等待子进程完成。所以这样用户就可以得到命令的结果,并且可以在 shell 显示其提示后输入另一个命令。

所以最后当子进程完成时显示 ls -l *.py 的结果,并且由于我们已经等待子进程结束,这意味着给出了命令的结果。所以现在 shell 可以再次显示它的提示以再次等待用户输入。这将继续循环,除非用户键入 exit。

本文参与 腾讯云自媒体分享计划,分享自微信公众号。
原始发表:2021-11-28,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 Python七号 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 0、什么是 shell
  • 1、获取并解析用户输入
  • 2、识别命令及命令的参数
  • 3、查找命令
  • 4、执行命令
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档