制作简易shell

最新推荐文章于 2025-05-23 21:31:19 发布
最新推荐文章于 2025-05-23 21:31:19 发布
阅读量741 收藏 10
点赞数
CC 4.0 BY-SA版权
文章标签： c语言 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_61021034/article/details/124213415

要求：

  • 实现 管道 (也就是 |)
  • 实现 输入输出重定向(也就是 < > >>)
  • 实现 后台运行（也就是 & ）
  • 实现 cd，要求支持能切换到绝对路径，相对路径和支持 cd -
  • 屏蔽一些信号（如 ctrl + c 不能终止）

1.将输入命令拆分存入二维字符指针分配的内存中

char **getcmd(int *p)
{
    char **cmd = (char **)malloc(sizeof(char *) * cmdsize);
    char *input = (char *)malloc(sizeof(char) * 1000);
    int len = 0, count = 0, pi = 0, i = 0;
    if (fgets(input, 1000, stdin) == NULL)
    {
        input[0] = 0;
    }

    int l = strlen(input);
    if (l == 0)
    {

        free(cmd);
        free(input);
        exit(0);
    }

    if (strcmp(input, "\n") == 0)
    {
        cmd[0] = (char *)malloc(5);
        strcpy(cmd[0], "\n");
        free(input);
        return cmd;
    }

    input[l - 1] = '\0';
    // add_history(input);
    while (len < l - 1)
    {
        while (input[len] == ' ')
        {
            len++;
            i++;
        }

        while (len < l - 1 && (input[len] != ' ' && input[len] != '|' && input[len] != '>' && input[len] != '<' && input[len] != '&'))
        {
            if (input[len] == '&')
            {
                bg = 1;
                input[len] = ' ';
            }

            len++;
        }
        cmd[count] = (char *)malloc(sizeof(char) * 20);
        realsize++;
        strncpy(cmd[count++], input + i, len - i);
        cmd[count - 1][len - i] = '\0';
        if (strcmp(cmd[count - 1], "~") == 0)
        {
            strcpy(cmd[count - 1], "/home/kangning");
        }
        // printf("|%s|\n",cmd[count-1]);
        while (input[len] == ' ' || input[len] == '&')
        {
            if (input[len] == '&')
            {
                bg = 1;
            }
            len++;
        }

        if (input[len] == '<')
        {
            in = count;
            len++;
        }
        else if (input[len] == '>')
        {
            len++;
            if (input[len] == '>')
            {
                len++;
                add = count;
            }
            else
                out = count;
        }
        if (input[len] == '|')
        {
            len++;
            p[pi++] = count;
        }

        while (input[len] == ' ' || input[len] == '<' || input[len] == '|' || input[len] == '>')
        {
            len++;
        }
        i = len;
    }
    free(input);
    input = NULL;
    return cmd;
}

2.没有管道时执行这个函数

void execcmd(char **cmd)
{
    pid_t pid;
    int status;
    pid = fork();

    switch (pid)
    {
    case -1:
        perror("fork");
        return;
    case 0:
        if (out)
        {
            int fd;

            if ((fd = open(cmd[out], O_RDWR | O_CREAT | O_TRUNC, S_IWUSR | S_IRUSR)) == -1)
            {
                perror("open");
            }

            dup2(fd, STDOUT_FILENO);
            close(fd);
            free(cmd[out]);
            cmd[out] = NULL;
        }
        if (add)
        {
            int fd;

            if ((fd = open(cmd[add], O_RDWR | O_CREAT, S_IWUSR | S_IRUSR)) == -1)
            {
                perror("open");
            }
            lseek(fd, -1, SEEK_END);
            dup2(fd, STDOUT_FILENO);
            close(fd);
            free(cmd[add]);
            cmd[add] = NULL;
        }
        execvp(cmd[0], cmd);
    default:
        if (!bg)
            mywait(pid, &status, 0);
    }
}

3.有管道时执行这个函数 

