如何修复命令服务器无法显示所有管道命令输出的问题？

我正在实现一个命令服务器程序，目前可处理单个命令，但无法处理如「ls | ps aux」这类管道复合命令。当前代码仅会输出最后一条命令的结果（例如仅显示「ps aux」的输出），即使用户输入多段管道命令如「ls | ps aux | ls」，也仅显示最后一个「ls」的输出。我尝试使用多管道（最多支持10条命令）实现，将前序命令的输入重定向至管道，最后一条命令的输出重定向至临时文件再发送给客户端，但仍无法显示所有命令的输出。相关处理逻辑的代码如下：

case COMLINE: {
    char client_message[MAX_MSG_SIZE];
    bytes_read = read(cs_fd, client_message, MAX_MSG_SIZE);
    if (bytes_read == -1) {
        perror("read");
        exit(EXIT_FAILURE);
    }
    client_message[bytes_read] = '\0'; 
    printf("Command received: %s\n", client_message);

    // Split the command string into individual commands
    char *commands[10]; // Assuming a maximum of 10 commands in a pipeline
    int n_commands = 0;
    char *token = strtok(client_message, "|");
    while (token != NULL) {
        commands[n_commands++] = token;
        token = strtok(NULL, "|");
    }

    if (n_commands == 0) {
        // Handle the case where no commands are found
        break;
    }

    // Dynamically allocate pipefd
    int *pipefd = malloc(2 * (n_commands - 1) * sizeof(int));
    if (pipefd == NULL) {
        perror("malloc");
        exit(EXIT_FAILURE);
    }

    // Create pipes
    for (int i = 0; i < (n_commands - 1); i++) {
        if (pipe(pipefd + i*2) < 0) {
            perror("pipe");
            exit(EXIT_FAILURE);
        }
    }

    // Create a temporary file to store the last command's output
    FILE *temp_output = tmpfile();
    if (temp_output == NULL) {
        perror("tmpfile");
        exit(EXIT_FAILURE);
    }

    // Execute each command
    for (int i = 0; i < n_commands; i++) {
        pid_t pid = fork();
        if (pid == -1) {
            perror("fork");
            exit(EXIT_FAILURE);
        } else if (pid == 0) { // Child process
            // Redirect input from the previous command
            if (i != 0) {
                if (dup2(pipefd[(i-1)*2], STDIN_FILENO) < 0) {
                    perror("dup2");
                    exit(EXIT_FAILURE);
                }
            }

            // Redirect output to the next command or the temp file
            if (i != n_commands - 1) {
                if (dup2(pipefd[i*2 + 1], STDOUT_FILENO) < 0) {
                    perror("dup2");
                    exit(EXIT_FAILURE);
                }
            } else {
                // Last command: redirect output to temp file
                if (dup2(fileno(temp_output), STDOUT_FILENO) < 0) {
                    perror("dup2");
                    exit(EXIT_FAILURE);
                }
            }

            // Close all pipe file descriptors
            for (int j = 0; j < 2*(n_commands-1); j++) {
                close(pipefd[j]);
            }

            // Execute the command
            execlp("/bin/sh", "sh", "-c", commands[i], NULL);
            perror("execlp");
            exit(EXIT_FAILURE);
        }
    }

    // Close all pipe file descriptors in the parent
    for (int i = 0; i < 2*(n_commands-1); i++) {
        close(pipefd[i]);
    }
    free(pipefd);

    // Wait for all child processes to finish
    for (int i = 0; i < n_commands; i++) {
        wait(NULL);
    }


    // Send the output to the client
    Message response;
    fseek(temp_output, 0, SEEK_END);
    response.length = ftell(temp_output);
    response.type = COMRESULT;
    write(sc_fd, &response, sizeof(response));

    rewind(temp_output);
    while ((bytes_read = fread(temp_buffer, 1, wsize, temp_output)) > 0) {
        ssize_t written = write(sc_fd, temp_buffer, bytes_read);
        if (written == -1) {
            perror("write");
            exit(EXIT_FAILURE);
        }
        printf("Sent: %d\n", (int)written);
        
        // Print sent bytes individually
        printf("Sent: ");
        for (ssize_t i = 0; i < written; ++i) {
            printf("%c", temp_buffer[i]);
        }
        printf("\n");

        if(written < wsize){
            break;
        }
    }

    // Close the temporary file
    fclose(temp_output);
    break;
}

首先需要明确：管道的核心逻辑是前一个命令的标准输出作为后一个命令的标准输入，整个管道的最终输出是最后一个命令处理后的结果，而非所有命令的输出拼接。例如ls | ps aux中，ps aux本身不读取标准输入，因此它的输出和单独执行一致，这是管道的正常行为。如果你的预期是让所有命令独立执行并输出结果，应该使用分号（;）分隔命令，而非管道。

如果确实需要实现标准管道功能，你的代码可以从以下几个方面优化修复：

• 处理命令前后的空格
  strtok按|分割后，命令字符串前后可能包含空白字符（比如输入ls | ps aux会得到"ls "和" ps aux"），虽然sh -c可以兼容，但可能引发意外问题。添加trim函数去除命令前后空白：

  #include <ctype.h>
  char* trim(char* str) {
      // 去除开头空格
      while(isspace((unsigned char)*str)) str++;
      if(*str == 0) return str;
      // 去除结尾空格
      char* end = str + strlen(str) - 1;
      while(end > str && isspace((unsigned char)*end)) end--;
      end[1] = '\0';
      return str;
  }
  

  分割命令后调用该函数：

  commands[n_commands++] = trim(token);
  

• 重定向错误输出到客户端
  当前代码仅重定向了标准输出，命令执行的错误信息（stderr）会输出到服务器终端，无法传递给客户端。在子进程中添加stderr重定向：

  // 在stdout重定向完成后添加
  if (dup2(STDOUT_FILENO, STDERR_FILENO) < 0) {
      perror("dup2 stderr");
      exit(EXIT_FAILURE);
  }
  

• 增强子进程等待的健壮性
  原代码用wait(NULL)循环固定次数，改用waitpid等待所有子进程退出，避免因退出顺序导致的问题：

  int status;
  pid_t pid;
  while ((pid = waitpid(-1, &status, 0)) > 0) {
      // 可选：记录子进程退出状态
  }
  

• 确保临时文件输出完整
  虽然子进程退出时会自动刷新文件缓冲，但在父进程读取前显式刷新临时文件，避免缓冲数据未写入：

  // 在wait循环结束后添加
  fflush(temp_output);
  

如果你的真实需求是执行多个独立命令并汇总所有输出，需要将命令分割符改为分号（;），并让每个命令的输出追加到临时文件（无需管道传递）：

// 修改分割逻辑
char *token = strtok(client_message, ";");
while (token != NULL) {
    commands[n_commands++] = trim(token);
    token = strtok(NULL, ";");
}

内容的提问来源于stack exchange，提问作者Kerim Eren