使用 memcpy 或 strcpy 在子進程中將 c 字符串從 1 個緩沖區復制到另一個緩沖區似乎不起作用

Question

我正在嘗試編寫一個模擬 shell，它保存命令行歷史記錄並覆蓋SIGINT的信號操作以觸發打印用戶輸入的前 10 個命令。 據我所知，從處理所有信號到使用execvp更新游標和運行命令，一切都很好。

然而，我遇到了兩個問題，我很難想辦法解決這些問題。

1. 嘗試將輸入緩沖區的內容實際復制到我自己的 c 字符串向量（即histv 。 在調用read並將用戶輸入存儲在buf ，我嘗試將buf的內容復制到histv[cursor % MAX_HISTORY]處的位置（我使用模數的原因是因為使用一種圓形數組而不是處理似乎更容易光標上升到大於MAX_HISTORY某個數字的情況）

2. 當我嘗試將進程作為后台進程運行時，即使命令有效，我也總是收到 execvp 錯誤。 我知道在父進程獲得SIGUSR2信號並創建一個新的子進程來運行命令之后它會發生。 所以我假設它與子進程殺死自己並引發SIGUSR2后argv發生的事情有關

下面是整個程序的代碼。 有些地方有點亂，但總體來說還是比較簡單的。 我已經使用了所有memcpy 、 strcpy和strncpy都無濟於事。 它們都編譯並運行沒有錯誤，但它們似乎都沒有做任何事情。

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

// limits
#define MAX_LINE 80
#define MAX_HISTORY 10

// function headers
void print_history(unsigned int const, char**);
void handler_func(int);
void read_func(char*[], char[], char**, unsigned int const);
int parse_args(char*, char**, size_t);

// globals
volatile sig_atomic_t sig_caught = 0;

void print_history (const unsigned int cursor, char **histv) {
    int temp = (cursor > MAX_HISTORY) ? (cursor - MAX_HISTORY) : 0;

    puts("\n\nprinting the previous ten commands...");
    printf("cursor %d", cursor);

    for (int i = 1; temp < cursor; temp++) {
        printf("%d%s\n", i++, histv[temp % MAX_HISTORY]);
    }
}

void handler_func(int sig)
{   
    /* update loop control variable */
    sig_caught = 1;
}

int main(void)
{
    // declare sigaction struct
    struct sigaction sigactor;

    // initialize sigaction struct
    sigactor.sa_handler = handler_func;
    sigemptyset(&sigactor.sa_mask);
    sigactor.sa_flags = 0;

    // set up sigaction for SIGINT
    if (sigaction(SIGINT, &sigactor, NULL) == -1) {
        perror("siagction() failed");
        _exit(EXIT_FAILURE);
    }


    // set the buffer to no buffering
    setvbuf(stdout, NULL, _IONBF, 0);

    unsigned int cursor = 0;

    /* initlialize history vector */
    char **histv = (char**)malloc(sizeof(char*) * MAX_HISTORY);
    for (int i = 0; i < MAX_HISTORY; i++) 
        histv[i] = (char*)malloc(sizeof(char) * MAX_LINE);

    // enter shell loop
    while (1) {

        /* fork process and get child pid */
        int cpid;

        char *argsv[MAX_LINE/2+1];
        char buf[MAX_LINE];


        while(!sig_caught) {

            cpid = fork();

            /* child */
            if (cpid == 0) {
                read_func(argsv, buf, histv, cursor);
            }

            /* fork error */
            else if (cpid < 0) {
                perror("Error forking process");
                _exit(EXIT_FAILURE);
            }

            /* parent process begins here */
            else {

                /* variable to store status returned from child*/
                int cstatus;

                /* suspend parent until child exits *
                 * store return status in cstatus   */
                waitpid(cpid, &cstatus, 0);

                /* get status from child process and check for SIGTERM *
                 * SIGTERM is raised by child when someone enters '!q' */
                switch(WTERMSIG(cstatus))
                {
                /* user wants to quit */
                case SIGTERM:
                    puts("User issued quit command");
                    for (int i = 0; i < MAX_HISTORY; i++) 
                        free((void *)histv[i]);
                    free((void *)histv);
                    _exit(EXIT_SUCCESS);

                /* invalid string length */
                case SIGUSR1: 
                    puts("Please enter a valid string");
                    break;

                /* background process */
                case SIGUSR2:
                    cpid = fork();
                    if (cpid < 0) perror("Error forking process...");
                    else if (cpid == 0) {
                        if (execvp(argsv[0], argsv) < 0) {
                            --cursor;
                            perror("execvp");
                            kill(getpid(), SIGUSR1);
                        }
                    }
                }

                if (!sig_caught) cursor++;
            }

        }// signal loop

        kill (cpid, SIGTERM);
        print_history(cursor, histv);
        fflush(stdout);
        sig_caught = 0;

    }
}