思路：命令用管道符号分开，分别执行，使用两个中间文件进行传输，还会用到swap函数来调换文件描述符，cutcmd函数将一维字符串分割成二维字符串

void piexec(char **cmd, int *p, int pipesize)
{
    char subcmd[10][50]={};
    int start = 0, i = 0, status;
    pid_t ppid;

    for (i = 0; i < pipesize; i++)
    {
        for (int j = start; j < p[i]; j++)
        {
            if (cmd[j])
            {
                strcat(subcmd[i], cmd[j]);
                strcat(subcmd[i], " ");
            }
        }
        start = p[i];
    }

    ppid = fork();
    if (ppid == -1)
    {
        perror("fork");
    }
    else if (ppid == 0)
    {
        pid_t pid;
        int sfd[2];
        for (i = 0; i <= pipesize; i++)
        {
            if (i == 0)
            {
                if ((pid = fork()) == -1)
                {
                    perror("fork");
                }
                else if (pid == 0)
                {
                    int fd[2];
                    if ((fd[0] = open("fifo1", O_RDWR | O_CREAT | O_TRUNC, S_IWUSR | S_IRUSR)) == -1)
                    {
                        perror("open");
                    }
                    if ((fd[1] = open("fifo2", O_RDWR | O_CREAT | O_TRUNC, S_IWUSR | S_IRUSR)) == -1)
                    {
                        perror("open");
                    }

                    sfd[1] = dup(STDOUT_FILENO);
                    dup2(fd[1], STDOUT_FILENO);
                    char **tmp = cutcmd(subcmd[i]);
                    execvp(cmd[0], tmp);
                }
                else
                {
                    mywait(pid, &status, 0);
                    dup2(sfd[1], STDOUT_FILENO);
                }
            }
            else if (i < pipesize)
            {
                if ((pid = fork()) == -1)
                {
                    perror("fork");
                }
                else if (pid == 0)
                {
                    int fd[2];
                    if ((fd[0] = open("fifo1", O_RDWR | O_CREAT, S_IWUSR | S_IRUSR)) == -1)
                    {
                        perror("open");
                    }
                    if ((fd[1] = open("fifo2", O_RDWR | O_CREAT, S_IWUSR | S_IRUSR)) == -1)
                    {
                        perror("open");
                    }
                    swap(&fd[0], &fd[1]);

                    sfd[1] = dup(STDOUT_FILENO);
                    sfd[0] = dup(STDIN_FILENO);

                    dup2(fd[0], STDIN_FILENO);
                    dup2(fd[1], STDOUT_FILENO);
                    close(fd[0]);
                    close(fd[1]);
                    execvp(cmd[p[i]], cutcmd(subcmd[i]));
                }
                else
                {
                    mywait(pid, &status, 0);
                    dup2(sfd[0], STDIN_FILENO);
                    dup2(sfd[1], STDOUT_FILENO);
                }
            }
            else
            {
                if ((pid = fork()) == -1)
                {
                    perror("fork");
                }
                else if (pid == 0)
                {
                    int fd[2];
                    if ((fd[0] = open("fifo1", O_RDWR | O_CREAT, S_IWUSR | S_IRUSR)) == -1)
                    {
                        perror("open");
                    }
                    if ((fd[1] = open("fifo2", O_RDWR | O_CREAT, S_IWUSR | S_IRUSR)) == -1)
                    {
                        perror("open");
                    }
                    if (pipesize % 2)
                        swap(&fd[0], &fd[1]);

                    sfd[0] = dup(STDIN_FILENO);
                    int res = dup2(fd[0], STDIN_FILENO);
                    if (res == -1)
                    {
                        fprintf(stderr, "error dup2\n");
                        exit(1);
                    }
                    if (out)
                    {
                        int fd;
                        if ((fd = open(cmd[out], O_RDWR | O_CREAT | O_TRUNC, S_IWUSR | S_IRUSR)) == -1)
                        {
                            perror("open");
                        }

                        dup2(fd, STDOUT_FILENO);
                        close(fd);
                        free(cmd[out]);
                        cmd[out] = NULL;
                    }
                    if (add)
                    {
                        int fd;

                        if ((fd = open(cmd[add], O_RDWR | O_CREAT, S_IWUSR | S_IRUSR)) == -1)
                        {
                            perror("open");
                        }
                        lseek(fd, -1, SEEK_END);
                        dup2(fd, STDOUT_FILENO);
                        close(fd);
                        free(cmd[add]);
                        cmd[add] = NULL;
                    }
                    close(fd[0]);
                    close(fd[1]);
                    printf("here\n");
                    execvp(cmd[start], cmd + start);
                }
                else
                {
                    mywait(pid, &status, 0);
                    dup2(sfd[0], STDIN_FILENO);
                }
            }
        }
    }
    else if (ppid > 0)
    {
        if (!bg)
        {
            mywait(ppid, &status, 0);
        }
        // while(1){
        //     sleep(1);
        //     printf("-");
        // }
        unlink("fifo1");
        unlink("fifo2");
    }
}

