实现一个使用 epoll 的极简 HTTP 服务器

November 9, 2025

实现一个使用 epoll 的极简 HTTP 服务器 (仅支持 GET/POST, 简单路由)。

Source: https://github.com/flouthoc/envelop.c
Author: flouthoc@gmail.com MIT LICENSE

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <fcntl.h>

/* 命名约定简述:
    MACROS 全大写; ENUMS 首字母大写其余小写; STRUCTS 全小写下划线; 变量全小写。
*/

// 服务器监听地址 0.0.0.0:SERVER_PORT (对所有本地接口开放)
#define SERVER_PORT 3000

/* 支持的 HTTP 版本标识 */
#define VERSION_11 "1.1"
#define VERSION_10 "1.0"
/* 事件数组最大容量 (epoll) */
#define MAXEVENTS 64


/* 全局临时缓冲区 (复用以减少栈分配) */
char global_buffer[1024];

/* 仅实现需要支持的请求方法 */
enum Method {
  GET,
  POST
};

/* 常用 HTTP 状态码 (只列出当前用到的) */
enum Http_status {
  HTTP_STATUS_OK = 200,
  HTTP_STATUS_CREATED = 201,
  HTTP_STATUS_ACCEPTED = 202,
  HTTP_STATUS_BAD_REQUEST = 400,
  HTTP_STATUS_NOT_FOUND = 404,
};

/* 解析后的请求行数据 (仅保留必要字段) */
struct http_request {
  char version[4];
  enum Method method;
  char * uri;
};

/* 构造用的响应头及可选正文 */
struct http_response {
  char * header;
  size_t length;
  int is_content; // 如果此响应中有消息体，则为1；如果没有，则为0，这只是为了在回复时额外添加换行
};

// 打印响应头 (调试用)，保留 \r\n 可视化
void print_rn(char * str) {
  while ( * str) {
    if ( * str == '\n') {
      fputs("\n", stdout);
    } else if ( * str == '\r') {
      fputs("\r", stdout);
    } else {
      fputc( * str, stdout);
    }
    str++;
  }
  fputs("\n", stdout);
}

// 扩展响应缓冲区并追加字符串 (header + 内容)
static inline void extend_header(struct http_response * handle,
  const char * extension, size_t length) {
  struct http_response * h = handle;
  h -> length += length;
  h -> header = realloc(h -> header, h -> length);
  strcat(h -> header, extension);
}

// 发送响应并 free 结构体
static void reply(struct http_response * handle, int connectionfd) {

  int written, n;
  char * buf;
  if (handle -> is_content == 0) extend_header(handle, "\r\n", 2);
  n = handle -> length;
  buf = handle -> header;

  print_rn(buf);

  while (n > 0) {
    if ((written = write(connectionfd, buf, (handle -> length + 1))) > 0) {
      buf += written;
      n -= written;
    } else {
      perror("When replying to file descriptor");
    }
  }

  free(handle -> header);
  free(handle);

}

/* TODO: 可扩展为最简模板解析器 (占位) */
static char * readTemplate(char * filename) {
  if (filename != NULL) {
    /* 预留: 读取文件并返回动态内容 */
  }
  return NULL;
}

// 构造状态行 (HTTP/X.X <code>) 并初始化响应结构
static inline void prepare_status_line(struct http_response ** response_handle, char * version, enum Http_status status) {
  struct http_response * r = malloc(sizeof(struct http_response));
  /* Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF */
  /* I wont use Reason-Phrase cause its not important for me now */
  r -> header = malloc(16 * sizeof(char)); // hard-coding length for HTTP/X.X(8) SP(1) STATUS-CODE(3) SP(1) CRLF(2)
  r -> length = sprintf(r -> header, "HTTP/%s %d \r\n", version, status);
  r -> is_content = 0;
  * response_handle = r;
}

// 添加单个 header 行
void setHeader(struct http_response * handle, char * header, char * value) {
  size_t len;
  char local_buffer[1024];
  strcpy(local_buffer, value);
  len = sprintf(global_buffer, "%s: %s\r\n", header, local_buffer);
  extend_header(handle, global_buffer, len);
}

