【Linux】1w详解如何实现一个简单的shell

最新推荐文章于 2024-08-09 10:53:56 发布
最新推荐文章于 2024-08-09 10:53:56 发布
阅读量3k 收藏 86
点赞数 95
分类专栏： Linux 文章标签： c语言 开发语言 linux 运维 服务器 笔记 自动化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80171004/article/details/140291516
版权

 目录 

实现思路

1. 交互 获取命令行

2. 子串分割 解析命令行

3. 指令的判断 内建命令

4. 普通命令的执行

 补充：vim 文本替换

整体代码

重点思考

1.getenv和putenv是什么意思

2.代码extern char **environ;

3.内建命令是什么

4.lastcode = WEXITSTATUS(status);

5.execvp(_argv[0], _argv);的调用

6._argc&_argv

实现思路

1. 交互 获取命令行

显示提示符和获取用户输入

Shell本质是一个死循环，不断地显示提示符和获取用户输入。

memset 函数

memset 函数用于将一段内存区域设置为指定的值。它的原型是：

void *memset(void *s, int c, size_t n);

参数说明：

  • s：指向要填充的内存区域的指针。

  • c：要设置的值（以无符号字符形式传递，但实际存储在内存中的每个字节的值是该无符号字符的值）。

  • n：要设置的字节数。

示例用法：

char command_line[NUM];
memset(command_line, '\0', sizeof(command_line) * sizeof(char));

这里的代码表示将 command_line 数组的每个字节都设置为 \0（空字符），确保初始化整个数组。

fgets 函数

fgets 函数用于从指定的输入流读取字符串。它的原型是：

char *fgets(char *s, int n, FILE *stream);

参数说明：

  • s：指向存储读取数据的字符数组的指针。

  • n：要读取的最大字符数（包括终止字符 \0）。

  • stream：输入流，通常是 stdin 用于标准输入。

示例用法：

fgets(command_line, NUM, stdin);

这行代码表示从标准输入读取最多 NUM-1 个字符（预留一个字符用于终止字符 \0）到 command_line 数组中。

综合示例

结合起来，代码片段如下所示：

char command_line[NUM];
memset(command_line, '\0', sizeof(command_line) * sizeof(char));
fgets(command_line, NUM, stdin);

这段代码的作用是：

  1. 使用 memset 函数将 command_line 数组的所有字节都设置为 \0，即初始化数组。

  2. 使用 fgets 函数从标准输入读取最多 NUM-1 个字符并存储在 command_line 数组中。

这样处理后，command_line 数组会包含从输入读取的字符串，并且如果字符串的长度小于 NUM，数组中剩余的字节会保持为 \0。

以下是实现这两个步骤的代码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

#define NUM 1024

char command_line[NUM]; // 用来接收命令行内容

int main(void) {
    while (1) {
        /* Step1：显示提示符 */
        printf("[用户@主机 当前目录] # ");
        fflush(stdout);

        /* Step2：获取用户输入 */
        memset(command_line, '\0', sizeof(command_line));
        fgets(command_line, NUM, stdin);  // 从键盘获取输入
        command_line[strlen(command_line) - 1] = '\0'; // 消除 '\n'
        printf("%s\n", command_line);
    }
}

通过上述代码，我们可以实现提示用户输入，并获取用户输入。

注意点：

执行发现有空行怎么办

 我们利用 fgets 函数从键盘上获取，标准输入 stdin，获取到 C 风格的字符串，

注意默认会添加 \0 ，我们先把获取到的结果 command_line 打印出来看看：

 因为 command_line 里有一个 \n，我们把它替换成 \0 即可：

 command_line[strlen(command_line) - 1] = '\0';  // 消除 '\0'

2. 子串分割 解析命令行

获取用户输入后，我们需要将接收到的字符串拆分为命令及其参数。

将接收到的字符串拆开

通过 strtok 函数，我们可以将一个字符串按照特定的分隔符打散，依次返回子串：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

#define NUM 1024
#define SEP " "
#define SIZE 128

char command_line[NUM];
char* command_args[SIZE];