swap函数：

void swap(int *fd0, int *fd1)
{
    int temp = *fd0;
    *fd0 = *fd1;
    *fd1 = temp;
}

cutcmd函数：


char **cutcmd(char *input)
{
    char **cmd = (char **)malloc(sizeof(char *) * cmdsize);
    int len = 0, count = 0, pi = 0, i = 0;

    int l = strlen(input);
    while (len < l)
    {

        cmd[count] = (char *)malloc(sizeof(char) * 20);
        while (len < l && (input[len] != ' '))
        {
            len++;
        }
        strncpy(cmd[count++], input + i, len - i);
        if (strcmp(cmd[count - 1], "~") == 0)
        {
            strcpy(cmd[count - 1], "/home/kangning");
        }
        i = len;

        while (input[len] == ' ' || input[len] == '|')
        {
            i++;
            len++;
        }
    }
    return cmd;
}

4.主函数循环：

int main(void)
{
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGINT);
    sigprocmask(SIG_BLOCK, &set, NULL);
    setvbuf(stdout, NULL, _IONBF, 0);

    last = (char *)malloc(sizeof(char) * 100);

    while (1)
    {
        out = 0, add = 0, realsize = 0;
        int p[10] = {0}, sfd, fd, pipesize = 0;
        printf("# ");

        char **cmd = getcmd(p);
        if (strcmp(cmd[0], "\n") == 0)
        {
            free(cmd[0]);
            cmd[0] = NULL;
            free(cmd);
            cmd = NULL;
            continue;
        }

        int aaa = 0;
        if (in)
        {
            sfd = dup(STDIN_FILENO);
            fd = open(cmd[in], O_RDWR, S_IRUSR | S_IWUSR);
            if (dup2(fd, STDIN_FILENO) == -1)
            {
                fprintf(stderr, "error dup2\n");
                exit(1);
            }
            free(cmd[in]);
            cmd[in] = NULL;
        }

        if (strcmp(cmd[0], "exit") == 0)
        {
            exit(0);
        }
        else if (strcmp(cmd[0], "cd") == 0)
        {
            if (cmd[1] && strcmp(cmd[1], "-") == 0)
            {
                if (last)
                {

                    char *buf = (char *)malloc(sizeof(char) * 100);
                    getcwd(buf, 100);
                    printf("%s\n", last);

                    chdir(last);

                    strcpy(last, buf);
                }
                else
                { // last==NULL
                    printf("bash: cd: OLDPWD 未设定\n");
                }
            }
            else
            {

                getcwd(last, 100);
                chdir(cmd[1]);
            }

            continue;
        }

        for (int i = 0; i < 10; i++)
        {
            if (p[i])
                pipesize++;
        }
        if (p[0])
        {
            piexec(cmd, p, pipesize);
        }
        else
            execcmd(cmd);

        if (in)
        {
            if (dup2(sfd, STDIN_FILENO) == -1)
            {
                fprintf(stderr, "error dup2\n");
            }
            in = 0;
        }
        // printf("realsize = %d\n",realsize);
        for (int i = 0; i < realsize; i++)
        {
            if ((add && (i == add)) || (out && (i == out)) || (in && (i == in)))
                continue;
            free(cmd[i]);
            cmd[i] = NULL;
        }
        free(cmd);
        cmd = NULL;
    }
    free(last);
    return 0;
}

