lib/http/http1.c - net/facil.io - Rivoreo Source Code Repositories

 /*
 copyright: Boaz segev, 2016-2017
 license: MIT

 Feel free to copy, use and enjoy according to the license provided.
 */
 #include "spnlock.inc"

 #include "http.h"
 #include "http1.h"
 #include "http1_request.h"
 #include "http1_simple_parser.h"

 #include <fcntl.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/stat.h>

 char *HTTP1_Protocol_String = "facil_http/1.1_protocol";
 /* *****************************************************************************
 HTTP/1.1 data structures
 */

 typedef struct http1_protocol_s {
   protocol_s protocol;
   http_settings_s *settings;
   void (*on_request)(http_request_s *request);
   struct http1_protocol_s *next;
   http1_request_s request;
   ssize_t len; /* used as a persistent socket `read` indication. */
 } http1_protocol_s;

 static void http1_on_data(intptr_t uuid, http1_protocol_s *protocol);

 /* *****************************************************************************
 HTTP/1.1 pool
 */

 static struct {
   spn_lock_i lock;
   uint8_t init;
   http1_protocol_s *next;
   http1_protocol_s protocol_mem[HTTP1_POOL_SIZE];
 } http1_pool = {.lock = SPN_LOCK_INIT, .init = 0};

 static void http1_free(intptr_t uuid, http1_protocol_s *pr) {
   if ((uintptr_t)pr < (uintptr_t)http1_pool.protocol_mem ||
       (uintptr_t)pr >= (uintptr_t)(http1_pool.protocol_mem + HTTP1_POOL_SIZE))
     goto use_free;
   spn_lock(&http1_pool.lock);
   pr->next = http1_pool.next;
   http1_pool.next = pr;
   spn_unlock(&http1_pool.lock);
   return;
 use_free:
   free(pr);
   return;
   (void)uuid;
 }

 static inline void http1_set_protocol_data(http1_protocol_s *pr) {
   pr->protocol = (protocol_s){
       .on_data = (void (*)(intptr_t, protocol_s *))http1_on_data,
       .on_close = (void (*)(intptr_t uuid, protocol_s *))http1_free};
   pr->request.request = (http_request_s){.fd = 0, .http_version = HTTP_V1};
   pr->request.header_pos = pr->request.buffer_pos = pr->len = 0;
 }

 static http1_protocol_s *http1_alloc(void) {
   http1_protocol_s *pr;
   spn_lock(&http1_pool.lock);
   if (!http1_pool.next)
     goto use_malloc;
   pr = http1_pool.next;
   http1_pool.next = pr->next;
   spn_unlock(&http1_pool.lock);
   http1_request_clear(&pr->request.request);
   pr->request.request.settings = pr->settings;
   pr->len = 0;
   return pr;
 use_malloc:
   if (http1_pool.init == 0)
     goto initialize;
   spn_unlock(&http1_pool.lock);
   // fprintf(stderr, "using malloc\n");
   pr = malloc(sizeof(*pr));
   http1_set_protocol_data(pr);
   return pr;
 initialize:
   http1_pool.init = 1;
   for (size_t i = 1; i < (HTTP1_POOL_SIZE - 1); i++) {
     http1_set_protocol_data(http1_pool.protocol_mem + i);
     http1_pool.protocol_mem[i].next = http1_pool.protocol_mem + (i + 1);
   }
   http1_pool.protocol_mem[HTTP1_POOL_SIZE - 1].next = NULL;
   http1_pool.next = http1_pool.protocol_mem + 1;
   spn_unlock(&http1_pool.lock);
   http1_set_protocol_data(http1_pool.protocol_mem);
   return http1_pool.protocol_mem;
 }

 /* *****************************************************************************
 HTTP callbacks
 */
 #define HTTP_BODY_CHUNK_SIZE 3072 // 4096

 static void http1_on_header_found(http_request_s *request,
                                   http_header_s *header) {
   ((http1_request_s *)request)
       ->headers[((http1_request_s *)request)->header_pos] = *header;
   ((http1_request_s *)request)->header_pos += 1;
 }

 static void http1_on_data(intptr_t uuid, http1_protocol_s *pr);
 static void http1_on_data_def(intptr_t uuid, protocol_s *pr, void *ignr) {
   sock_touch(uuid);
   http1_on_data(uuid, (http1_protocol_s *)pr);
   (void)ignr;
 }
 /* parse and call callback */
 static void http1_on_data(intptr_t uuid, http1_protocol_s *pr) {
   ssize_t result;
   char buff[HTTP_BODY_CHUNK_SIZE];
   http1_request_s *request = &pr->request;
   char *buffer = request->buffer;
   for (;;) {
     // handle requests with no file data
     if (request->request.body_file <= 0) {
       // request headers parsing
       if (pr->len == 0) {
         buffer = request->buffer;
         // make sure headers don't overflow
         pr->len = sock_read(uuid, buffer + request->buffer_pos,
                             HTTP1_MAX_HEADER_SIZE - request->buffer_pos);
         // update buffer read position.
         request->buffer_pos += pr->len;
         // if (len > 0) {
         //   fprintf(stderr, "\n----\nRead from socket, %lu bytes, total
         //   %lu:\n",
         //           len, request->buffer_pos);
         //   for (size_t i = 0; i < request->buffer_pos; i++) {
         //     fprintf(stderr, "%c", buffer[i] ? buffer[i] : '-');
         //   }
         //   fprintf(stderr, "\n");
         // }
       }
       if (pr->len <= 0)
         goto finished_reading;

       // parse headers
       result =
           http1_parse_request_headers(buffer, request->buffer_pos,
                                       &request->request, http1_on_header_found);
       // review result
       if (result >= 0) { // headers comeplete
         // are we done?
         if (request->request.content_length == 0 || request->request.body_str) {
           goto handle_request;
         }
         if (request->request.content_length > pr->settings->max_body_size) {
           goto body_to_big;
         }
         // initialize or submit body data
         result = http1_parse_request_body(buffer + result, pr->len - result,
                                           (http_request_s *)request);
         if (result >= 0) {
           request->buffer_pos += result;
           goto handle_request;
         } else if (result == -1) // parser error
           goto parser_error;
         goto parse_body;
       } else if (result == -1) // parser error
         goto parser_error;
       // assume incomplete (result == -2), even if wrong, we're right.
       pr->len = 0;
       continue;
     }
     if (request->request.body_file > 0) {
     // fprintf(stderr, "Body File\n");
     parse_body:
       buffer = buff;
       // request body parsing
       pr->len = sock_read(uuid, buffer, HTTP_BODY_CHUNK_SIZE);
       if (pr->len <= 0)
         goto finished_reading;
       result = http1_parse_request_body(buffer, pr->len, &request->request);
       if (result >= 0) {
         goto handle_request;
       } else if (result == -1) // parser error
         goto parser_error;
       if (pr->len < HTTP_BODY_CHUNK_SIZE) // pause parser for more data
         goto finished_reading;
       goto parse_body;
     }
     continue;
   handle_request:
     // review required headers / data
     if (request->request.host == NULL)
       goto bad_request;
     http_settings_s *settings = pr->settings;
     request->request.settings = settings;
     // call request callback
     if (pr && settings &&
         (request->request.upgrade || settings->public_folder == NULL ||
          http_response_sendfile2(
              NULL, &request->request, settings->public_folder,
              settings->public_folder_length, request->request.path,
              request->request.path_len, settings->log_static))) {
       pr->on_request(&request->request);
       // fprintf(stderr, "Called on_request\n");
     }
     // rotate buffer for HTTP pipelining
     if ((ssize_t)request->buffer_pos <= result) {
       pr->len = 0;
       // fprintf(stderr, "\n----\nAll data consumed.\n");
     } else {
       memmove(request->buffer, buffer + result, request->buffer_pos - result);
       pr->len = request->buffer_pos - result;
       // fprintf(stderr, "\n----\ndata after move, %lu long:\n%.*s\n", len,
       //         (int)len, request->buffer);
     }
     // fprintf(stderr, "data in buffer, %lu long:\n%.*s\n", len, (int)len,
     //         request->buffer);
     // clear request state
     http1_request_clear(&request->request);
     request->buffer_pos = pr->len;
     // make sure to use the correct buffer.
     buffer = request->buffer;
     if (pr->len) {
       /* prevent this connection from hogging the thread by pipelining endless
        * requests.
        */
       facil_defer(.task = http1_on_data_def, .task_type = FIO_PR_LOCK_TASK,
                   .uuid = uuid);
       return;
     }
   }
   // no routes lead here.
   fprintf(stderr,
           "I am lost on a deserted island, no code can reach me here :-)\n");
   goto finished_reading; // How did we get here?
 parser_error:
   if (request->request.headers_count >= HTTP1_MAX_HEADER_COUNT)
     goto too_big;
 bad_request:
   /* handle generally bad requests */
   {
     http_response_s *response = http_response_create(&request->request);
     response->status = 400;
     if (pr->settings->public_folder &&
         !http_response_sendfile2(response, &request->request,
                                  pr->settings->public_folder,
                                  pr->settings->public_folder_length, "400.html",
                                  8, pr->settings->log_static))
       http_response_write_body(response, "Bad Request", 11);
     http_response_finish(response);
     sock_close(uuid);
     request->buffer_pos = 0;
     goto finished_reading;
   }
 too_big:
   /* handle oversized headers */
   {
     http_response_s *response = http_response_create(&request->request);
     response->status = 431;
     if (pr->settings->public_folder &&
         !http_response_sendfile2(response, &request->request,
                                  pr->settings->public_folder,
                                  pr->settings->public_folder_length, "431.html",
                                  8, pr->settings->log_static))
       http_response_write_body(response, "Request Header Fields Too Large", 31);
     http_response_finish(response);
     sock_close(uuid);
     request->buffer_pos = 0;
     goto finished_reading;
   body_to_big:
     /* handle oversized body */
     {
       http_response_s *response = http_response_create(&request->request);
       response->status = 413;
       if (pr->settings->public_folder &&
           !http_response_sendfile2(response, &request->request,
                                    pr->settings->public_folder,
                                    pr->settings->public_folder_length,
                                    "413.html", 8, pr->settings->log_static))
         http_response_write_body(response, "Payload Too Large", 17);
       http_response_finish(response);
       sock_close(uuid);
       request->buffer_pos = 0;
       goto finished_reading;
     }
   }
 finished_reading:
   pr->len = 0;
 }

 /* *****************************************************************************
 HTTP listening helpers
 */

 /**
 Allocates memory for an upgradable HTTP/1.1 protocol.

 The protocol self destructs when the `on_close` callback is called.
 */
 protocol_s *http1_on_open(intptr_t fd, http_settings_s *settings) {
   if (sock_uuid2fd(fd) >= (sock_max_capacity() - HTTP_BUSY_UNLESS_HAS_FDS))
     goto is_busy;
   http1_protocol_s *pr = http1_alloc();
   pr->request.request.fd = fd;
   pr->settings = settings;
   pr->on_request = settings->on_request;
   facil_set_timeout(fd, pr->settings->timeout);
   return (protocol_s *)pr;

 is_busy:
   if (settings->public_folder && settings->public_folder_length) {
     size_t p_len = settings->public_folder_length;
     struct stat file_data = {.st_mode = 0};
     char fname[p_len + 8 + 1];
     memcpy(fname, settings->public_folder, p_len);
     if (settings->public_folder[p_len - 1] == '/' ||
         settings->public_folder[p_len - 1] == '\\')
       p_len--;
     memcpy(fname + p_len, "/503.html", 9);
     p_len += 9;
     if (stat(fname, &file_data))
       goto busy_no_file;
     // check that we have a file and not something else
     if (!S_ISREG(file_data.st_mode) && !S_ISLNK(file_data.st_mode))
       goto busy_no_file;
     int file = open(fname, O_RDONLY);
     if (file == -1)
       goto busy_no_file;
     sock_buffer_s *buffer;
     buffer = sock_buffer_checkout();
     memcpy(buffer->buf,
            "HTTP/1.1 503 Service Unavailable\r\n"
            "Content-Type: text/html\r\n"
            "Connection: close\r\n"
            "Content-Length: ",
            94);
     p_len = 94 + http_ul2a((char *)buffer->buf + 94, file_data.st_size);
     memcpy(buffer->buf + p_len, "\r\n\r\n", 4);
     p_len += 4;
     if ((off_t)(BUFFER_PACKET_SIZE - p_len) > file_data.st_size) {
       if (read(file, buffer->buf + p_len, file_data.st_size) < 0) {
         close(file);
         sock_buffer_free(buffer);
         goto busy_no_file;
       }
       close(file);
       buffer->len = p_len + file_data.st_size;
       sock_buffer_send(fd, buffer);
     } else {
       buffer->len = p_len;
       sock_buffer_send(fd, buffer);
       sock_sendfile(fd, file, 0, file_data.st_size);
       sock_close(fd);
     }
     return NULL;
   }

 busy_no_file:
   sock_write(fd,
              "HTTP/1.1 503 Service Unavailable\r\nContent-Length: "
              "13\r\n\r\nServer Busy.",
              68);
   sock_close(fd);
   return NULL;
 }
	/*
	copyright: Boaz segev, 2016-2017
	license: MIT

	Feel free to copy, use and enjoy according to the license provided.
	*/
	#include "spnlock.inc"

	#include "http.h"
	#include "http1.h"
	#include "http1_request.h"
	#include "http1_simple_parser.h"

	#include <fcntl.h>
	#include <stdio.h>
	#include <string.h>
	#include <sys/stat.h>

	char *HTTP1_Protocol_String = "facil_http/1.1_protocol";
	/* *****************************************************************************
	HTTP/1.1 data structures
	*/

	typedef struct http1_protocol_s {
	protocol_s protocol;
	http_settings_s *settings;
	void (on_request)(http_request_s request);
	struct http1_protocol_s *next;
	http1_request_s request;
	ssize_t len; /* used as a persistent socket `read` indication. */
	} http1_protocol_s;

	static void http1_on_data(intptr_t uuid, http1_protocol_s *protocol);

	/* *****************************************************************************
	HTTP/1.1 pool
	*/

	static struct {
	spn_lock_i lock;
	uint8_t init;
	http1_protocol_s *next;
	http1_protocol_s protocol_mem[HTTP1_POOL_SIZE];
	} http1_pool = {.lock = SPN_LOCK_INIT, .init = 0};

	static void http1_free(intptr_t uuid, http1_protocol_s *pr) {
	if ((uintptr_t)pr < (uintptr_t)http1_pool.protocol_mem \|\|
	(uintptr_t)pr >= (uintptr_t)(http1_pool.protocol_mem + HTTP1_POOL_SIZE))
	goto use_free;
	spn_lock(&http1_pool.lock);
	pr->next = http1_pool.next;
	http1_pool.next = pr;
	spn_unlock(&http1_pool.lock);
	return;
	use_free:
	free(pr);
	return;
	(void)uuid;
	}

	static inline void http1_set_protocol_data(http1_protocol_s *pr) {
	pr->protocol = (protocol_s){
	.on_data = (void ()(intptr_t, protocol_s ))http1_on_data,
	.on_close = (void ()(intptr_t uuid, protocol_s ))http1_free};
	pr->request.request = (http_request_s){.fd = 0, .http_version = HTTP_V1};
	pr->request.header_pos = pr->request.buffer_pos = pr->len = 0;
	}

	static http1_protocol_s *http1_alloc(void) {
	http1_protocol_s *pr;
	spn_lock(&http1_pool.lock);
	if (!http1_pool.next)
	goto use_malloc;
	pr = http1_pool.next;
	http1_pool.next = pr->next;
	spn_unlock(&http1_pool.lock);
	http1_request_clear(&pr->request.request);
	pr->request.request.settings = pr->settings;
	pr->len = 0;
	return pr;
	use_malloc:
	if (http1_pool.init == 0)
	goto initialize;
	spn_unlock(&http1_pool.lock);
	// fprintf(stderr, "using malloc\n");
	pr = malloc(sizeof(*pr));
	http1_set_protocol_data(pr);
	return pr;
	initialize:
	http1_pool.init = 1;
	for (size_t i = 1; i < (HTTP1_POOL_SIZE - 1); i++) {
	http1_set_protocol_data(http1_pool.protocol_mem + i);
	http1_pool.protocol_mem[i].next = http1_pool.protocol_mem + (i + 1);
	}
	http1_pool.protocol_mem[HTTP1_POOL_SIZE - 1].next = NULL;
	http1_pool.next = http1_pool.protocol_mem + 1;
	spn_unlock(&http1_pool.lock);
	http1_set_protocol_data(http1_pool.protocol_mem);
	return http1_pool.protocol_mem;
	}

	/* *****************************************************************************
	HTTP callbacks
	*/
	#define HTTP_BODY_CHUNK_SIZE 3072 // 4096

	static void http1_on_header_found(http_request_s *request,
	http_header_s *header) {
	((http1_request_s *)request)
	->headers[((http1_request_s )request)->header_pos] = header;
	((http1_request_s *)request)->header_pos += 1;
	}

	static void http1_on_data(intptr_t uuid, http1_protocol_s *pr);
	static void http1_on_data_def(intptr_t uuid, protocol_s pr, void ignr) {
	sock_touch(uuid);
	http1_on_data(uuid, (http1_protocol_s *)pr);
	(void)ignr;
	}
	/* parse and call callback */
	static void http1_on_data(intptr_t uuid, http1_protocol_s *pr) {
	ssize_t result;
	char buff[HTTP_BODY_CHUNK_SIZE];
	http1_request_s *request = &pr->request;
	char *buffer = request->buffer;
	for (;;) {
	// handle requests with no file data
	if (request->request.body_file <= 0) {
	// request headers parsing
	if (pr->len == 0) {
	buffer = request->buffer;
	// make sure headers don't overflow
	pr->len = sock_read(uuid, buffer + request->buffer_pos,
	HTTP1_MAX_HEADER_SIZE - request->buffer_pos);
	// update buffer read position.
	request->buffer_pos += pr->len;
	// if (len > 0) {
	// fprintf(stderr, "\n----\nRead from socket, %lu bytes, total
	// %lu:\n",
	// len, request->buffer_pos);
	// for (size_t i = 0; i < request->buffer_pos; i++) {
	// fprintf(stderr, "%c", buffer[i] ? buffer[i] : '-');
	// }
	// fprintf(stderr, "\n");
	// }
	}
	if (pr->len <= 0)
	goto finished_reading;

	// parse headers
	result =
	http1_parse_request_headers(buffer, request->buffer_pos,
	&request->request, http1_on_header_found);
	// review result
	if (result >= 0) { // headers comeplete
	// are we done?
	if (request->request.content_length == 0 \|\| request->request.body_str) {
	goto handle_request;
	}
	if (request->request.content_length > pr->settings->max_body_size) {
	goto body_to_big;
	}
	// initialize or submit body data
	result = http1_parse_request_body(buffer + result, pr->len - result,
	(http_request_s *)request);
	if (result >= 0) {
	request->buffer_pos += result;
	goto handle_request;
	} else if (result == -1) // parser error
	goto parser_error;
	goto parse_body;
	} else if (result == -1) // parser error
	goto parser_error;
	// assume incomplete (result == -2), even if wrong, we're right.
	pr->len = 0;
	continue;
	}
	if (request->request.body_file > 0) {
	// fprintf(stderr, "Body File\n");
	parse_body:
	buffer = buff;
	// request body parsing
	pr->len = sock_read(uuid, buffer, HTTP_BODY_CHUNK_SIZE);
	if (pr->len <= 0)
	goto finished_reading;
	result = http1_parse_request_body(buffer, pr->len, &request->request);
	if (result >= 0) {
	goto handle_request;
	} else if (result == -1) // parser error
	goto parser_error;
	if (pr->len < HTTP_BODY_CHUNK_SIZE) // pause parser for more data
	goto finished_reading;
	goto parse_body;
	}
	continue;
	handle_request:
	// review required headers / data
	if (request->request.host == NULL)
	goto bad_request;
	http_settings_s *settings = pr->settings;
	request->request.settings = settings;
	// call request callback
	if (pr && settings &&
	(request->request.upgrade \|\| settings->public_folder == NULL \|\|
	http_response_sendfile2(
	NULL, &request->request, settings->public_folder,
	settings->public_folder_length, request->request.path,
	request->request.path_len, settings->log_static))) {
	pr->on_request(&request->request);
	// fprintf(stderr, "Called on_request\n");
	}
	// rotate buffer for HTTP pipelining
	if ((ssize_t)request->buffer_pos <= result) {
	pr->len = 0;
	// fprintf(stderr, "\n----\nAll data consumed.\n");
	} else {
	memmove(request->buffer, buffer + result, request->buffer_pos - result);
	pr->len = request->buffer_pos - result;
	// fprintf(stderr, "\n----\ndata after move, %lu long:\n%.*s\n", len,
	// (int)len, request->buffer);
	}
	// fprintf(stderr, "data in buffer, %lu long:\n%.*s\n", len, (int)len,
	// request->buffer);
	// clear request state
	http1_request_clear(&request->request);
	request->buffer_pos = pr->len;
	// make sure to use the correct buffer.
	buffer = request->buffer;
	if (pr->len) {
	/* prevent this connection from hogging the thread by pipelining endless
	* requests.
	*/
	facil_defer(.task = http1_on_data_def, .task_type = FIO_PR_LOCK_TASK,
	.uuid = uuid);
	return;
	}
	}
	// no routes lead here.
	fprintf(stderr,
	"I am lost on a deserted island, no code can reach me here :-)\n");
	goto finished_reading; // How did we get here?
	parser_error:
	if (request->request.headers_count >= HTTP1_MAX_HEADER_COUNT)
	goto too_big;
	bad_request:
	/* handle generally bad requests */
	{
	http_response_s *response = http_response_create(&request->request);
	response->status = 400;
	if (pr->settings->public_folder &&
	!http_response_sendfile2(response, &request->request,
	pr->settings->public_folder,
	pr->settings->public_folder_length, "400.html",
	8, pr->settings->log_static))
	http_response_write_body(response, "Bad Request", 11);
	http_response_finish(response);
	sock_close(uuid);
	request->buffer_pos = 0;
	goto finished_reading;
	}
	too_big:
	/* handle oversized headers */
	{
	http_response_s *response = http_response_create(&request->request);
	response->status = 431;
	if (pr->settings->public_folder &&
	!http_response_sendfile2(response, &request->request,
	pr->settings->public_folder,
	pr->settings->public_folder_length, "431.html",
	8, pr->settings->log_static))
	http_response_write_body(response, "Request Header Fields Too Large", 31);
	http_response_finish(response);
	sock_close(uuid);
	request->buffer_pos = 0;
	goto finished_reading;
	body_to_big:
	/* handle oversized body */
	{
	http_response_s *response = http_response_create(&request->request);
	response->status = 413;
	if (pr->settings->public_folder &&
	!http_response_sendfile2(response, &request->request,
	pr->settings->public_folder,
	pr->settings->public_folder_length,
	"413.html", 8, pr->settings->log_static))
	http_response_write_body(response, "Payload Too Large", 17);
	http_response_finish(response);
	sock_close(uuid);
	request->buffer_pos = 0;
	goto finished_reading;
	}
	}
	finished_reading:
	pr->len = 0;
	}

	/* *****************************************************************************
	HTTP listening helpers
	*/

	/**
	Allocates memory for an upgradable HTTP/1.1 protocol.

	The protocol self destructs when the `on_close` callback is called.
	*/
	protocol_s http1_on_open(intptr_t fd, http_settings_s settings) {
	if (sock_uuid2fd(fd) >= (sock_max_capacity() - HTTP_BUSY_UNLESS_HAS_FDS))
	goto is_busy;
	http1_protocol_s *pr = http1_alloc();
	pr->request.request.fd = fd;
	pr->settings = settings;
	pr->on_request = settings->on_request;
	facil_set_timeout(fd, pr->settings->timeout);
	return (protocol_s *)pr;

	is_busy:
	if (settings->public_folder && settings->public_folder_length) {
	size_t p_len = settings->public_folder_length;
	struct stat file_data = {.st_mode = 0};
	char fname[p_len + 8 + 1];
	memcpy(fname, settings->public_folder, p_len);
	if (settings->public_folder[p_len - 1] == '/' \|\|
	settings->public_folder[p_len - 1] == '\\')
	p_len--;
	memcpy(fname + p_len, "/503.html", 9);
	p_len += 9;
	if (stat(fname, &file_data))
	goto busy_no_file;
	// check that we have a file and not something else
	if (!S_ISREG(file_data.st_mode) && !S_ISLNK(file_data.st_mode))
	goto busy_no_file;
	int file = open(fname, O_RDONLY);
	if (file == -1)
	goto busy_no_file;
	sock_buffer_s *buffer;
	buffer = sock_buffer_checkout();
	memcpy(buffer->buf,
	"HTTP/1.1 503 Service Unavailable\r\n"
	"Content-Type: text/html\r\n"
	"Connection: close\r\n"
	"Content-Length: ",
	94);
	p_len = 94 + http_ul2a((char *)buffer->buf + 94, file_data.st_size);
	memcpy(buffer->buf + p_len, "\r\n\r\n", 4);
	p_len += 4;
	if ((off_t)(BUFFER_PACKET_SIZE - p_len) > file_data.st_size) {
	if (read(file, buffer->buf + p_len, file_data.st_size) < 0) {
	close(file);
	sock_buffer_free(buffer);
	goto busy_no_file;
	}
	close(file);
	buffer->len = p_len + file_data.st_size;
	sock_buffer_send(fd, buffer);
	} else {
	buffer->len = p_len;
	sock_buffer_send(fd, buffer);
	sock_sendfile(fd, file, 0, file_data.st_size);
	sock_close(fd);
	}
	return NULL;
	}

	busy_no_file:
	sock_write(fd,
	"HTTP/1.1 503 Service Unavailable\r\nContent-Length: "
	"13\r\n\r\nServer Busy.",
	68);
	sock_close(fd);
	return NULL;
	}