// 设置正文相关头并发送带内容的响应
void replywithContent(struct http_response * response_handle, int connectionfd,
  const char * content) {
  size_t content_length = strlen(content);
  sprintf(global_buffer, "%d", (int) content_length);
  setHeader(response_handle, "Content-Length", global_buffer);
  setHeader(response_handle, "Content-Type", "text/html");
  extend_header(response_handle, "\r\n", 2);
  response_handle -> is_content = 1;
  extend_header(response_handle, content, content_length);
  reply(response_handle, connectionfd);
}

/* 路由: 根据 URI 返回不同内容 (简易示例) */
void router(struct http_request * request_handle, int connectionfd, struct http_response ** response_handle) {
  if (!strcmp(request_handle -> uri, "/hello")) {
    prepare_status_line(response_handle, request_handle -> version, HTTP_STATUS_OK);
    replywithContent( * response_handle, connectionfd, "Hello");
  } else if (!strcmp(request_handle -> uri, "/hey")) {
    prepare_status_line(response_handle, request_handle -> version, HTTP_STATUS_OK);
    replywithContent( * response_handle, connectionfd, "Hey hi this is a test");
  } else {
    prepare_status_line(response_handle, request_handle -> version, HTTP_STATUS_NOT_FOUND);
    replywithContent( * response_handle, connectionfd, "Not Found");
  }
}

// 解析请求行 (方法 URI 版本)，仅支持 GET/POST + HTTP/1.0/1.1
static int parse_http_request(struct http_request ** req, char * request_buffer) /* 仅解析运行所需部分 */ {
  int length;
  char * uri;
  char * token_handler;
  struct http_request * p = (struct http_request * )(malloc(sizeof(struct http_request)));
  token_handler = strtok(request_buffer, " ");

  if (!strcmp(token_handler, "GET")) p -> method = GET;
  else if (!strcmp(token_handler, "POST")) p -> method = POST;
  else return 0;

  token_handler = strtok(NULL, " ");
  length = strlen(token_handler);
  uri = malloc(sizeof(char) * (length + 1));
  strcpy(uri, token_handler);
  p -> uri = uri;

  token_handler = strtok(NULL, " ");
  if (!strncmp(token_handler, "HTTP/1.1\r\n", 10)) strcpy(p -> version, VERSION_11);
  else if (!strncmp(token_handler, "HTTP/1.0\r\n", 10)) strcpy(p -> version, VERSION_10);
  else return 0;

  * req = p;
  return 1;
}

// 根据解析结果分发响应 (目前只区分 GET)
void respond(struct http_request * request_handle, int connectionfd) {
  struct http_response * response_handle;
  if (request_handle -> method == GET) router(request_handle, connectionfd, & response_handle);
  else goto error;
  return;

  error:
    prepare_status_line( & response_handle, request_handle -> version, HTTP_STATUS_BAD_REQUEST);
  reply(response_handle, connectionfd);
}