5.全局变量解释：in 重定向输入，out 重定向输出，add 重定向追加，pipesize 管道数量，cmdsize 二维字符数组中的一维数量

6.mywait函数回收子进程

void mywait(pid_t pid, int *status, int options)
{
    waitpid(pid, status, options);

    if (WIFSIGNALED(*status))
    {
        printf("\nshell be killed by %d", WTERMSIG(*status));
        if (WCOREDUMP(*status))
        {
            printf("\n退出 (核心已转储)");
        }
    }
}

7.源代码

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/fcntl.h>
#include <sys/stat.h>
#include <errno.h>

int in = 0, out = 0, add = 0, bg = 0, cmdsize = 100, realsize = 0;
char *last;

char **getcmd(int *p);
char **cutcmd(char *input);
void execcmd(char **cmd);
void swap(int *fd0, int *fd1);
void piexec(char **cmd, int *p, int pipesize);
void piexec1(char **cmd, int *p, int pipesize);
void mywait(pid_t pid, int *status, int options);
void newexec(char **cmd, int *p, int pipesize, int start, int head);

int main(void)
{
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGINT);
    sigprocmask(SIG_BLOCK, &set, NULL);
    setvbuf(stdout, NULL, _IONBF, 0);

    last = (char *)malloc(sizeof(char) * 100);

    while (1)
    {
        out = 0, add = 0, realsize = 0;
        int p[10] = {0}, sfd, fd, pipesize = 0;
        printf("# ");

        char **cmd = getcmd(p);
        if (strcmp(cmd[0], "\n") == 0)
        {
            free(cmd[0]);
            cmd[0] = NULL;
            free(cmd);
            cmd = NULL;
            continue;
        }

        int aaa = 0;
        if (in)
        {
            sfd = dup(STDIN_FILENO);
            fd = open(cmd[in], O_RDWR, S_IRUSR | S_IWUSR);
            if (dup2(fd, STDIN_FILENO) == -1)
            {
                fprintf(stderr, "error dup2\n");
                exit(1);
            }
            free(cmd[in]);
            cmd[in] = NULL;
        }

        if (strcmp(cmd[0], "exit") == 0)
        {
            exit(0);
        }
        else if (strcmp(cmd[0], "cd") == 0)
        {
            if (cmd[1] && strcmp(cmd[1], "-") == 0)
            {
                if (last)
                {

                    char *buf = (char *)malloc(sizeof(char) * 100);
                    getcwd(buf, 100);
                    printf("%s\n", last);

                    chdir(last);

                    strcpy(last, buf);
                }
                else
                { // last==NULL
                    printf("bash: cd: OLDPWD 未设定\n");
                }
            }
            else
            {

                getcwd(last, 100);
                chdir(cmd[1]);
            }

            continue;
        }

        for (int i = 0; i < 10; i++)
        {
            if (p[i])
                pipesize++;
        }
        if (p[0])
        {
            piexec(cmd, p, pipesize);
        }
        else
            execcmd(cmd);

        if (in)
        {
            if (dup2(sfd, STDIN_FILENO) == -1)
            {
                fprintf(stderr, "error dup2\n");
            }
            in = 0;
        }
        // printf("realsize = %d\n",realsize);
        for (int i = 0; i < realsize; i++)
        {
            if ((add && (i == add)) || (out && (i == out)) || (in && (i == in)))
                continue;
            free(cmd[i]);
            cmd[i] = NULL;
        }
        free(cmd);
        cmd = NULL;
    }
    free(last);
    return 0;
}