int main(void) {
    while (1) {
        /* 显示提示符和获取用户输入 */
        printf("[用户@主机 当前目录] # ");
        fflush(stdout);
        memset(command_line, '\0', sizeof(command_line));
        fgets(command_line, NUM, stdin);
        command_line[strlen(command_line) - 1] = '\0';

        /* 将接收到的字符串拆开 */
        command_args[0] = strtok(command_line, SEP);
        int idx = 1;
        while ((command_args[idx++] = strtok(NULL, SEP)));

        /* 打印拆分结果 */
        for (int i = 0; i < idx - 1; i++) {
            printf("%d : %s\n", i, command_args[i]);
        }
    }
}

通过这段代码，我们可以将输入的命令行字符串拆分成多个子字符串，并打印出来。

strtok 函数的原型为：

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

参数说明：

  • str：要进行分割的字符串，第一次调用时传入要分割的字符串，后续调用时传入 NULL 即可。

  • delim：分隔符，用于指定分割字符串的字符。

示例用法

在代码中，使用了 strtok 函数将 command_line 字符串按照 SEP 分隔符进行切割，并将每个子字符串存储在 command_args 数组中。

command_args[0] = strtok(command_line, SEP);
int idx = 1;

这里的代码首先将 command_line 字符串按照 SEP 分隔符切割成子字符串，并将第一个子字符串的指针存储在 command_args[0] 中。然后，

利用循环逐个获取剩余的子字符串，并将它们存储在 command_args 数组中（使用 idx 来索引）。

3. 指令的判断 内建命令

为了实现一些特定功能，如路径切换，我们需要在Shell中实现内建命令。

内建命令：实现路径切换

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

#define NUM 1024
#define SEP " "
#define SIZE 128

char command_line[NUM];
char* command_args[SIZE];

/* Shell 内置函数: 路径跳转 */
int ChangeDir(const char* new_path) {
    return chdir(new_path);
}

int main(void) {
    while (1) {
        /* 显示提示符和获取用户输入 */
        printf("[用户@主机 当前目录] # ");
        fflush(stdout);
        memset(command_line, '\0', sizeof(command_line));
        fgets(command_line, NUM, stdin);
        command_line[strlen(command_line) - 1] = '\0';

        /* 将接收到的字符串拆开 */
        command_args[0] = strtok(command_line, SEP);
        int idx = 1;
        while ((command_args[idx++] = strtok(NULL, SEP)));

        /* 判断并执行内建命令 */
        if (strcmp(command_args[0], "cd") == 0 && command_args[1] != NULL) {
            ChangeDir(command_args[1]);
            continue;
        }

        /* 执行普通命令 */
    }
}

这段代码通过判断输入的命令是否为 cd 来执行路径切换，而无需创建子进程。

getcwd用于获取当前工作目录（当前目录）的路径。该函数的声明如下：

char *getcwd(char *buf, size_t size);

函数参数说明：

  • buf：指向存储当前工作目录路径的缓冲区
  • size：缓冲区的大小

函数返回值： 如果函数调用成功，则返回指向存储当前工作目录路径的缓冲区的指针；如果函数调用失败，则返回NULL。

通过调用getcwd函数，可以获取当前程序所在的工作目录路径。

chdir用于改变当前工作目录（当前目录）的路径。该函数的声明如下：

int chdir(const char *path);

函数参数说明：

  • path：要设置为当前工作目录的路径

函数返回值： 如果函数调用成功，则返回0；如果函数调用失败，则返回-1，并设置errno来指示错误的类型。

4. 普通命令的执行

最后，我们实现普通命令的执行，包括创建子进程并执行用户输入的命令。

创建进程 & 程序替换

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
 
#define NUM 1024
#define SEP " "
#define SIZE 128
 
char command_line[NUM];
char* command_args[SIZE];
 