int main() {
  int n, i;
  int listenfd;
  int listenfd_flags;
  int epoll_fd;
  char msg_buffer[1024];
  char temp_buffer[1024];
  int connectionfd;
  int client_length;

  /* 请求结构体指针 (解析成功后填充) */
  struct http_request * request_handle;

  /* sockaddr_in: 保存服务器与客户端地址信息 */
  struct sockaddr_in server_address, client_address;

  /* epoll_event: 事件数据; 仅在支持 epoll 的系统运行 (Linux) */
  struct epoll_event event;
  struct epoll_event * events;

  char greet[] = "Hello";

  /* 创建监听套接字 */
  listenfd = socket(AF_INET, SOCK_STREAM, 0);

  if (listenfd == -1) {
    perror("Socket");
    exit(1);
  }

  /* 清零地址结构 */
  memset(&server_address, 0, sizeof(server_address));

  /* 设置地址族/地址/端口 */
  server_address.sin_family = AF_INET;
  server_address.sin_addr.s_addr = inet_addr("0.0.0.0");
  /* 端口号定义见顶部宏 */
  server_address.sin_port = htons(SERVER_PORT);

  /* 绑定监听地址与端口 */
  if (bind(listenfd, (struct sockaddr * ) & server_address, sizeof(server_address)) == -1) {
    perror("Bind");
    exit(1);
  }

  if ((listenfd_flags = fcntl(listenfd, F_GETFL, 0)) == -1) {
    perror("While trying to get listenfd flags");
    exit(1);
  }

  /* 设置非阻塞 (事件驱动需要) */
  listenfd_flags |= O_NONBLOCK;

  if (fcntl(listenfd, F_SETFL, listenfd_flags) == -1) {
    perror("While trying to set flags");
    exit(1);
  }

  if (listen(listenfd, 10) == -1) {
    perror("Listen");
    exit(1);
  }

  if ((epoll_fd = epoll_create1(0)) == -1) {
    perror("epoll_create");
    exit(1);
  }

  event.data.fd = listenfd;
  event.events = EPOLLIN;
  if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listenfd, & event) == -1) {
    perror("Epoll context");
    exit(1);
  }

  events = calloc(MAXEVENTS, sizeof event);

  /* 主事件循环 (epoll_wait) */
  while (1) {

    /* 等待就绪事件 */
    n = epoll_wait(epoll_fd, events, MAXEVENTS, -1);
    for (i = 0; i < n; i++) {

      /* 若事件包含错误/挂断或非可读则关闭并跳过 */
      if ((events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP) || (!(events[i].events & EPOLLIN))) {
        /* 文件描述符尚未连接用于传输，可以在不关闭的情况下关闭 */
        close(events[i].data.fd);
        continue;
      } else if (listenfd == events[i].data.fd) {

        // 新连接到来: 循环接受所有就绪连接
        while (1) {

          /* 接受连接 */
          int connectionfd_flags;
          connectionfd = accept(listenfd, (struct sockaddr * ) & client_address, & client_length);
          if (connectionfd == -1) {

            if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
              /* 已处理所有传入连接 */
              break;
            } else {
              perror("accept");
              break;
            }
          }

          /* 设置客户端套接字非阻塞 */
          if ((connectionfd_flags = fcntl(connectionfd, F_GETFL, 0)) == -1) {
            perror("While trying to get listenfd flags");
            exit(1);
          }

          connectionfd_flags |= O_NONBLOCK;

          if (fcntl(connectionfd, F_SETFL, connectionfd_flags) == -1) {
            perror("While trying to set flags");
            exit(1);
          }

          // 将客户端套接字加入 epoll 监听
          event.data.fd = connectionfd;
          event.events = EPOLLIN;
          if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, connectionfd, & event) == -1) {
            perror("epoll_ctl");
            exit(1);
          }
        }
        continue;
      } else {
        // 已有连接: 读取并处理请求
        memset(msg_buffer, 0, sizeof(msg_buffer));
        memset(temp_buffer, 0, sizeof(temp_buffer));

        // 读取请求 (简单循环, 遇到 -1 退出)
        while ((n = read(events[i].data.fd, msg_buffer, 1024))) {

          if (n == -1) {
            //	printf("Might be EAGAIN\n");
            break;
          }

        }

        // 解析 HTTP 请求
        strcpy(temp_buffer, msg_buffer);
        if (!parse_http_request( & request_handle, temp_buffer)) {
          printf("Request Unparsablen\n");
          // 解析失败: 关闭连接
          if (shutdown(events[i].data.fd, SHUT_RDWR) == -1) {
            perror("shutdown");
          }

          continue;
        }

        // 构造并发送响应
        respond(request_handle, events[i].data.fd);
        // 关闭连接并释放资源
        if (shutdown(events[i].data.fd, SHUT_RDWR) == -1) {
          perror("shutdown");
        }

        free(request_handle -> uri);
        free(request_handle);
        //printf("%s\n", temp_buffer);
      }
    }
  }


  /*

  // This was some rough loop so i'm commenting it
  while(1){
      client_length = sizeof(client_address);
      memset(msg_buffer, 0, sizeof(msg_buffer));
      memset(temp_buffer, 0, sizeof(temp_buffer));
      connectionfd = accept(listenfd, (struct sockaddr*)&client_address, &client_length);
      while( n = recv(connectionfd, msg_buffer, 1024, MSG_DONTWAIT)){

          //printf("%sn", msg_buffer);
          //printf("%zdn", strlen(msg_buffer));
          if(strstr(msg_buffer, "rnrn"))
          break;


          //if( n < 0)
          //    if(errno == EWOULDBLOCK)
          //        break;
      }
      strcpy(temp_buffer, msg_buffer);
      if(!parse_http_request(&request_handle, temp_buffer)){
          printf("Request Unparsable");
          close(connectionfd);
          continue;
      }
      respond(request_handle, connectionfd);
      close(connectionfd);
      free(request_handle->uri);
      free(request_handle);
  }

  */

  exit(0);
}