char **getcmd(int *p)
{
    char **cmd = (char **)malloc(sizeof(char *) * cmdsize);
    char *input = (char *)malloc(sizeof(char) * 1000);
    int len = 0, count = 0, pi = 0, i = 0;
    if (fgets(input, 1000, stdin) == NULL)
    {
        input[0] = 0;
    }

    int l = strlen(input);
    if (l == 0)
    {

        free(cmd);
        free(input);
        exit(0);
    }

    if (strcmp(input, "\n") == 0)
    {
        cmd[0] = (char *)malloc(5);
        strcpy(cmd[0], "\n");
        free(input);
        return cmd;
    }

    input[l - 1] = '\0';
    // add_history(input);
    while (len < l - 1)
    {
        while (input[len] == ' ')
        {
            len++;
            i++;
        }

        while (len < l - 1 && (input[len] != ' ' && input[len] != '|' && input[len] != '>' && input[len] != '<' && input[len] != '&'))
        {
            if (input[len] == '&')
            {
                bg = 1;
                input[len] = ' ';
            }

            len++;
        }
        cmd[count] = (char *)malloc(sizeof(char) * 20);
        realsize++;
        strncpy(cmd[count++], input + i, len - i);
        cmd[count - 1][len - i] = '\0';
        if (strcmp(cmd[count - 1], "~") == 0)
        {
            strcpy(cmd[count - 1], "/home/kangning");
        }
        // printf("|%s|\n",cmd[count-1]);
        while (input[len] == ' ' || input[len] == '&')
        {
            if (input[len] == '&')
            {
                bg = 1;
            }
            len++;
        }

        if (input[len] == '<')
        {
            in = count;
            len++;
        }
        else if (input[len] == '>')
        {
            len++;
            if (input[len] == '>')
            {
                len++;
                add = count;
            }
            else
                out = count;
        }
        if (input[len] == '|')
        {
            len++;
            p[pi++] = count;
        }

        while (input[len] == ' ' || input[len] == '<' || input[len] == '|' || input[len] == '>')
        {
            len++;
        }
        i = len;
    }
    free(input);
    input = NULL;
    return cmd;
}

char **cutcmd(char *input)
{
    char **cmd = (char **)malloc(sizeof(char *) * cmdsize);
    int len = 0, count = 0, pi = 0, i = 0;

    int l = strlen(input);
    while (len < l)
    {

        cmd[count] = (char *)malloc(sizeof(char) * 20);
        while (len < l && (input[len] != ' '))
        {
            len++;
        }
        strncpy(cmd[count++], input + i, len - i);
        if (strcmp(cmd[count - 1], "~") == 0)
        {
            strcpy(cmd[count - 1], "/home/kangning");
        }
        i = len;

        while (input[len] == ' ' || input[len] == '|')
        {
            i++;
            len++;
        }
    }
    return cmd;
}

void execcmd(char **cmd)
{
    pid_t pid;
    int status;
    pid = fork();

    switch (pid)
    {
    case -1:
        perror("fork");
        return;
    case 0:
        if (out)
        {
            int fd;

            if ((fd = open(cmd[out], O_RDWR | O_CREAT | O_TRUNC, S_IWUSR | S_IRUSR)) == -1)
            {
                perror("open");
            }

            dup2(fd, STDOUT_FILENO);
            close(fd);
            free(cmd[out]);
            cmd[out] = NULL;
        }
        if (add)
        {
            int fd;

            if ((fd = open(cmd[add], O_RDWR | O_CREAT, S_IWUSR | S_IRUSR)) == -1)
            {
                perror("open");
            }
            lseek(fd, -1, SEEK_END);
            dup2(fd, STDOUT_FILENO);
            close(fd);
            free(cmd[add]);
            cmd[add] = NULL;
        }
        execvp(cmd[0], cmd);
    default:
        if (!bg)
            mywait(pid, &status, 0);
    }
}