int main(void)
{
    while (1) {
        /* Step1：显示提示符 */
        printf("[lvy@我的主机名 当前目录] # ");
        fflush(stdout);
 
        /* Step2：获取用户输入 */
        memset (
            command_line, 
            '\0', 
            sizeof(command_line) * sizeof(char)
        );
        fgets(command_line, NUM, stdin);  /* 从键盘获取，标准输入，stdin 
            获取到 C 风格的字符串，默认添加 '\0' */
        command_line[strlen(command_line) - 1] = '\0';  // 消除 '\0'
 
        /* Step3: 将接收到的字符串拆开 - 字符串切分 */
        command_args[0] = strtok(command_line, SEP);
        int idx = 1;
        
        /* 这里的 = 是故意这么写的，因为 strtok 截取成功返回字符串起始地址
            截取失败，返回 NULL */
        while (command_args[idx++] = strtok(NULL, SEP));
 
        //我们来测试一下看看 
        // for (int i = 0; i < idx; i++) {
        //     printf("%d : %s\n", i, command_args[i]);
        // }
 
        // printf("%s\n", command_line);
 
        /* Step4. TODO */
        /* Step5. 创建进程，执行 */
        pid_t id = fork();
        if (id == 0) {
            /* child */
            /* Step6: 程序替换 */
            execvp (
                command_args[0],  // 保存的是我们要执行的程序名字
                command_args
            );
 
            exit(1);   // 只要执行到这里，子进程一定是替换失败了，直接退出。
        }
 
        /* Father */
        int status = 0;
        pid_t ret = waitpid(id, &status, 0);
        if (ret > 0) {   // 等待成功
            printf("等待成功！sig: %d, code: %d\n", status&0x7F, (status>>8)&0xFF);
        }
    } // end while
 
}

通过上述代码，我们可以创建一个进程来执行用户输入的命令，并等待子进程结束。

给命令带颜色

为了增强Shell的用户体验，可以给一些常用命令添加颜色，例如 ls 命令：

/* 将接收到的字符串拆开 */
command_args[0] = strtok(command_line, SEP);
int idx = 1;
while ((command_args[idx++] = strtok(NULL, SEP)));

/* 给 ls 命令添加颜色 */
if (strcmp(command_args[0], "ls") == 0) {
    command_args[idx++] = (char*)"--color=auto";
}

以上实现了一个简单的Shell，具备了基本的提示符显示、用户输入获取、命令解析、内建命令和普通命令的执行功能。

内建命令 环境变量

/* Shell 内置函数: 路径跳转 */
int ChangeDir(const char* new_path) {
    chdir(new_path);
 
    return 0;  // 调用成功
}
 
int main(void) 
{
    ...
        /* Step4. TODO 编写后面的逻辑，内建命令 */
        if (strcmp(command_args[0], "cd") == 0 && command_args[1] != NULL) {
            ChangeDir(command_args[1]);  // 让调用方进行路径切换
            continue;
        }
    ...
}

保存环境变量的字符串，不能是易变的，所以 strcpy mycommand，实现与argv的分离

 补充：vim 文本替换

如何快速将mycmd换为myshell呢

通过如下操作

: %s/mycmd/myshell/g

就可以啦

细节设置的思考，在最后一部分，让我们先来看一下整体

整体代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>//创建子进程
#include <stdlib.h>//这些文件都是什么意思
#include <sys/types.h>
#include <sys/wait.h>

#define LEFT "["
#define RIGHT "]"
#define LABLE "#"
#define DELIM " \t"
#define LINE_SIZE 1024
#define ARGC_SIZE 32
#define EXIT_CODE 44

int lastcode = 0;
int quit = 0;
extern char **environ;
char commandline[LINE_SIZE];
char *argv[ARGC_SIZE];//存储切割之后的命令行
char pwd[LINE_SIZE];

// 自定义环境变量表
char myenv[LINE_SIZE];
// 自定义本地变量表


const char *getusername()
{
    return getenv("USER");
}

const char *gethostname()
{
    return getenv("HOSTNAME");
}

void getpwd()
{
    getcwd(pwd, sizeof(pwd));//获取当前工作目录
}

void interact(char *cline, int size)//交互
{
    getpwd();
    printf(LEFT"%s@%s %s"RIGHT""LABLE" ", getusername(), gethostname(), pwd);
    char *s = fgets(cline, size, stdin);输入流进行输入
    assert(s);//断言不为空
    (void)s;//调用s避免报错
    // "abcd\n\0"
    cline[strlen(cline)-1] = '\0';//取消自动换行
}

// ls -a -l | wc -l | head 
int splitstring(char cline[], char *_argv[])
{
    int i = 0;
    argv[i++] = strtok(cline, DELIM);//区分全局变量和形参_
    while(_argv[i++] = strtok(NULL, DELIM)); // 故意写的=
    //NULL的设置才能实现往后移的切割
    return i - 1;//去除NULL
}

