C中的简单http服务器，多进程无法正常工作 解决方法是在完成一次重复后添加fseek（文件，0，0）。

我正在编写一个非常简单的http服务器，它将用http响应响应任何GET请求。响应内容将在程序启动时传递给程序，例如

$./server test1.html 999

此命令将打开listen to 999端口，如果收到任何GET请求，服务器将向请求客户端发送“http头”+“content of test1.html”

fork（）部分不能很好地工作，我第一次可以得到正确的响应，但是在那之后，新客户端将不会从服务器接收任何东西（cookies和缓存被清除）

我调试过，程序会fprintf（）正确的内容，问题是“客户端不会接收到它们”

下面是我的代码，有一个名为get_mime_type（）的函数，您可以忽略它并将mime设置为“text/html”或任何您想要的值

有什么提示吗

顺便说一句，我还想避免使用多进程来处理多个连接，有没有实现单进程、单线程http服务器的想法

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <signal.h>
#include <dirent.h>
#include <time.h>
#include <unistd.h>

#define BACKLOG 1024
#define RFC1123FMT "%a, %d %b %Y %H:%M:%S GMT"
#define DEBUG 1

/**
 * Get the mime type of a file
 *
 * Pre-Condition: 1. mime-types.tsv is in current directory, and it is correct
 *                2. file exists and all right
 */
char *get_mime_type(char *filename) {
  // Get extension
  char *ext;   // file extension
  if ((ext = strrchr(filename, '.')) == NULL) {
    fprintf(stderr, "Error: Cannot get the extension of \"%s\".\n", filename);
    exit(1);
  }
  ext += sizeof(char);  // get rid of the `.'

  // Read in mime-types.tsv and try to get the mime-type regarding to current file's extension
  // No detailed error-checking according to pre-condition
  FILE *mime_file;
  mime_file = fopen("mime-types.tsv", "r");

  int BUF_MAX = 1024;
  char *buffer = (char *)malloc(sizeof(char) * BUF_MAX);
  char *mime;
  fgets(buffer, BUF_MAX, mime_file);
  int linum = atoi(buffer);
  while (linum-- > 0) {
    fgets(buffer, BUF_MAX, mime_file);
    if ((strncasecmp(buffer, ext, strlen(ext))) == 0) {
      buffer[strlen(buffer) - 1] = '\0';
      mime = buffer;
      while (*mime != ' ') {
    mime += sizeof(char);
      }
      mime += sizeof(char);
      free(buffer);   // TODO: is this all right?
      fclose(mime_file);
      return mime;
    }
  }
  free(buffer);
  fclose(mime_file);
  return NULL;
}

void sigchld_handler(int s)
{
  while(waitpid(-1, NULL, WNOHANG) > 0);
}

/**
 * Get sockaddr, IPv4 or IPv6:
 */
void *get_in_addr(struct sockaddr *sig_action)
{
  if (sig_action->sa_family == AF_INET) {
    return &(((struct sockaddr_in*)sig_action)->sin_addr);
  }

  return &(((struct sockaddr_in6*)sig_action)->sin6_addr);
}


/**
 * Open a socket and listen to it, send information once got requests
 */