void read_func(char *argsv[], char buf[], char *histv[], unsigned int const cursor)
{
    printf("\nCMD > ");

    int background = 0;

    size_t length = read(STDIN_FILENO, buf, MAX_LINE);

    if (length > 80 || length <= 0) kill(getpid(), SIGUSR1);

    /* copy buffer into history and update cursor */
    memcpy(histv[cursor % MAX_HISTORY], buf, length);

    printf("cursor %d", cursor);
    /* parse arguments and return number of arguments */
    background = parse_args(buf, argsv, length);

    /* user entered quit command or string is invalid */
    if (background == -1) kill(getpid(), SIGTERM);

    /* signal parent to run process in the background */
    if (background == 1) kill(getpid(), SIGUSR2);

    /* run command */
    if (execvp(argsv[0], argsv) < 0) {
        perror("execvp");
        _exit(EXIT_FAILURE);
    }

}

int parse_args(char buf[], char *argsv[], size_t length)
{

    int i,      /* loop index for accessing buf array */
        start,  /* index where beginning of next command parameter is */
        ct,     /* index of where to place the next parameter into args[] */
        bckg;   /* background flag */


    /* read what the user enters on the command line */
    ct = 0;
    start = -1;
    bckg = 0;

    if (buf[0] == '!' && buf[1] == 'q') return -1;

    /* examine every character in the buf */
    for (i = 0; i < length; i++) {
        switch (buf[i]){
            case ' ':
            case '\t':       /* argument separators */
                if(start != -1){
                    argsv[ct] = &buf[start];    /* set up pointer */
                    ct++;
                }
                buf[i] = '\0'; /* add a null char; make a C string */
                start = -1;
                break;

            case '\n':                 /* should be the final char examined */  
                if (start != -1){
                    argsv[ct] = &buf[start];
                    ct++;
                }
                buf[i] = '\0';
                argsv[ct] = NULL; /* no more arguments to this command */
                break;

            case '&':
                bckg = 1;
                buf[i] = '\0';
                break;

            default:             /* some other character */
                if (start == -1)
                    start = i;
        }
    }
    argsv[ct] = NULL; /* just in case the input line was > 80 */

    return bckg;
}

旁注， parse_args函數最初是提供給我們的，我對其進行了一些更改以與程序的其余部分一起使用，但在大多數情況下我沒有編寫該函數。

請放輕松，我已經很久沒有使用 C 做任何事情了，我在這里所做的很多事情都花了很多精力來開始理解這個程序的行為方式。 (~:

Answer 1

因此，兩個問題都與內存未共享這一事實有關，如o11c 所述。 我通過使用mmap而不是malloc解決了這個問題，這反過來簡化了我的程序，因為我不再需要處理內存管理。 變化描述如下。

char **histv = (char**)malloc(sizeof(char*) * MAX_HISTORY);
for (int i = 0; i < MAX_HISTORY; i++) 
    histv[i] = (char*)malloc(sizeof(char) * MAX_LINE);

改為

char **histv = (char**)mmap(NULL, (sizeof(char*) * MAX_HISTORY), (PROT_READ | PROT_WRITE), (MAP_SHARED | MAP_ANONYMOUS), -1, 0);
for (int i = 0; i < MAX_HISTORY; i++) histv[i] = (char*)mmap(NULL,  (sizeof(char) * MAX_LINE), (PROT_READ | PROT_WRITE), (MAP_SHARED | MAP_ANONYMOUS), -1, 0);

雖然我不知道這是否是最好的方法，但它解決了我的問題。

另請注意，我確實使用munmap明確取消了內存映射，即使它在技術上應該在退出時自動處理。