void NormalExcute(char *_argv[])
{
    pid_t id = fork();
    if(id < 0){
        perror("fork");
        return;
    }
    else if(id == 0){
        //让子进程执行命令
        //execvpe(_argv[0], _argv, environ);
        execvp(_argv[0], _argv);
        //系统调用
        exit(EXIT_CODE);
    }
    else{
        int status = 0;
        pid_t rid = waitpid(id, &status, 0);
        if(rid == id) 
        {//返回正确执行
            lastcode = WEXITSTATUS(status);
        }
    }
}
//切换路径，内建命令
//shell执行的内建命令，一个一个判断
int buildCommand(char *_argv[], int _argc)
{
    if(_argc == 2 && strcmp(_argv[0], "cd") == 0){
        chdir(argv[1]);//切换路径的函数
        getpwd();//获取当前路径
        sprintf(getenv("PWD"), "%s", pwd);
        return 1;
    }
    //导入环境变量export
    else if(_argc == 2 && strcmp(_argv[0], "export") == 0){
        strcpy(myenv, _argv[1]);//为什么要进行一个拷贝 是什么意思呢！！！！
        putenv(myenv);//argv 是我们定义的，每次都是变化的
        //所以不要写我们的地址，要提字符串的地址
        return 1;
    }
    else if(_argc == 2 && strcmp(_argv[0], "echo") == 0){
        if(strcmp(_argv[1], "$?") == 0)
        {
            printf("%d\n", lastcode);//查看退出码
            lastcode=0;
        }
        else if(*_argv[1] == '$'){//打印环境变量
            char *val = getenv(_argv[1]+1);//获取
            if(val) printf("%s\n", val);
        }
        else{
            printf("%s\n", _argv[1]);
        }

        return 1;
    }

    // 特殊处理一下ls
    if(strcmp(_argv[0], "ls") == 0)
    {
        _argv[_argc++] = "--color";
        _argv[_argc] = NULL;
    }
    return 0; //带有颜色之后返回，再执行普通命令
}

int main()
{
    while(!quit){
        //1.许多软件启动起来就是死循环
        // 2. 交互问题,获取命令行, ls -a -l > myfile / ls -a -l >> myfile / cat < file.txt
        interact(commandline, sizeof(commandline));
        //对函数做了一下封装

        // commandline -> "ls -a -l -n\0" -> "ls" "-a" "-l" "-n"
        // 3. 子串分割的问题，解析命令行
        int argc = splitstring(commandline, argv);
        //如何将字串打散呢
        //strtok需要循环调用
        //while(argv[i++]=strtok(commandline,DELIM);//故意写的等号
        if(argc == 0) continue;

        // 4. 指令的判断 
        // debug
        //for(int i = 0; argv[i]; i++) printf("[%d]: %s\n", i, argv[i]);
        //内键命令，本质就是一个shell内部的一个函数
        int n = buildCommand(argv, argc);

        // ls -a -l | wc -l
        // 4.0 分析输入的命令行字符串，获取有多少个|, 命令打散多个子命令字符串
        // 4.1 malloc申请空间，pipe先申请多个管道
        // 4.2 循环创建多个子进程，每一个子进程的重定向情况。最开始. 输出重定向, 1->指定的一个管道的写端 
        // 中间：输入输出重定向， 0标准输入重定向到上一个管道的读端 1标准输出重定向到下一个管道的写端
        // 最后一个：输入重定向，将标准输入重定向到最后一个管道的读端
        // 4.3 分别让不同的子进程执行不同的命令--- exec* --- exec*不会影响该进程曾经打开的文件，不会影响预先设置好的管道重定向
        // 5. 普通命令的执行
        if(!n) NormalExcute(argv);//让命令0的时候执行
    }
    return 0;
}

重点思考

1.getenv和putenv是什么意思

 getenv函数用于获取指定环境变量的值。它的函数定义如下：

char *getenv(const char *name);

  • 参数：

    • name：要获取的环境变量的名称。

  • 返回值：

    • 如果指定的环境变量存在，那么返回一个指向该环境变量值的指针。

    • 如果指定的环境变量不存在，则返回NULL。

以下是一个使用getenv函数的示例：