int run_server(char *filename, char *port) {
  // open file and get its information
  FILE *file;
  struct stat statbuf;
  if (stat(filename, &statbuf) < 0) {
    fprintf(stderr, "Error: Unable to open \"%s\".\n", filename);
    exit(1);
  }
  if (S_ISDIR(statbuf.st_mode)) {
    fprintf(stderr, "Error: %s is a directory, expected a file.\n", filename);
    exit(1);
  }
  if ((file = fopen(filename, "r")) == NULL) {
    fprintf(stderr, "Error: Unable to open \"%s\".\n", filename);
    exit(1);
  }
  char *mime = get_mime_type(filename);
  if (mime == NULL) {
    fprintf(stderr, "Error: the type of \"%s\" cannot be recognised.\n", filename);
    exit(1);
  }
  int file_len = S_ISREG(statbuf.st_mode) ? statbuf.st_size : -1;
  time_t mtime = statbuf.st_mtime; // last modified time, used in header

  // init sock
  int server_fd, client_fd;
  struct addrinfo hints, *server_info, *p_server_info;
  struct sockaddr_storage client_addr;
  socklen_t sock_in_size;
  struct sigaction sig_action;
  int yes = 1;
  char client_ip[INET6_ADDRSTRLEN];
  int return_value; // store return value of getaddrinfo

  memset(&hints, 0, sizeof(hints));
  hints.ai_family = AF_UNSPEC;
  hints.ai_socktype = SOCK_STREAM;
  hints.ai_flags = AI_PASSIVE;

  if ((return_value = getaddrinfo(NULL, port, &hints, &server_info)) != 0) {
    fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(return_value));
    return 1;
  }
  // TODO ? free hints? free p_server_info
  // bind
  for (p_server_info = server_info; p_server_info != NULL; p_server_info = p_server_info->ai_next) {
    if ((server_fd = socket(p_server_info->ai_family, p_server_info->ai_socktype,
                p_server_info->ai_protocol)) == -1) {
      perror("server: socket");
      continue;
    }

    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &yes,
           sizeof(int)) == -1) {
      perror("setsockopt");
      exit(1);
    }

    if (bind(server_fd, p_server_info->ai_addr, p_server_info->ai_addrlen) == -1) {
      close(server_fd);
      perror("server: bind");
      continue;
    }
    break;
  }

  if (p_server_info == NULL) { // not bind
    fprintf(stderr, "server: failed to bind\n");
    return 2;
  }

  freeaddrinfo(server_info);

  // listen
  if (listen(server_fd, BACKLOG) == -1) {
    perror("listen");
    exit(1);
  }

  // reap dead processes
  sig_action.sa_handler = sigchld_handler;
  sigemptyset(&sig_action.sa_mask);
  sig_action.sa_flags = SA_RESTART;
  if (sigaction(SIGCHLD, &sig_action, NULL) == -1) {
    perror("sigaction");
    exit(1);
  }

  printf("server: waiting for connections...\n");

  while (1) {
    sock_in_size = sizeof(client_addr);
    client_fd = accept(server_fd, (struct sockaddr *) &client_addr, &sock_in_size);
    if (client_fd == -1) {
      perror("accept");
      continue;
    }
    inet_ntop(client_addr.ss_family,
          get_in_addr((struct sockaddr *)&client_addr),
          client_ip, sizeof(client_ip));
    printf("server: got connection from %s\n", client_ip);

    if (!fork()) { // child process
      close(server_fd);
      FILE* response = fdopen(client_fd, "a+"); // response file
      // response header
      time_t now;
      char timebuf[128];
      now = time(NULL);
      strftime(timebuf, sizeof(timebuf), RFC1123FMT, gmtime(&now));

      fprintf(response, "HTTP/1.1 200 OK\r\n");
      fprintf(response, "Server: server\r\n");
      fprintf(response, "Date: %s\r\n", timebuf);

      strftime(timebuf, sizeof(timebuf), RFC1123FMT, gmtime(&mtime));
      fprintf(response, "Last-Modified: %s\r\n", timebuf);
      fprintf(response, "Content-Type: %s\r\n", mime);
      fprintf(response, "Content-Length: %d\r\n", file_len);
      fprintf(response, "Connection: close\r\n");
      fprintf(response, "\r\n");

      // response content
      char buf[1024];
      int n;
      while ((n = fread(buf, 1, sizeof(buf), file)) > 0) {
        fwrite(buf, 1, n, response);
      }
      fclose(response);
      fclose(file);
      close(client_fd);
      exit(0);
    }
  }
  fclose(file);
  close(server_fd);
  return 0;
}