←Back to home

This work is licensed under CC BY-NC-SA 4.0

#include <stdio.h> #include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <stdlib.h> #include <errno.h> #include <arpa/inet.h> #include <sys/epoll.h> #include <fcntl.h> /* 命名约定简述: MACROS 全大写; ENUMS 首字母大写其余小写; STRUCTS 全小写下划线; 变量全小写。 */ // 服务器监听地址 0.0.0.0:SERVER_PORT (对所有本地接口开放) #define SERVER_PORT 3000 /* 支持的 HTTP 版本标识 */ #define VERSION_11 "1.1" #define VERSION_10 "1.0" /* 事件数组最大容量 (epoll) */ #define MAXEVENTS 64 /* 全局临时缓冲区 (复用以减少栈分配) */ char global_buffer[1024]; /* 仅实现需要支持的请求方法 */ enum Method { GET, POST }; /* 常用 HTTP 状态码 (只列出当前用到的) */ enum Http_status { HTTP_STATUS_OK = 200, HTTP_STATUS_CREATED = 201, HTTP_STATUS_ACCEPTED = 202, HTTP_STATUS_BAD_REQUEST = 400, HTTP_STATUS_NOT_FOUND = 404, }; /* 解析后的请求行数据 (仅保留必要字段) */ struct http_request { char version[4]; enum Method method; char * uri; }; /* 构造用的响应头及可选正文 */ struct http_response { char * header; size_t length; int is_content; // 如果此响应中有消息体，则为1；如果没有，则为0，这只是为了在回复时额外添加换行 }; // 打印响应头 (调试用)，保留 \r\n 可视化 void print_rn(char * str) { while ( * str) { if ( * str == '\n') { fputs("\n", stdout); } else if ( * str == '\r') { fputs("\r", stdout); } else { fputc( * str, stdout); } str++; } fputs("\n", stdout); } // 扩展响应缓冲区并追加字符串 (header + 内容) static inline void extend_header(struct http_response * handle, const char * extension, size_t length) { struct http_response * h = handle; h -> length += length; h -> header = realloc(h -> header, h -> length); strcat(h -> header, extension); } // 发送响应并 free 结构体 static void reply(struct http_response * handle, int connectionfd) { int written, n; char * buf; if (handle -> is_content == 0) extend_header(handle, "\r\n", 2); n = handle -> length; buf = handle -> header; print_rn(buf); while (n > 0) { if ((written = write(connectionfd, buf, (handle -> length + 1))) > 0) { buf += written; n -= written; } else { perror("When replying to file descriptor"); } } free(handle -> header); free(handle); } /* TODO: 可扩展为最简模板解析器 (占位) */ static char * readTemplate(char * filename) { if (filename != NULL) { /* 预留: 读取文件并返回动态内容 */ } return NULL; } // 构造状态行 (HTTP/X.X <code>) 并初始化响应结构 static inline void prepare_status_line(struct http_response ** response_handle, char * version, enum Http_status status) { struct http_response * r = malloc(sizeof(struct http_response)); /* Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF */ /* I wont use Reason-Phrase cause its not important for me now */ r -> header = malloc(16 * sizeof(char)); // hard-coding length for HTTP/X.X(8) SP(1) STATUS-CODE(3) SP(1) CRLF(2) r -> length = sprintf(r -> header, "HTTP/%s %d \r\n", version, status); r -> is_content = 0; * response_handle = r; } // 添加单个 header 行 void setHeader(struct http_response * handle, char * header, char * value) { size_t len; char local_buffer[1024]; strcpy(local_buffer, value); len = sprintf(global_buffer, "%s: %s\r\n", header, local_buffer); extend_header(handle, global_buffer, len); } // 设置正文相关头并发送带内容的响应 void replywithContent(struct http_response * response_handle, int connectionfd, const char * content) { size_t content_length = strlen(content); sprintf(global_buffer, "%d", (int) content_length); setHeader(response_handle, "Content-Length", global_buffer); setHeader(response_handle, "Content-Type", "text/html"); extend_header(response_handle, "\r\n", 2); response_handle -> is_content = 1; extend_header(response_handle, content, content_length); reply(response_handle, connectionfd); } /* 路由: 根据 URI 返回不同内容 (简易示例) */ void router(struct http_request * request_handle, int connectionfd, struct http_response ** response_handle) { if (!strcmp(request_handle -> uri, "/hello")) { prepare_status_line(response_handle, request_handle -> version, HTTP_STATUS_OK); replywithContent( * response_handle, connectionfd, "Hello"); } else if (!strcmp(request_handle -> uri, "/hey")) { prepare_status_line(response_handle, request_handle -> version, HTTP_STATUS_OK); replywithContent( * response_handle, connectionfd, "Hey hi this is a test"); } else { prepare_status_line(response_handle, request_handle -> version, HTTP_STATUS_NOT_FOUND); replywithContent( * response_handle, connectionfd, "Not Found"); } } // 解析请求行 (方法 URI 版本)，仅支持 GET/POST + HTTP/1.0/1.1 static int parse_http_request(struct http_request ** req, char * request_buffer) /* 仅解析运行所需部分 */ { int length; char * uri; char * token_handler; struct http_request * p = (struct http_request * )(malloc(sizeof(struct http_request))); token_handler = strtok(request_buffer, " "); if (!strcmp(token_handler, "GET")) p -> method = GET; else if (!strcmp(token_handler, "POST")) p -> method = POST; else return 0; token_handler = strtok(NULL, " "); length = strlen(token_handler); uri = malloc(sizeof(char) * (length + 1)); strcpy(uri, token_handler); p -> uri = uri; token_handler = strtok(NULL, " "); if (!strncmp(token_handler, "HTTP/1.1\r\n", 10)) strcpy(p -> version, VERSION_11); else if (!strncmp(token_handler, "HTTP/1.0\r\n", 10)) strcpy(p -> version, VERSION_10); else return 0; * req = p; return 1; } // 根据解析结果分发响应 (目前只区分 GET) void respond(struct http_request * request_handle, int connectionfd) { struct http_response * response_handle; if (request_handle -> method == GET) router(request_handle, connectionfd, & response_handle); else goto error; return; error: prepare_status_line( & response_handle, request_handle -> version, HTTP_STATUS_BAD_REQUEST); reply(response_handle, connectionfd); } int main() { int n, i; int listenfd; int listenfd_flags; int epoll_fd; char msg_buffer[1024]; char temp_buffer[1024]; int connectionfd; int client_length; /* 请求结构体指针 (解析成功后填充) */ struct http_request * request_handle; /* sockaddr_in: 保存服务器与客户端地址信息 */ struct sockaddr_in server_address, client_address; /* epoll_event: 事件数据; 仅在支持 epoll 的系统运行 (Linux) */ struct epoll_event event; struct epoll_event * events; char greet[] = "Hello"; /* 创建监听套接字 */ listenfd = socket(AF_INET, SOCK_STREAM, 0); if (listenfd == -1) { perror("Socket"); exit(1); } /* 清零地址结构 */ memset(&server_address, 0, sizeof(server_address)); /* 设置地址族/地址/端口 */ server_address.sin_family = AF_INET; server_address.sin_addr.s_addr = inet_addr("0.0.0.0"); /* 端口号定义见顶部宏 */ server_address.sin_port = htons(SERVER_PORT); /* 绑定监听地址与端口 */ if (bind(listenfd, (struct sockaddr * ) & server_address, sizeof(server_address)) == -1) { perror("Bind"); exit(1); } if ((listenfd_flags = fcntl(listenfd, F_GETFL, 0)) == -1) { perror("While trying to get listenfd flags"); exit(1); } /* 设置非阻塞 (事件驱动需要) */ listenfd_flags |= O_NONBLOCK; if (fcntl(listenfd, F_SETFL, listenfd_flags) == -1) { perror("While trying to set flags"); exit(1); } if (listen(listenfd, 10) == -1) { perror("Listen"); exit(1); } if ((epoll_fd = epoll_create1(0)) == -1) { perror("epoll_create"); exit(1); } event.data.fd = listenfd; event.events = EPOLLIN; if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listenfd, & event) == -1) { perror("Epoll context"); exit(1); } events = calloc(MAXEVENTS, sizeof event); /* 主事件循环 (epoll_wait) */ while (1) { /* 等待就绪事件 */ n = epoll_wait(epoll_fd, events, MAXEVENTS, -1); for (i = 0; i < n; i++) { /* 若事件包含错误/挂断或非可读则关闭并跳过 */ if ((events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP) || (!(events[i].events & EPOLLIN))) { /* 文件描述符尚未连接用于传输，可以在不关闭的情况下关闭 */ close(events[i].data.fd); continue; } else if (listenfd == events[i].data.fd) { // 新连接到来: 循环接受所有就绪连接 while (1) { /* 接受连接 */ int connectionfd_flags; connectionfd = accept(listenfd, (struct sockaddr * ) & client_address, & client_length); if (connectionfd == -1) { if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) { /* 已处理所有传入连接 */ break; } else { perror("accept"); break; } } /* 设置客户端套接字非阻塞 */ if ((connectionfd_flags = fcntl(connectionfd, F_GETFL, 0)) == -1) { perror("While trying to get listenfd flags"); exit(1); } connectionfd_flags |= O_NONBLOCK; if (fcntl(connectionfd, F_SETFL, connectionfd_flags) == -1) { perror("While trying to set flags"); exit(1); } // 将客户端套接字加入 epoll 监听 event.data.fd = connectionfd; event.events = EPOLLIN; if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, connectionfd, & event) == -1) { perror("epoll_ctl"); exit(1); } } continue; } else { // 已有连接: 读取并处理请求 memset(msg_buffer, 0, sizeof(msg_buffer)); memset(temp_buffer, 0, sizeof(temp_buffer)); // 读取请求 (简单循环, 遇到 -1 退出) while ((n = read(events[i].data.fd, msg_buffer, 1024))) { if (n == -1) { // printf("Might be EAGAIN\n"); break; } } // 解析 HTTP 请求 strcpy(temp_buffer, msg_buffer); if (!parse_http_request( & request_handle, temp_buffer)) { printf("Request Unparsablen\n"); // 解析失败: 关闭连接 if (shutdown(events[i].data.fd, SHUT_RDWR) == -1) { perror("shutdown"); } continue; } // 构造并发送响应 respond(request_handle, events[i].data.fd); // 关闭连接并释放资源 if (shutdown(events[i].data.fd, SHUT_RDWR) == -1) { perror("shutdown"); } free(request_handle -> uri); free(request_handle); //printf("%s\n", temp_buffer); } } } /* // This was some rough loop so i'm commenting it while(1){ client_length = sizeof(client_address); memset(msg_buffer, 0, sizeof(msg_buffer)); memset(temp_buffer, 0, sizeof(temp_buffer)); connectionfd = accept(listenfd, (struct sockaddr*)&client_address, &client_length); while( n = recv(connectionfd, msg_buffer, 1024, MSG_DONTWAIT)){ //printf("%sn", msg_buffer); //printf("%zdn", strlen(msg_buffer)); if(strstr(msg_buffer, "rnrn")) break; //if( n < 0) // if(errno == EWOULDBLOCK) // break; } strcpy(temp_buffer, msg_buffer); if(!parse_http_request(&request_handle, temp_buffer)){ printf("Request Unparsable"); close(connectionfd); continue; } respond(request_handle, connectionfd); close(connectionfd); free(request_handle->uri); free(request_handle); } */ exit(0); }