#include <stdio.h>
#include <stdlib.h>

int main() {
    char *path = getenv("PATH");
    if (path != NULL) {
        printf("PATH environment variable: %s\n", path);
    } else {
        printf("PATH environment variable not found.\n");
    }
    return 0;
}

成功实现对环境变量的调用啦

putenv函数

putenv函数用于设置环境变量。它的函数定义如下：

int putenv(char *string);

  • 参数：

    • string：形式为"name=value"的字符串，用于设置具体的环境变量及其值。

  • 返回值：

    • 成功时返回0。

    • 失败时返回非零值。

以下是一个使用putenv函数的示例：

#include <stdio.h>
#include <stdlib.h>

int main() {
    char env_str[] = "MY_ENV=hello_world";
    if (putenv(env_str) == 0) {
        printf("Environment variable set successfully.\n");
    } else {
        perror("putenv");
        return 1;
    }
    
    char *my_env = getenv("MY_ENV");
    if (my_env != NULL) {
        printf("MY_ENV: %s\n", my_env);
    } else {
        printf("MY_ENV environment variable not found.\n");
    }
    
    return 0;
}

注意事项

  1. 内存管理：

    • getenv返回的指针指向的是环境变量的值，不能直接修改此值，否则可能导致未定义行为。

    • putenv函数参数所指向的字符串在函数调用后仍需存在，因为putenv不会复制这个字符串。因此传递给putenv的字符串应始终位于可修改的全局或堆内存中，而不是局部变量中。

  1. 线程安全性：

    • getenv和putenv函数在某些实现中不是线程安全的，特别是当修改同一个环境变量时。建议在多线程环境中使用setenv和unsetenv函数，它们是现代C库中提供的线程安全的替代函数。

总结

getenv和putenv是C语言中用于获取和设置环境变量的基本函数。通过了解并正确使用它们，可以更好地管理进程环境。

2.代码extern char **environ;

 extern char **environ; 是C语言中的全局变量声明，用于访问当前进程的环境变量。为了理解这一行代码，我们需要理清以下几个关键概念：

环境变量的存储

在Unix和类Unix操作系统（如Linux）中，环境变量是一组键值对（例如PATH=/usr/bin），用于向进程传递配置信息。每个环境变量项以字符串的形式存储在一个全局变量数组中。这个数组在进程启动时由操作系统初始化，并且每个程序都可以访问和修改它。

环境变量在内存中的表示

在内存中，环境变量通常表示为一个字符串数组，每个字符串保存一个环境变量。例如：

PATH=/usr/bin
HOME=/home/user
USER=user
...

这些字符串指针存储在一个全局变量数组中，即char **environ。

extern关键字

extern关键字用于声明一个全局变量，但不定义它。它告诉编译器这个变量是在别处（比如另一个源文件或由操作系统提供）定义的。因此，extern char **environ; 仅仅是一个声明，用来告知编译器这个变量在别处已经定义过，可以在当前文件中使用它。

为什么这样写？

在标准C库中，environ变量实际上在系统库中已经定义，我们只需要在我们的程序中声明一下即可使用。这种方式使我们能够访问和操作环境变量。

这里是extern char **environ;的具体含义：

  1. 声明：它声明了一个外部变量environ，是一个指向字符指针的指针。

  2. 外部定义：实际的环境变量数组由操作系统初始化，并定义在某个系统库中。

  3. 全局访问：通过这个声明，我们可以在任何源文件中访问和操作环境变量。

示例

下面是一个具体的例子，展示了如何使用environ来访问并打印所有环境变量：

#include <stdio.h>

// 声明外部环境变量数组
extern char **environ;

int main(void) {
    // 指向环境变量数组的指针
    char **env = environ;

    // 遍历并打印所有环境变量
    while (*env) {
        printf("%s\n", *env);
        env++;
    }

    return 0;
}

就可以成功调用所有环境变量啦

总结

extern char **environ; 这一行代码的作用是声明一个指针数组，用于访问当前进程的环境变量。通过这种方式，我们可以在C程序中方便地读取和操作环境变量。

3.内建命令是什么