void swap(int *fd0, int *fd1)
{
    int temp = *fd0;
    *fd0 = *fd1;
    *fd1 = temp;
}

void mywait(pid_t pid, int *status, int options)
{
    waitpid(pid, status, options);

    if (WIFSIGNALED(*status))
    {
        printf("\nshell be killed by %d", WTERMSIG(*status));
        if (WCOREDUMP(*status))
        {
            printf("\n退出 (核心已转储)");
        }
    }
}

void piexec(char **cmd, int *p, int pipesize)
{
    char subcmd[10][50]={};
    int start = 0, i = 0, status;
    pid_t ppid;

    for (i = 0; i < pipesize; i++)
    {
        for (int j = start; j < p[i]; j++)
        {
            if (cmd[j])
            {
                strcat(subcmd[i], cmd[j]);
                strcat(subcmd[i], " ");
            }
        }
        start = p[i];
    }

    ppid = fork();
    if (ppid == -1)
    {
        perror("fork");
    }
    else if (ppid == 0)
    {
        pid_t pid;
        int sfd[2];
        for (i = 0; i <= pipesize; i++)
        {
            if (i == 0)
            {
                if ((pid = fork()) == -1)
                {
                    perror("fork");
                }
                else if (pid == 0)
                {
                    int fd[2];
                    if ((fd[0] = open("fifo1", O_RDWR | O_CREAT | O_TRUNC, S_IWUSR | S_IRUSR)) == -1)
                    {
                        perror("open");
                    }
                    if ((fd[1] = open("fifo2", O_RDWR | O_CREAT | O_TRUNC, S_IWUSR | S_IRUSR)) == -1)
                    {
                        perror("open");
                    }

                    sfd[1] = dup(STDOUT_FILENO);
                    dup2(fd[1], STDOUT_FILENO);
                    char **tmp = cutcmd(subcmd[i]);
                    execvp(cmd[0], tmp);
                }
                else
                {
                    mywait(pid, &status, 0);
                    dup2(sfd[1], STDOUT_FILENO);
                }
            }
            else if (i < pipesize)
            {
                if ((pid = fork()) == -1)
                {
                    perror("fork");
                }
                else if (pid == 0)
                {
                    int fd[2];
                    if ((fd[0] = open("fifo1", O_RDWR | O_CREAT, S_IWUSR | S_IRUSR)) == -1)
                    {
                        perror("open");
                    }
                    if ((fd[1] = open("fifo2", O_RDWR | O_CREAT, S_IWUSR | S_IRUSR)) == -1)
                    {
                        perror("open");
                    }
                    swap(&fd[0], &fd[1]);

                    sfd[1] = dup(STDOUT_FILENO);
                    sfd[0] = dup(STDIN_FILENO);

                    dup2(fd[0], STDIN_FILENO);
                    dup2(fd[1], STDOUT_FILENO);
                    close(fd[0]);
                    close(fd[1]);
                    execvp(cmd[p[i]], cutcmd(subcmd[i]));
                }
                else
                {
                    mywait(pid, &status, 0);
                    dup2(sfd[0], STDIN_FILENO);
                    dup2(sfd[1], STDOUT_FILENO);
                }
            }
            else
            {
                if ((pid = fork()) == -1)
                {
                    perror("fork");
                }
                else if (pid == 0)
                {
                    int fd[2];
                    if ((fd[0] = open("fifo1", O_RDWR | O_CREAT, S_IWUSR | S_IRUSR)) == -1)
                    {
                        perror("open");
                    }
                    if ((fd[1] = open("fifo2", O_RDWR | O_CREAT, S_IWUSR | S_IRUSR)) == -1)
                    {
                        perror("open");
                    }
                    if (pipesize % 2)
                        swap(&fd[0], &fd[1]);

                    sfd[0] = dup(STDIN_FILENO);
                    int res = dup2(fd[0], STDIN_FILENO);
                    if (res == -1)
                    {
                        fprintf(stderr, "error dup2\n");
                        exit(1);
                    }
                    if (out)
                    {
                        int fd;
                        if ((fd = open(cmd[out], O_RDWR | O_CREAT | O_TRUNC, S_IWUSR | S_IRUSR)) == -1)
                        {
                            perror("open");
                        }

                        dup2(fd, STDOUT_FILENO);
                        close(fd);
                        free(cmd[out]);
                        cmd[out] = NULL;
                    }
                    if (add)
                    {
                        int fd;

                        if ((fd = open(cmd[add], O_RDWR | O_CREAT, S_IWUSR | S_IRUSR)) == -1)
                        {
                            perror("open");
                        }
                        lseek(fd, -1, SEEK_END);
                        dup2(fd, STDOUT_FILENO);
                        close(fd);
                        free(cmd[add]);
                        cmd[add] = NULL;
                    }
                    close(fd[0]);
                    close(fd[1]);
                    printf("here\n");
                    execvp(cmd[start], cmd + start);
                }
                else
                {
                    mywait(pid, &status, 0);
                    dup2(sfd[0], STDIN_FILENO);
                }
            }
        }
    }
    else if (ppid > 0)
    {
        if (!bg)
        {
            mywait(ppid, &status, 0);
        }
        // while(1){
        //     sleep(1);
        //     printf("-");
        // }
        unlink("fifo1");
        unlink("fifo2");
    }
}