int main(int argc, char *argv[])
{
  if (argc != 3) {
    fprintf(stderr, "Usage: $server filename port\n");
    exit(1);
  }
  char *filename = argv[1];
  char *port = argv[2];
  return run_server(filename, port);
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义待办事项1024
#定义RFC1123FMT“%a，%d%b%Y%H:%M:%S GMT”
#定义调试1
/**
*获取文件的mime类型
*
*先决条件：1。mime-types.tsv位于当前目录中，并且它是正确的
*                2. 文件存在并且正确
*/
char*get\u mime\u类型（char*filename）{
//接分机
char*ext；//文件扩展名
如果（（ext=strrchr（文件名，'.'）==NULL）{
fprintf（stderr，“错误：无法获取\%s\”\n“文件名”的扩展名）；
出口（1）；
}
ext+=sizeof（char）；//去掉“.”
//读入mime-types.tsv并尝试获取与当前文件扩展名相关的mime类型
//没有根据前提条件进行详细的错误检查
文件*mime_文件；
mime_file=fopen（“mime types.tsv”，“r”）；
int BUF_MAX=1024；
char*buffer=（char*）malloc（sizeof（char）*BUF_MAX）；
char*mime；
fgets（缓冲区、BUF_MAX、mime_文件）；
int linum=atoi（缓冲区）；
而（linum-->0）{
fgets（缓冲区、BUF_MAX、mime_文件）；
如果（（strncasecmp（缓冲区，外部，strlen（外部）））==0）{
缓冲区[strlen（buffer）-1]='\0'；
mime=缓冲区；
while（*mime！=''）{
mime+=sizeof（char）；
}
mime+=sizeof（char）；
空闲（缓冲区）；//托多：这样行吗？
fclose（mime_文件）；
返回mime；
}
}
自由（缓冲）；
fclose（mime_文件）；
返回NULL；
}
void sigchld_处理程序（int s）
{
而（waitpid（-1，NULL，WNOHANG）>0）；
}
/**
*获取sockaddr、IPv4或IPv6：
*/
void*get\u in\u addr（结构sockaddr*sig\u操作）
{
if（信号动作->信号系列==AF\U INET）{
返回（（*（struct sockaddr）sig_action）->sin_addr）；
}
返回（（6*中的结构sockaddr）sig\u action）->sin6\u addr）；
}
/**
*打开一个套接字并监听它，一旦收到请求就发送信息
*/
int run_服务器（字符*文件名，字符*端口）{
//打开文件并获取其信息
文件*文件；
结构stat statbuf；
if（stat（filename，&statbuf）<0）{
fprintf（stderr，“错误：无法打开\%s\”\n，“文件名”）；
出口（1）；
}
if（S_ISDIR（statbuf.st_模式））{
fprintf（stderr，“错误：%s是一个目录，应该是一个文件。\n”，文件名）；
出口（1）；
}
if（（file=fopen（filename，“r”））==NULL）{
fprintf（stderr，“错误：无法打开\%s\”\n，“文件名”）；
出口（1）；
}
char*mime=get\u mime\u type（文件名）；
if（mime==NULL）{
fprintf（stderr，“错误：无法识别\%s\”的类型。\n”，文件名）；
出口（1）；
}
int file_len=S_ISREG（statbuf.st_模式）？statbuf.st_大小：-1；
time\u t mtime=statbuf.st\u mtime；//上次修改的时间，在标头中使用
//初始袜子
int server_fd、client_fd；
结构addrinfo提示，*server\u info，*p\u server\u info；
结构sockaddr\u存储客户端\u addr；
袜子尺寸的袜子；
结构sig动作sig_动作；
int yes=1；
char client_ip[INET6_ADDRSTRLEN]；
int return_value；//存储getaddrinfo的返回值
memset（&hints，0，sizeof（hints））；
hits.ai_family=AF_unsec；
hits.ai_socktype=SOCK_流；
hits.ai_flags=ai_被动；
if（（return_value=getaddrinfo（NULL、端口、提示和服务器_信息））！=0）{
fprintf（标准，“getaddrinfo:%s\n”，gai_strerror（返回值））；
返回1；
}
//TODO？免费提示？免费p_服务器信息
//束缚
对于（p_server_info=server_info；p_server_info！=NULL；p_server_info=p_server_info->ai_next）{
如果（（服务器\u fd=socket），
p_服务器信息->ai_协议）==-1）{
perror（“服务器：套接字”）；
继续；
}
如果（setsockopt）（服务器\u fd、SOL\u套接字、SO\u REUSEADDR，&yes，
sizeof（int））==-1）{
perror（“setsockopt”）；
出口（1）；
}
如果（绑定（服务器\u fd，p\u服务器\u信息->ai\u地址，p\u服务器\u信息->ai\u地址）=-1）{
关闭（服务器\u fd）；
perror（“服务器：绑定”）；
继续；
}
打破
}
如果（p_server_info==NULL）{//不绑定
fprintf（stderr，“服务器：绑定失败\n”）；
返回2；
}
freeaddrinfo（服务器信息）；
//听
如果（侦听（服务器\u fd，待办事项）=-1）{
佩罗尔（“倾听”）；
出口（1）；
}
//收获死过程
sig_action.sa_handler=sigchld_handler；
sig清空设置（&sig_action.sa_mask）；
sig_action.sa_flags=sa_重启；
if（sigcold和sig_action，NULL）=-1）{
佩罗尔（“sigaction”）；
出口（1）；
}
printf（“服务器：正在等待连接…\n”）；
而(1){
sock\u in\u size=sizeof（客户地址）；
client\u fd=accept（server\u fd，（struct sockaddr*）和client\u addr，&sock\u in\u size）；
如果（客户端\u fd==-1）{
佩罗（“接受”）；
继续；
}
inet_ntop（客户地址和家庭），
获取地址（（struct sockaddr*）和客户端地址），
客户ip，sizeof（客户ip））；
printf（“服务器：从%s\n获得连接”，客户端\u ip）；
如果（！fork（））{
for (p_server_info = server_info; p_server_info != NULL; p_server_info = p_server_info->ai_next) {
    if ((server_fd = socket(p_server_info->ai_family, p_server_info->ai_socktype,
                p_server_info->ai_protocol)) == -1) {
      perror("server: socket");
      continue;
    }

// response content
      char buf[1024];
      int n;
      while ((n = fread(buf, 1, sizeof(buf), file)) > 0) {
        fwrite(buf, 1, n, response);
      }