内建命令是指直接内置在操作系统内核中的一些命令，与普通的外部命令（外部程序文件）不同。这些内建命令是直接由shell解释器（如Bash、Zsh等）所处理，而不需要通过外部文件的方式来执行。这些内建命令通常在操作系统的shell环境中被频繁使用，并且执行速度更快，因为它们不需要创建新的进程来执行。

在Unix和类Unix操作系统中，通常会有一些内建命令，比如cd、echo、exit等。这些命令不需要单独的可执行文件，而是直接由shell内核提供支持。当用户在shell中输入这些命令时，shell会直接处理它们，而不需要通过搜索系统路径来找到可执行文件。

值得一提的是，某些shell也允许用户通过自定义的方式添加新的内建命令，这样用户可以根据自己的需求来扩展shell的内建功能。

4.lastcode = WEXITSTATUS(status);

在C语言中，WEXITSTATUS(status) 是一个宏，用于从wait或waitpid返回的状态信息中提取子进程的退出状态。这个宏主要用于处理子进程的退出状态信息。

具体来说，WEXITSTATUS(status) 用于提取子进程在终止时传递给exit或_exit函数的退出状态。这个宏将状态信息进行适当的位操作，以获取子进程的退出状态值。

一般情况下，status 是由wait或waitpid函数返回的子进程状态，其中包含了有关子进程终止的信息，包括退出状态。通过使用WEXITSTATUS(status)，可以将状态转换为子进程的退出状态，以便于后续处理和判断子进程的终止情况。

具体的用法示例如下：

#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main() {
    pid_t pid;
    int status;
    int lastcode;

    pid = fork();

    if (pid < 0) {
        perror("fork failed");
        exit(1);
    } else if (pid == 0) {
        // This is the child process
        char *args[] = {"ls", "-l", NULL};
        execvp(args[0], args);
    } else {
        // This is the parent process
        waitpid(pid, &status, 0);//获得了子进程的退出码
        lastcode = WEXITSTATUS(status);
        printf("子进程的退出状态是：%d\n", lastcode);
    }

    return 0;
}

在这个例子中，WEXITSTATUS(status) 会从 status 中提取子进程的退出状态，并将其赋值给 lastcode。然后这个退出状态可以被用来进行一些处理，比如根据不同的退出状态进行不同的操作。

需要注意的是，使用 WEXITSTATUS(status) 的前提是要确保传入的 status 参数是一个子进程终止的状态，因为该宏只能提取终止进程的退出状态信息。

5.execvp(_argv[0], _argv);的调用

在代码中，execvp(_argv[0], _argv) 是一个执行函数 execvp 的调用，用于执行磁盘文件上的程序。这个函数会用指定的程序文件（由 _argv[0] 指定）来覆盖当前进程的镜像，并且用 _argv 数组中的参数替换掉原来的程序参数。

相对路径执行指令

  1. 路径搜索：根据 PATH 环境变量，execvp 会在指定路径中查找可执行文件。
  2. 内存映射：找到可执行文件后，将其映射到当前进程地址空间。
  3. 替换镜像：用新程序的数据、堆栈、代码段替换当前进程的相应部分。
  4. 执行：新程序从其入口点开始执行，覆盖原进程的代码。

下面是对 execvp 函数调用的解释：

  • _argv[0] 表示要执行的程序文件的路径或名称。如果是一个程序的名称而没有路径，execvp 会在 $PATH 环境变量指定的路径中搜索这个程序。
  • _argv 是一个以空指针结尾的字符串数组，用于传递给新程序的命令行参数。数组的第一个元素（_argv[0]）通常是被执行的程序的名称，随后的元素是程序的参数。
  • 当调用 execvp 时，操作系统会加载并执行指定的程序文件，并用 _argv 数组中的参数来替换当前进程的参数。（因为默认会在PATH中查询，就和系统连接上了）
  • 如果 execvp 调用成功，则当前进程的镜像将被新程序替换，并且新程序开始执行。原来的程序代码和数据都会被新程序的代码和数据取代。
  • 如果 execvp 调用失败，它会返回-1，并且当前进程的状态不会改变。

在简单的C代码中，execvp 函数通常与 fork 函数一起使用，例如：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
    char *_argv[] = {"ls", "-l", "-a", NULL}; // 要执行的命令及参数组成的数组
    execvp(_argv[0], _argv);  // 在新的程序中执行 ls 命令
    // 如果执行成功，下面的代码不会被执行
    perror("execvp"); // 如果 execvp 失败，打印出错误信息
    return 1;
}