写在最后：程序还有一些不完善的地方，不过还能忍，可以接受

自己编写简单的shell
tttst的专栏
05-09 551
ubuntu 14.04.2 自己编写一个简单的shell （简单爆了，因为这是我自己写的） （虽然简单，但是最基本的功能还是能够实现的） （头一回按照自己的思路独立写几行代码，感觉不错哦）函数execvp(progname,arglist)的功能 将指定的程序复制到调用它的进程 将指定的字符串数组作为argv[]传给这个程序 运行这个程序 头文件：#include<unistdh> 函数
【Linux系统】自制简易shell的实现日志
从不依靠，从不寻找，非常沉默，非常骄傲。 你必须非常努力，才能看起来毫不费力。
10-18 1944
超 2W 字详细讲解如何自制一个简易的shell，实现：调用并执行系统命令、运行几个内建命令等等功能
shell的编写
03-09 1336
编写自己的Shell解释器 来源：http://www.youkuaiyun.com/subject/linux/ ————————————————————————————————— 摘要：本期的目的是向大家介绍shell的概念和基本原理，并且在此基础上动手做一个简单shell解释器。同时，还将就用到的一些 linux环境编程的知识做一定讲解。 本文适合的读者对象 对linux环境上的c语言开发有一定经验；
shell脚本竟如此简单【shell脚本基础】
最新发布
Parzaifal的博客
05-23 985
学习shell脚本基础编程
制作一个微型shell
Ferlan的博客
09-20 625
1 /* 模拟shell写一个咱们自己的微型myshell 2 * 功能：myshell&amp;amp;amp;gt; ls 3 * 能够执行各种命令 4 * 5 */ 6 #include &amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; 7 #include &amp;amp;amp;lt;unistd.h&amp;amp;amp;gt; 8
我的自制shell，MINI型
Manio
08-15 2282
像普通C程序一样编译运行即可。mini.h/*filename:mini.h*/#define WHITESPACE    " ., &"#define MAX_ARG_LEN        10#define MAX_DIRS           20#define MAX_PATH_LEN       100#define STD_INPUT          0#define STD
写一个自己的shell
无聊星期三的博客
09-04 4853
shell 什么是shell？ shell就像是在linux中的一个媒婆，我们给shell命令，shell来告诉系统我们需要做什么，为我们牵线，实现调用操作系统提供给我们的接口，shell提供了你与操作系统之间通讯的方式。 shell是操作系统最外面的一层。shell管理你与操作系统之间的交互：等待你输入，向操作系统解释你的输入，并且处理各种各样的操作系统的输出结果。 下图中红圈的东西即s...
C语言自制简易shell程序，精简代码仅60行
Shell程序可以是简单的命令行界面，也可以是具有复杂功能和图形用户界面的系统。在Unix和类Unix系统中，最常用的shell是bash（Bourne Again SHell）。用C语言实现一个简单的shell能够帮助开发者深入理解操作系统的...
从零开始制作简易Shell解释器教程
制作自己的Shell解释器需要一定的Linux环境编程知识，包括但不限于： - **系统调用**：Linux系统提供了一系列系统调用供编程使用，Shell可以通过这些调用来执行底层的操作。 - **进程管理**：Shell需要创建和管理...
c语言制作简易shell重定向
12-18
在C语言中制作一个简易shell重定向，通常涉及到文件操作和标准输入输出流的控制。 shell重定向允许将输出或输入重定向到不同的位置，如文件、终端或其他进程。下面是一个简单的例子，展示了如何使用C语言模拟`>`...
奋斗少年自制Windows Shell环境
10-10
制作一个简易的Windows Shell环境，通常需要从以下几个方面着手： 1. 环境准备：制作Windows Shell环境之前，需要安装好相应的开发工具和环境。常用的开发工具有Visual Studio、MinGW或者其他支持Windows开发的IDE...
C例子：DIY shell
12-06
该程序是我写的博客“一起talk C栗子吧（第七十一回：C语言实例--DIY shell）”的配套程序，共享给大家使用
体会Linux与生俱来的美　高级篇　编写自己的Shell解释器（全文）
Purpleendurer@优快云
06-13 4248
http://www.youkuaiyun.com/subject/linux/shell.mht编写自己的Shell解释器摘要：本期的目的是向大家介绍shell的概念和基本原理，并且在此基础上动手做一个简单shell解释器。同时，还将就用到的一些 linux环境编程的知识做一定讲解。本文适合的读者对象       对linux环境上的c语言开发有一定经验；对linux环境编程（比如进程、管道）有一点了解。概
linux 编写自己的shell
fulianzhou的专栏
02-29 406
// 已实现的功能: // 1.普通的shell命令 例如:ls -la; vim smsh3.c // 2.变量存储与替换 例如:set 显示所有的变量 // a=x; x=who am i 添加变量或者修改变量的值 // echo $x; $x 变量替换 #include
做一个简单的shell
didi1663478999的博客
08-19 875
考虑下面这个与shell典型的互动： 用下面的时间轴来表示时间发生的次序，其中时间从左到右。shell由标识的方块代表，它随着时间的流逝从左向右移动。shell从用户读入字符串“ls”。shell建立一个新的进程，然后在那个进程中运行ls程序并等待那个进程结束。 然后shell读取新的一行输入，建立一个新的进程，在这个进程中运行程序，并等待这个进程结束。所以要写一个shell，需要循环以下过程...
创建一个属于自己的shell
zcl9796的博客
09-20 1541
1 /*写一个属于自己的微型myshell 2 * 功能：myshell&gt;ls 3 * 能够执行基础Linux 命令 4 * 5 */ 6 #include&lt;stdio.h&gt; 7 #include&lt;unistd.h&gt; 8 #include&lt;errno.h&gt; 9 #i...
自制小shell
mtawaken的专栏
07-20 1654
曾经被面试过一个问题就是“从终端输入一个命令到显示出结果中间的过程shi”
命令 shell_编写自己的 Shell 命令（下）
weixin_35779309的博客
01-14 457
有些时候，我们编写的 EFI 程序不希望有人改动，这个时候就可以考虑将程序“藏”到 Shell 中。本文就实验将 RU.EFI 编译到 Shell 中。为了更好的理解本文的方案，最好先阅读理解前介绍过的如何将一个 EFI 程序包含在另外的 EFI中运行的方法【参考1】。具体方法是将下面的代码直接插入上一篇的 lzc.c 中： // // print it... ...
实现自己的shell
weixin_59514216的博客
08-29 738
实现自己的shell
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

倚风听雨.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值