编写一个C程序作为Linux内核的shell命令行解释程序。Shell程序应该使用与Bource shell相同的方式运行程序。 增加功能以使用户可以使用“&”操作符作为命令的结束符。一个以“&”结尾的命令应该与shell并发执行。 增加功能以使用户可以使用“<”和“>”作为文件名前缀来重定向stdin和stdout描述符。同样，允许用户使用管道操作符“|”来同时执行两个进程，并把第一个进程的stdout重定向为第二个进程的stdin。

由于这个问题比较复杂，需要编写一段C程序来实现一个Linux shell的基本功能，因此我会给出一些大致的思路和伪代码。

首先需要理解一下Linux shell的基本工作流程：

1. 读取用户输入的命令行字符串。
2. 解析命令行字符串，得到命令和参数。
3. 创建一个新进程并执行命令。
4. 等待命令执行完成并获取命令的退出状态。

在此基础上，我们可以添加一些功能：

1. 支持后台执行命令，即使用“&”操作符作为命令的结束符。
2. 支持重定向stdin和stdout描述符，即使用“<”和“>”作为文件名前缀。
3. 支持管道操作符“|”，将第一个进程的stdout重定向为第二个进程的stdin。

下面是一个大致的伪代码实现：

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

#define MAX_ARGS 128
#define MAX_CMD_LEN 1024

int main() {
  char cmd[MAX_CMD_LEN];
  char *args[MAX_ARGS];
  int i, j, k, num_args;
  pid_t pid;
  int status;
  int in_fd, out_fd;
  int pipefd[2];

  while (1) {
    // 读取用户输入的命令行字符串
    printf("> ");
    fgets(cmd, MAX_CMD_LEN, stdin);
    cmd[strcspn(cmd, "\n")] = '\0';

    // 解析命令行字符串，得到命令和参数
    num_args = 0;
    args[num_args++] = strtok(cmd, " ");
    while ((args[num_args] = strtok(NULL, " ")) != NULL) {
      num_args++;
    }

    // 处理后台执行命令
    int background = 0;
    if (num_args > 0 && strcmp(args[num_args - 1], "&") == 0) {
      background = 1;
      args[num_args - 1] = NULL;
      num_args--;
    }

    // 处理重定向stdin和stdout描述符
    in_fd = STDIN_FILENO;
    out_fd = STDOUT_FILENO;
    for (i = 0; i < num_args; i++) {
      if (strcmp(args[i], "<") == 0 && args[i + 1] != NULL) {
        in_fd = open(args[i + 1], O_RDONLY);
        if (in_fd < 0) {
          perror("open");
          exit(EXIT_FAILURE);
        }
        args[i] = NULL;
        i++;
      } else if (strcmp(args[i], ">") == 0 && args[i + 1] != NULL) {
        out_fd = open(args[i + 1], O_WRONLY | O_CREAT | O_TRUNC, 0644);
        if (out_fd < 0) {
          perror("open");
          exit(EXIT_FAILURE);
        }
        args[i] = NULL;
        i++;
      }
    }

    // 处理管道操作符
    int pipe_index = -1;
    for (i = 0; i < num_args; i++) {
      if (strcmp(args[i], "|") == 0) {
        pipe_index = i;
        break;
      }
    }
    if (pipe_index >= 0) {
      if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
      }
      pid = fork();
      if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
      } else if (pid == 0) {
        // 子进程，重定向stdin到管道读端
        close(pipefd[1]);
        dup2(pipefd[0], STDIN_FILENO);
        close(pipefd[0]);

        // 执行第二个进程
        args[pipe_index] = NULL;
        execvp(args[pipe_index + 1], &args[pipe_index + 1]);
        perror("execvp");
        exit(EXIT_FAILURE);
      } else {
        // 父进程，重定向stdout到管道写端
        close(pipefd[0]);
        dup2(pipefd[1], STDOUT_FILENO);
        close(pipefd[1]);

        // 执行第一个进程
        args[pipe_index] = NULL;
        execvp(args[0], args);
        perror("execvp");
        exit(EXIT_FAILURE);
      }
    } else {
      // 创建一个新进程并执行命令
      pid = fork();
      if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
      } else if (pid == 0) {
        // 子进程，重定向stdin和stdout描述符
        dup2(in_fd, STDIN_FILENO);
        dup2(out_fd, STDOUT_FILENO);

        // 执行命令
        execvp(args[0], args);
        perror("execvp");
        exit(EXIT_FAILURE);
      } else {
        // 父进程，等待命令执行完成并获取命令的退出状态
        if (!background) {
          waitpid(pid, &status, 0);
        }
      }
    }
  }

  return 0;
}

需要注意的是，在使用管道操作符“|”时，我们需要先fork一个子进程来执行第二个进程，然后再在父进程中执行第一个进程。这是因为管道操作符“|”会创建一个管道，将第一个进程的stdout重定向到管道写端，将第二个进程的stdin重定向到管道读端，这样就可以实现两个进程之间的数据传输。

此外，我们还需要注意在使用重定向stdin和stdout描述符时，需要在执行命令之前先打开文件并将文件描述符重定向到对应的文件。在使用完文件之后，还需要将文件描述符关闭，以避免文件泄漏和资源浪费。

最后，需要注意的是，由于本代码没有完全测试，可能存在一些语法错误或者逻辑错误，仅供参考。