需要注意的是，execvp 在执行成功后，原进程的代码和数据将会被新进程替换。这就意味着，如果 execvp 后面还有代码，那么这些代码将不会被执行，因为当前的程序已经不再存在。

实现shell， 一行一行的运行，先判断是否为内建命令

6._argc&_argv

  • _argv：是一个字符指针数组，用于存储命令和参数。
  • _argc：是整型变量，用于存储命令和参数的数量。
  • splitstring 函数将命令行字符串分割成多个子字符串，存储在 _argv 中，并返回子字符串的数量 _argc。
  • NormalExcute 函数使用 _argv 数组创建子进程并执行命令。
  • buildCommand 函数使用 _argv 和 _argc 处理内建命令。
lvy¯
关注
  • 95
    点赞
  • 踩
  • 86
    收藏
    觉得还不错? 一键收藏
  • 69
    评论
专栏目录
linux shell 脚本 入门到实战详解[⭐建议收藏！！⭐]
心有鸿鹄天地，不敢妄坠人间
09-28 27万+
文章目录shell 入门到实战详解[⭐建议收藏！！⭐]关于作者**作者介绍**一、shell 入门简介1.1 什么是shell1.2 shell 编程注意事项1.3 第一个shell 脚本 hello world二、shell 环境变量讲解2.1 shell 变量详解2.2 shell 系统变量 介绍2.3 shell 环境变量 介绍2.3.1 常见的系统环境变量2.4 shell 用户环境变量 介绍2.4.1 自定义shell环境变量2.4.2 echo 打印菜单栏2.4.3 shell 中彩色输出 h
详解Linux Shell 实现一个获取任意位数的随机密码的脚本
09-15
1. **接受命令行参数**：在Shell脚本中，通过`$1`、`$2`等变量来访问命令行传递的参数，`$1`代表第一个参数，`$2`代表第二个参数，以此类推。如果需要获取所有参数，可以使用`$@`。在本例中，脚本检查是否传入了参数...
一天一个shell命令 linux文本操作系列-wc命令详解
01-11
全称 wc是一个用于统计的工具，全拼为：Word Count(单词统计) 实例： 1. 统计行数 $wc –l file 2. 统计单词数 $wc –w file 3. 统计字符数 $wc –c file 4. 统计流中的字符数 $echo –n 1234 | wc –c 输出：4 解读–help  用法：wc [选项]... [文件]... 或：wc [选项]... --files0-from=F 打印每行的换行符，单词，字节的数量，如果多于一个文件，则打印每个总行数。如果没有文件，或者文件位置用“-”表示，则读取标准流。 一个单词是由空白符分隔的非零长的字符序列 下面的操作可能用于
shell 运行原理和 Linux 权限详解.docx
11-06
shell 运行原理和 Linux 权限详解 shell 命令以及运行原理 * Shell 是 Linux 的外壳程序，用户不能直接使用内核，而是通过 Shell 与内核沟通。 * Shell 的定义：命令行解释器（command Interpreter），将用户的...
一天一个shell命令 linux文本内容操作系列-sed命令详解
09-15
正则表达式 `digit(0-9)` 匹配 "digit" 后跟一个数字，`\1` 引用匹配到的第一个括号内的内容，即数字 7。 6. **引用变量** ```bash $ text=hello $ echo "helloworld" | sed "s/$text/HELLO/" ``` 这里 `$...
C语言：求最大数不用数组
weixin_55021541的博客
08-08 191
输入一批正数用空格隔开，个数不限，输入0时结束循环，并且输出这批整数的最大值。
C语言—水手分椰子问题
2301_80163571的博客
08-08 258
【代码】C语言—水手分椰子问题。
东方博宜24年8月-C组 - 屋顶
kuaidihezi的博客
08-06 565
小 A 在奥运会期间，前往巴黎观看奥运会的相关赛事。在某项体育比赛中，他被场馆的屋顶吸引了，这个屋顶不同于普通的屋顶，在平坦的屋顶上，设计师使用特殊材料制作的边长为 1 米正方体，设计出了各种造型。由于正方体的高矮不一，下雨时，屋顶会有一定的积水，这些积水会被保留在屋顶，用于场馆内的绿植灌溉。下图给出了一个宽度为 8 的屋顶的截面图。在截面图中，我们可以看到，白色的方块是特殊材料制作的正方体，蓝色矩形，是下雨后，屋顶上的积水区域。图中积水区域的总面积为 9 平方米。
C语言——预处理和指针
attitude_lu的博客
08-05 1481
宏定义的语法形式：#define 标识符 字符串或者是#define 宏名 宏值预处理命令都是以#开头的例如：#define n 10注意在定义宏时在宏值后面是不可以加分号的如果加了分号在预处理进行文本替换的时候会一并把分号一起替换了，比如说我在定义#define N 10的后面加上分号可以看到在进行预处理时N会被替换成10;
Type-C取电芯片LDR6500
ZenasLDR的博客
08-06 308
Type-C诱骗取电芯片作为Type-C接口电源管理的重要组成部分，以其快速充电、高功率传输、自动检测与匹配以及智能控制等显著特点，正逐步改变着我们的充电体验和设备电源管理方式。随着技术的不断进步和应用场景的不断拓展，我们有理由相信Type-C诱骗取电芯片将在未来市场中迎来更加广阔的发展前景。同时，这也将推动整个电子设备行业向更加高效、便捷和智能的方向发展。
【C语言】编译和链接（细节的king）
tianxiawushanu的博客
08-06 859
本文讲解大家在写代码时，代码是如何被编译器执行的。其中涉及到了翻译环境和运行环境，其中讲解了翻译环境里面的诸多细节。看完本文后，绝对让你的知识跟上一层楼。
C语言典型例题28
2302_77517102的博客
08-06 621
输入一个华氏温度，要求输出摄氏温度。公式为C=5/9(F-32)，要求输出要有文字说明，取两位小数
Flink开发语言使用java还是Scala合适
七夜的博客
08-06 492
选择Java：如果团队对Java更熟悉，项目对代码的稳定性和可维护性要求高，并且需要与现有的Java生态系统集成。选择Scala：如果团队愿意尝试新的编程范式，项目需要快速迭代和开发，或者在大数据和分布式计算领域有特殊需求。最终的选择应根据团队的技能水平、项目需求、企业环境以及对新技术的接受度综合考虑。无论选择Java还是Scala，Flink都能提供强大的流处理能力，关键在于选择最适合团队和项目的语言。
Flink开发语言使用Java还是Scala合适?
Good_tea_h的博客
08-06 804
在讨论Apache Flink开发时选择Java还是Scala作为开发语言，我们需要深入探讨这两种语言在Flink生态系统中的适用性、它们各自的优缺点、对开发效率的影响、以及它们如何与Flink的核心功能和架构相结合。以下是对这一问题的详细分析，旨在帮助开发者在决策过程中做出更加明智的选择。
系统控制和管理接口：在Linux中利用电源和性能域进行平台资源抽象
最新发布
csdnsqst0046的博客
08-09 561
在本文中，您可以了解到如何利用我们的方法将复杂性从Linux驱动程序（需要为每个平台编写不同的开发程序）转移到固件。由于固件已经适配了平台，因此固件知道需要采取哪些手段来配置外设。您可以了解我们如何定义逻辑性能和电源域，而不是单独处理每个平台资源。您还可以了解到我们如何努力实现这一目标，以及您如何进行尝试并做出贡献。
linux 终端选择 VT100 VT102 VT200 Xterm linux Vshell 等都有什么区别
记录 分享 成就
08-06 355
在 Linux 系统中，终端类型通常指的是终端模拟器或终端控制程序所支持的特定功能和行为的集合。不同的终端类型支持不同的功能集，这些功能包括光标控制、文本格式化、屏幕滚动等。
linux 011 注释13：缺页中断，新设计艺术团队第二版，第四章 4-39 至 4-48
zhangzhangkeji的博客
08-06 210
（133） 4-42 函do_no_page。
linux docker安装 gitlab后忘记root密码如何找回
爱丫爱的博客
08-06 306
docker 安装git 忘记root 密码如何重新设置。
在Linux中宏观的看待线程
2301_77479435的博客
08-07 396
在Linux中宏观的看待线程
评论 69
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值