jscoverage/trunk/http-exchange.c

/*
    http-exchange.c - HTTP request/response exchange
    Copyright (C) 2008 siliconforks.com

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#include <config.h>

#include "http-server.h"

#include <assert.h>
#include <ctype.h>
#include <string.h>

#include <arpa/inet.h>

#include "util.h"

struct HTTPExchange {
  HTTPConnection * connection;

  HTTPMessage * request_message;

  char * method;
  char * request_uri;
  char * request_http_version;

  char * host;
  uint16_t port;
  char * abs_path;
  char * query;

  HTTPMessage * response_message;

  uint16_t status_code;
  char * response_http_version;
};

static const struct {
  const int status_code;
  const char * const reason_phrase;
} reason_phrases[] = {
  {100, "Continue"},
  {101, "Switching Protocols"},
  {200, "OK"},
  {201, "Created"},
  {202, "Accepted"},
  {203, "Non-Authoritative Information"},
  {204, "No Content"},
  {205, "Reset Content"},
  {206, "Partial Content"},
  {301, "Moved Permanently"},
  {302, "Found"},
  {303, "See Other"},
  {304, "Not Modified"},
  {305, "Use Proxy"},
  {307, "Temporary Redirect"},
  {400, "Bad Request"},
  {401, "Unauthorized"},
  {402, "Payment Required"},
  {403, "Forbidden"},
  {404, "Not Found"},
  {405, "Method Not Allowed"},
  {406, "Not Acceptable"},
  {407, "Proxy Authentication Required"},
  {408, "Request Time-out"},
  {409, "Conflict"},
  {410, "Gone"},
  {411, "Length Required"},
  {412, "Precondition Failed"},
  {413, "Request Entity Too Large"},
  {414, "Request-URI Too Large"},
  {415, "Unsupported Media Type"},
  {416, "Requested range not satisfiable"},
  {417, "Expectation Failed"},
  {500, "Internal Server Error"},
  {501, "Not Implemented"},
  {502, "Bad Gateway"},
  {503, "Service Unavailable"},
  {504, "Gateway Time-out"},
  {505, "HTTP Version not supported"},
};

HTTPExchange * HTTPExchange_new(HTTPConnection * connection) {
  HTTPExchange * exchange = xmalloc(sizeof(HTTPExchange));

  exchange->connection = connection;

  exchange->request_message = HTTPMessage_new(connection);
  exchange->method = NULL;
  exchange->request_uri = NULL;
  exchange->request_http_version = NULL;
  exchange->host = NULL;
  exchange->port = 0;
  exchange->abs_path = NULL;
  exchange->query = NULL;

  exchange->response_message = HTTPMessage_new(connection);
  exchange->response_http_version = NULL;
  exchange->status_code = 0;

  return exchange;
}

void HTTPExchange_delete(HTTPExchange * exchange) {
  HTTPMessage_delete(exchange->response_message);
  free(exchange->response_http_version);

  HTTPMessage_delete(exchange->request_message);
  free(exchange->method);
  free(exchange->request_uri);
  free(exchange->request_http_version);
  free(exchange->host);
  free(exchange->abs_path);
  free(exchange->query);

  free(exchange);
}

int HTTPExchange_get_peer(const HTTPExchange * exchange, struct sockaddr_in * peer) {
  return HTTPConnection_get_peer(exchange->connection, peer);
}

HTTPMessage * HTTPExchange_get_request_message(const HTTPExchange * exchange) {
  return exchange->request_message;
}

const char * HTTPExchange_get_request_line(const HTTPExchange * exchange) {
  return HTTPMessage_get_start_line(exchange->request_message);
}

const char * HTTPExchange_get_method(const HTTPExchange * exchange) {
  return exchange->method;
}

const char * HTTPExchange_get_request_uri(const HTTPExchange * exchange) {
  return exchange->request_uri;
}

const char * HTTPExchange_get_request_http_version(const HTTPExchange * exchange) {
  return exchange->request_http_version;
}

const char * HTTPExchange_get_host(const HTTPExchange * exchange) {
  return exchange->host;
}

uint16_t HTTPExchange_get_port(const HTTPExchange * exchange) {
  return exchange->port;
}

const char * HTTPExchange_get_abs_path(const HTTPExchange * exchange) {
  return exchange->abs_path;
}

void HTTPExchange_set_method(HTTPExchange * exchange, const char * method) {
  free(exchange->method);
  exchange->method = xstrdup(method);
}

void HTTPExchange_set_request_uri(HTTPExchange * exchange, const char * request_uri) {
  free(exchange->request_uri);
  exchange->request_uri = xstrdup(request_uri);
}

const HTTPHeader * HTTPExchange_get_request_headers(const HTTPExchange * exchange) {
  return HTTPMessage_get_headers(exchange->request_message);
}

const char * HTTPExchange_find_request_header(const HTTPExchange * exchange, const char * name) {
  return HTTPMessage_find_header(exchange->request_message, name);
}

void HTTPExchange_add_request_header(HTTPExchange * exchange, const char * name, const char * value) {
  HTTPMessage_add_header(exchange->request_message, name, value);
}

void HTTPExchange_set_request_header(HTTPExchange * exchange, const char * name, const char * value) {
  HTTPMessage_set_header(exchange->request_message, name, value);
}

void HTTPExchange_set_request_content_length(HTTPExchange * exchange, size_t value) {
  HTTPMessage_set_content_length(exchange->request_message, value);
}

int HTTPExchange_read_request_headers(HTTPExchange * exchange) {
  int result = 0;

  result = HTTPMessage_read_start_line_and_headers(exchange->request_message);
  if (result != 0) {
    return result;
  }

  /* parse the Request-Line */
  const char * request_line = HTTPMessage_get_start_line(exchange->request_message);
  const char * p = request_line;

  /* parse the Method */
  while (*p != ' ') {
    if (*p == '\0') {
      return -1;
    }
    p++;
  }
  if (p == request_line) {
    return -1;
  }
  exchange->method = xstrndup(request_line, p - request_line);

  /* skip over space */
  p++;

  /* parse the Request-URI */
  const char * start = p;
  while (*p != ' ') {
    if (*p == '\0') {
      return -1;
    }
    p++;
  }
  if (p == start) {
    return -1;
  }
  exchange->request_uri = xstrndup(start, p - start);

  /* skip over space */
  p++;

  /* parse the HTTP-Version */
  start = p;
  while (*p != '\r' && *p != '\n') {
    if (*p == '\0') {
      return -1;
    }
    p++;
  }
  if (p == start) {
    return -1;
  }
  exchange->request_http_version = xstrndup(start, p - start);

  /* uri elements */
  /* RFC 2616 5.1.2: the Request-URI can be an `absoluteURI' or an `abs_path' */
  result = URL_parse(exchange->request_uri, &(exchange->host), &(exchange->port),
                                            &(exchange->abs_path), &(exchange->query));
  if (result != 0) {
    return result;
  }

  if (exchange->host == NULL) {
    /* abs_path */
    const char * h = HTTPMessage_find_header(exchange->request_message, HTTP_HOST);
    if (h == NULL) {
      /* this must be an HTTP/1.0 client */
    }
    else {
      result = URL_parse_host_and_port(h, &(exchange->host), &(exchange->port));
      if (result != 0) {
        return result;
      }
    }
  }

  return 0;
}

int HTTPExchange_write_request_headers(HTTPExchange * exchange) {
  if (HTTPMessage_has_sent_headers(exchange->request_message)) {
    return 0;
  }

  /* set the Request-Line */
  if (HTTPMessage_get_start_line(exchange->request_message) == NULL) {
    if (exchange->method == NULL) {
      exchange->method = xstrdup("GET");
    }
    assert(exchange->request_uri != NULL);
    char * request_line;
    xasprintf(&request_line, "%s %s HTTP/1.1\r\n", exchange->method, exchange->request_uri);
    HTTPMessage_set_start_line(exchange->request_message, request_line);
    free(request_line);
  }

  /* set the Host, if necessary */
  if (! str_starts_with(exchange->request_uri, "http://")) {
    const char * host = HTTPMessage_find_header(exchange->request_message, HTTP_HOST);
    if (host == NULL) {
      struct sockaddr_in peer;
      int result = HTTPConnection_get_peer(exchange->connection, &peer);
      if (result != 0) {
        return result;
      }
      /* FIXME: is this thread-safe??? */
      const char * a = inet_ntoa(peer.sin_addr);
      char * value;
      xasprintf(&value, "%s:%u", a, ntohs(peer.sin_port));
      HTTPMessage_add_header(exchange->request_message, HTTP_HOST, value);
      free(value);
    }
  }

  return HTTPMessage_write_start_line_and_headers(exchange->request_message);
}

bool HTTPExchange_request_has_body(const HTTPExchange * exchange) {
  /*
  RFC 2616 4.3: a request has a body iff the request has a Content-Length or Transfer-Encoding header
  */
  return HTTPMessage_find_header(exchange->request_message, HTTP_CONTENT_LENGTH) != NULL || 
         HTTPMessage_find_header(exchange->request_message, HTTP_TRANSFER_ENCODING) != NULL;
}

int HTTPExchange_read_entire_request_entity_body(HTTPExchange * exchange, Stream * stream) {
  return HTTPMessage_read_entire_entity_body(exchange->request_message, stream);
}

int HTTPExchange_flush_request(HTTPExchange * exchange) {
  return HTTPMessage_flush(exchange->request_message);
}

/* response methods */

HTTPMessage * HTTPExchange_get_response_message(const HTTPExchange * exchange) {
  return exchange->response_message;
}

const char * HTTPExchange_get_response_http_version(const HTTPExchange * exchange) {
  return exchange->response_http_version;
}

uint16_t HTTPExchange_get_status_code(const HTTPExchange * exchange) {
  return exchange->status_code;
}

void HTTPExchange_set_status_code(HTTPExchange * exchange, uint16_t status_code) {
  exchange->status_code = status_code;
}

const HTTPHeader * HTTPExchange_get_response_headers(const HTTPExchange * exchange) {
  return HTTPMessage_get_headers(exchange->response_message);
}

const char * HTTPExchange_find_response_header(const HTTPExchange * exchange, const char * name) {
  return HTTPMessage_find_header(exchange->response_message, name);
}

void HTTPExchange_add_response_header(HTTPExchange * exchange, const char * name, const char * value) {
  HTTPMessage_add_header(exchange->response_message, name, value);
}

void HTTPExchange_set_response_header(HTTPExchange * exchange, const char * name, const char * value) {
  HTTPMessage_set_header(exchange->response_message, name, value);
}

void HTTPExchange_set_response_content_length(HTTPExchange * exchange, size_t value) {
  HTTPMessage_set_content_length(exchange->response_message, value);
}

static void skip_digits(const char ** p) {
  while (**p != '\0' && isdigit(**p)) {
    (*p)++;
  }
}

int HTTPExchange_read_response_headers(HTTPExchange * exchange) {
  /* make sure the request went through before we try to read stuff */
  int result = HTTPExchange_flush_request(exchange);
  if (result != 0) {
    return result;
  }

  result = HTTPMessage_read_start_line_and_headers(exchange->response_message);
  if (result != 0) {
    return result;
  }

  /* parse the Status-Line (RFC 2616 6.1) */
  const char * status_line = HTTPMessage_get_start_line(exchange->response_message);
  const char * p = status_line;

  /* read the HTTP-Version */
  if (! str_starts_with(p, "HTTP/")) {
    return -1;
  }
  p += 5;
  const char * start = p;
  skip_digits(&p);
  if (start == p) {
    return -1;
  }
  if (*p != '.') {
    return -1;
  }
  p++;
  start = p;
  skip_digits(&p);
  if (start == p) {
    return -1;
  }
  if (*p != ' ') {
    return -1;
  }
  exchange->response_http_version = xstrndup(status_line, p - status_line);

  /* skip over the space */
  p++;

  /* read the Status-Code */
  start = p;
  skip_digits(&p);
  if (p - start != 3) {
    return -1;
  }
  if (*p != ' ') {
    return -1;
  }
  exchange->status_code = strtoul(start, NULL, 10);

  return 0;
}

int HTTPExchange_write_response_headers(HTTPExchange * exchange) {
  if (HTTPMessage_has_sent_headers(exchange->response_message)) {
    return 0;
  }

  /* set the Status-Line (RFC 2616 6.1) */
  if (exchange->status_code == 0) {
    exchange->status_code = 200;
  }
  const char * reason_phrase = NULL;
  size_t num_reason_phrases = sizeof(reason_phrases) / sizeof(reason_phrases[0]);
  for (size_t i = 0; i < num_reason_phrases; i++) {
    if (reason_phrases[i].status_code == exchange->status_code) {
      reason_phrase = reason_phrases[i].reason_phrase;
      break;
    }
  }
  assert(reason_phrase != NULL);
  char * status_line;
  xasprintf(&status_line, "HTTP/1.1 %u %s\r\n", exchange->status_code, reason_phrase);
  HTTPMessage_set_start_line(exchange->response_message, status_line);
  free(status_line);

  /* set the Content-Type, if necessary */
  const char * content_type = HTTPMessage_find_header(exchange->response_message, HTTP_CONTENT_TYPE);
  if (content_type == NULL) {
    HTTPMessage_set_header(exchange->response_message, HTTP_CONTENT_TYPE, "text/html");
  }

  return HTTPMessage_write_start_line_and_headers(exchange->response_message);
}

bool HTTPExchange_response_has_body(const HTTPExchange * exchange) {
  /*
  RFC 2616 4.3: a response has a body iff the request is not HEAD and the response is not 1xx, 204, 304
  */
  const char * request_method = HTTPExchange_get_method(exchange);
  assert(request_method != NULL);
  return strcmp(request_method, "HEAD") != 0 &&
         exchange->status_code != 304 &&
         exchange->status_code != 204 &&
         exchange->status_code / 100 != 1;
}

int HTTPExchange_read_entire_response_entity_body(HTTPExchange * exchange, Stream * stream) {
  return HTTPMessage_read_entire_entity_body(exchange->response_message, stream);
}

int HTTPExchange_write_response(HTTPExchange * exchange, const void * p, size_t size) {
  int result = HTTPExchange_write_response_headers(exchange);
  if (result != 0) {
    return result;
  }
  return HTTPMessage_write(exchange->response_message, p, size);
}

int HTTPExchange_flush_response(HTTPExchange * exchange) {
  int result = HTTPExchange_write_response_headers(exchange);
  if (result != 0) {
    return result;
  }
  return HTTPMessage_flush(exchange->response_message);
}
1	siliconforks	116	/*
2			http-exchange.c - HTTP request/response exchange
3			Copyright (C) 2008 siliconforks.com
4
5			This program is free software; you can redistribute it and/or modify
6			it under the terms of the GNU General Public License as published by
7			the Free Software Foundation; either version 2 of the License, or
8			(at your option) any later version.
9
10			This program is distributed in the hope that it will be useful,
11			but WITHOUT ANY WARRANTY; without even the implied warranty of
12			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			GNU General Public License for more details.
14
15			You should have received a copy of the GNU General Public License along
16			with this program; if not, write to the Free Software Foundation, Inc.,
17			51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18			*/
19
20			#include <config.h>
21
22			#include "http-server.h"
23
24			#include <assert.h>
25			#include <ctype.h>
26			#include <string.h>
27
28			#include <arpa/inet.h>
29
30			#include "util.h"
31
32			struct HTTPExchange {
33			HTTPConnection * connection;
34
35			HTTPMessage * request_message;
36
37			char * method;
38			char * request_uri;
39			char * request_http_version;
40
41			char * host;
42			uint16_t port;
43			char * abs_path;
44			char * query;
45
46			HTTPMessage * response_message;
47
48			uint16_t status_code;
49			char * response_http_version;
50			};
51
52			static const struct {
53			const int status_code;
54			const char * const reason_phrase;
55			} reason_phrases[] = {
56			{100, "Continue"},
57			{101, "Switching Protocols"},
58			{200, "OK"},
59			{201, "Created"},
60			{202, "Accepted"},
61			{203, "Non-Authoritative Information"},
62			{204, "No Content"},
63			{205, "Reset Content"},
64			{206, "Partial Content"},
65			{301, "Moved Permanently"},
66			{302, "Found"},
67			{303, "See Other"},
68			{304, "Not Modified"},
69			{305, "Use Proxy"},
70			{307, "Temporary Redirect"},
71			{400, "Bad Request"},
72			{401, "Unauthorized"},
73			{402, "Payment Required"},
74			{403, "Forbidden"},
75			{404, "Not Found"},
76			{405, "Method Not Allowed"},
77			{406, "Not Acceptable"},
78			{407, "Proxy Authentication Required"},
79			{408, "Request Time-out"},
80			{409, "Conflict"},
81			{410, "Gone"},
82			{411, "Length Required"},
83			{412, "Precondition Failed"},
84			{413, "Request Entity Too Large"},
85			{414, "Request-URI Too Large"},
86			{415, "Unsupported Media Type"},
87			{416, "Requested range not satisfiable"},
88			{417, "Expectation Failed"},
89			{500, "Internal Server Error"},
90			{501, "Not Implemented"},
91			{502, "Bad Gateway"},
92			{503, "Service Unavailable"},
93			{504, "Gateway Time-out"},
94			{505, "HTTP Version not supported"},
95			};
96
97			HTTPExchange * HTTPExchange_new(HTTPConnection * connection) {
98			HTTPExchange * exchange = xmalloc(sizeof(HTTPExchange));
99
100			exchange->connection = connection;
101
102			exchange->request_message = HTTPMessage_new(connection);
103			exchange->method = NULL;
104			exchange->request_uri = NULL;
105			exchange->request_http_version = NULL;
106			exchange->host = NULL;
107			exchange->port = 0;
108			exchange->abs_path = NULL;
109			exchange->query = NULL;
110
111			exchange->response_message = HTTPMessage_new(connection);
112			exchange->response_http_version = NULL;
113			exchange->status_code = 0;
114
115			return exchange;
116			}
117
118			void HTTPExchange_delete(HTTPExchange * exchange) {
119			HTTPMessage_delete(exchange->response_message);
120			free(exchange->response_http_version);
121
122			HTTPMessage_delete(exchange->request_message);
123			free(exchange->method);
124			free(exchange->request_uri);
125			free(exchange->request_http_version);
126			free(exchange->host);
127			free(exchange->abs_path);
128			free(exchange->query);
129
130			free(exchange);
131			}
132
133			int HTTPExchange_get_peer(const HTTPExchange * exchange, struct sockaddr_in * peer) {
134			return HTTPConnection_get_peer(exchange->connection, peer);
135			}
136
137			HTTPMessage * HTTPExchange_get_request_message(const HTTPExchange * exchange) {
138			return exchange->request_message;
139			}
140
141			const char * HTTPExchange_get_request_line(const HTTPExchange * exchange) {
142			return HTTPMessage_get_start_line(exchange->request_message);
143			}
144
145			const char * HTTPExchange_get_method(const HTTPExchange * exchange) {
146			return exchange->method;
147			}
148
149			const char * HTTPExchange_get_request_uri(const HTTPExchange * exchange) {
150			return exchange->request_uri;
151			}
152
153			const char * HTTPExchange_get_request_http_version(const HTTPExchange * exchange) {
154			return exchange->request_http_version;
155			}
156
157			const char * HTTPExchange_get_host(const HTTPExchange * exchange) {
158			return exchange->host;
159			}
160
161			uint16_t HTTPExchange_get_port(const HTTPExchange * exchange) {
162			return exchange->port;
163			}
164
165			const char * HTTPExchange_get_abs_path(const HTTPExchange * exchange) {
166			return exchange->abs_path;
167			}
168
169			void HTTPExchange_set_method(HTTPExchange * exchange, const char * method) {
170			free(exchange->method);
171			exchange->method = xstrdup(method);
172			}
173
174			void HTTPExchange_set_request_uri(HTTPExchange * exchange, const char * request_uri) {
175			free(exchange->request_uri);
176			exchange->request_uri = xstrdup(request_uri);
177			}
178
179			const HTTPHeader * HTTPExchange_get_request_headers(const HTTPExchange * exchange) {
180			return HTTPMessage_get_headers(exchange->request_message);
181			}
182
183			const char * HTTPExchange_find_request_header(const HTTPExchange * exchange, const char * name) {
184			return HTTPMessage_find_header(exchange->request_message, name);
185			}
186
187			void HTTPExchange_add_request_header(HTTPExchange * exchange, const char * name, const char * value) {
188			HTTPMessage_add_header(exchange->request_message, name, value);
189			}
190
191			void HTTPExchange_set_request_header(HTTPExchange * exchange, const char * name, const char * value) {
192			HTTPMessage_set_header(exchange->request_message, name, value);
193			}
194
195			void HTTPExchange_set_request_content_length(HTTPExchange * exchange, size_t value) {
196			HTTPMessage_set_content_length(exchange->request_message, value);
197			}
198
199			int HTTPExchange_read_request_headers(HTTPExchange * exchange) {
200			int result = 0;
201
202			result = HTTPMessage_read_start_line_and_headers(exchange->request_message);
203			if (result != 0) {
204			return result;
205			}
206
207			/* parse the Request-Line */
208			const char * request_line = HTTPMessage_get_start_line(exchange->request_message);
209			const char * p = request_line;
210
211			/* parse the Method */
212			while (*p != ' ') {
213			if (*p == '\0') {
214			return -1;
215			}
216			p++;
217			}
218			if (p == request_line) {
219			return -1;
220			}
221			exchange->method = xstrndup(request_line, p - request_line);
222
223			/* skip over space */
224			p++;
225
226			/* parse the Request-URI */
227			const char * start = p;
228			while (*p != ' ') {
229			if (*p == '\0') {
230			return -1;
231			}
232			p++;
233			}
234			if (p == start) {
235			return -1;
236			}
237			exchange->request_uri = xstrndup(start, p - start);
238
239			/* skip over space */
240			p++;
241
242			/* parse the HTTP-Version */
243			start = p;
244			while (p != '\r' && p != '\n') {
245			if (*p == '\0') {
246			return -1;
247			}
248			p++;
249			}
250			if (p == start) {
251			return -1;
252			}
253			exchange->request_http_version = xstrndup(start, p - start);
254
255			/* uri elements */
256			/* RFC 2616 5.1.2: the Request-URI can be an `absoluteURI' or an `abs_path' */
257			result = URL_parse(exchange->request_uri, &(exchange->host), &(exchange->port),
258			&(exchange->abs_path), &(exchange->query));
259			if (result != 0) {
260			return result;
261			}
262
263			if (exchange->host == NULL) {
264			/* abs_path */
265			const char * h = HTTPMessage_find_header(exchange->request_message, HTTP_HOST);
266			if (h == NULL) {
267			/* this must be an HTTP/1.0 client */
268			}
269			else {
270			result = URL_parse_host_and_port(h, &(exchange->host), &(exchange->port));
271			if (result != 0) {
272			return result;
273			}
274			}
275			}
276
277			return 0;
278			}
279
280			int HTTPExchange_write_request_headers(HTTPExchange * exchange) {
281			if (HTTPMessage_has_sent_headers(exchange->request_message)) {
282			return 0;
283			}
284
285			/* set the Request-Line */
286			if (HTTPMessage_get_start_line(exchange->request_message) == NULL) {
287			if (exchange->method == NULL) {
288			exchange->method = xstrdup("GET");
289			}
290			assert(exchange->request_uri != NULL);
291			char * request_line;
292			xasprintf(&request_line, "%s %s HTTP/1.1\r\n", exchange->method, exchange->request_uri);
293			HTTPMessage_set_start_line(exchange->request_message, request_line);
294			free(request_line);
295			}
296
297			/* set the Host, if necessary */
298			if (! str_starts_with(exchange->request_uri, "http://")) {
299			const char * host = HTTPMessage_find_header(exchange->request_message, HTTP_HOST);
300			if (host == NULL) {
301			struct sockaddr_in peer;
302			int result = HTTPConnection_get_peer(exchange->connection, &peer);
303			if (result != 0) {
304			return result;
305			}
306			/* FIXME: is this thread-safe??? */
307			const char * a = inet_ntoa(peer.sin_addr);
308			char * value;
309			xasprintf(&value, "%s:%u", a, ntohs(peer.sin_port));
310			HTTPMessage_add_header(exchange->request_message, HTTP_HOST, value);
311			free(value);
312			}
313			}
314
315			return HTTPMessage_write_start_line_and_headers(exchange->request_message);
316			}
317
318			bool HTTPExchange_request_has_body(const HTTPExchange * exchange) {
319			/*
320			RFC 2616 4.3: a request has a body iff the request has a Content-Length or Transfer-Encoding header
321			*/
322			return HTTPMessage_find_header(exchange->request_message, HTTP_CONTENT_LENGTH) != NULL \|\|
323			HTTPMessage_find_header(exchange->request_message, HTTP_TRANSFER_ENCODING) != NULL;
324			}
325
326			int HTTPExchange_read_entire_request_entity_body(HTTPExchange * exchange, Stream * stream) {
327			return HTTPMessage_read_entire_entity_body(exchange->request_message, stream);
328			}
329
330			int HTTPExchange_flush_request(HTTPExchange * exchange) {
331			return HTTPMessage_flush(exchange->request_message);
332			}
333
334			/* response methods */
335
336			HTTPMessage * HTTPExchange_get_response_message(const HTTPExchange * exchange) {
337			return exchange->response_message;
338			}
339
340			const char * HTTPExchange_get_response_http_version(const HTTPExchange * exchange) {
341			return exchange->response_http_version;
342			}
343
344			uint16_t HTTPExchange_get_status_code(const HTTPExchange * exchange) {
345			return exchange->status_code;
346			}
347
348			void HTTPExchange_set_status_code(HTTPExchange * exchange, uint16_t status_code) {
349			exchange->status_code = status_code;
350			}
351
352			const HTTPHeader * HTTPExchange_get_response_headers(const HTTPExchange * exchange) {
353			return HTTPMessage_get_headers(exchange->response_message);
354			}
355
356			const char * HTTPExchange_find_response_header(const HTTPExchange * exchange, const char * name) {
357			return HTTPMessage_find_header(exchange->response_message, name);
358			}
359
360			void HTTPExchange_add_response_header(HTTPExchange * exchange, const char * name, const char * value) {
361			HTTPMessage_add_header(exchange->response_message, name, value);
362			}
363
364			void HTTPExchange_set_response_header(HTTPExchange * exchange, const char * name, const char * value) {
365			HTTPMessage_set_header(exchange->response_message, name, value);
366			}
367
368			void HTTPExchange_set_response_content_length(HTTPExchange * exchange, size_t value) {
369			HTTPMessage_set_content_length(exchange->response_message, value);
370			}
371
372			static void skip_digits(const char ** p) {
373			while (p != '\0' && isdigit(p)) {
374			(*p)++;
375			}
376			}
377
378			int HTTPExchange_read_response_headers(HTTPExchange * exchange) {
379			/* make sure the request went through before we try to read stuff */
380			int result = HTTPExchange_flush_request(exchange);
381			if (result != 0) {
382			return result;
383			}
384
385			result = HTTPMessage_read_start_line_and_headers(exchange->response_message);
386			if (result != 0) {
387			return result;
388			}
389
390			/* parse the Status-Line (RFC 2616 6.1) */
391			const char * status_line = HTTPMessage_get_start_line(exchange->response_message);
392			const char * p = status_line;
393
394			/* read the HTTP-Version */
395			if (! str_starts_with(p, "HTTP/")) {
396			return -1;
397			}
398			p += 5;
399			const char * start = p;
400			skip_digits(&p);
401			if (start == p) {
402			return -1;
403			}
404			if (*p != '.') {
405			return -1;
406			}
407			p++;
408			start = p;
409			skip_digits(&p);
410			if (start == p) {
411			return -1;
412			}
413			if (*p != ' ') {
414			return -1;
415			}
416			exchange->response_http_version = xstrndup(status_line, p - status_line);
417
418			/* skip over the space */
419			p++;
420
421			/* read the Status-Code */
422			start = p;
423			skip_digits(&p);
424			if (p - start != 3) {
425			return -1;
426			}
427			if (*p != ' ') {
428			return -1;
429			}
430			exchange->status_code = strtoul(start, NULL, 10);
431
432			return 0;
433			}
434
435			int HTTPExchange_write_response_headers(HTTPExchange * exchange) {
436			if (HTTPMessage_has_sent_headers(exchange->response_message)) {
437			return 0;
438			}
439
440			/* set the Status-Line (RFC 2616 6.1) */
441			if (exchange->status_code == 0) {
442			exchange->status_code = 200;
443			}
444			const char * reason_phrase = NULL;
445			size_t num_reason_phrases = sizeof(reason_phrases) / sizeof(reason_phrases[0]);
446			for (size_t i = 0; i < num_reason_phrases; i++) {
447			if (reason_phrases[i].status_code == exchange->status_code) {
448			reason_phrase = reason_phrases[i].reason_phrase;
449			break;
450			}
451			}
452			assert(reason_phrase != NULL);
453			char * status_line;
454			xasprintf(&status_line, "HTTP/1.1 %u %s\r\n", exchange->status_code, reason_phrase);
455			HTTPMessage_set_start_line(exchange->response_message, status_line);
456			free(status_line);
457
458			/* set the Content-Type, if necessary */
459			const char * content_type = HTTPMessage_find_header(exchange->response_message, HTTP_CONTENT_TYPE);
460			if (content_type == NULL) {
461			HTTPMessage_set_header(exchange->response_message, HTTP_CONTENT_TYPE, "text/html");
462			}
463
464			return HTTPMessage_write_start_line_and_headers(exchange->response_message);
465			}
466
467			bool HTTPExchange_response_has_body(const HTTPExchange * exchange) {
468			/*
469			RFC 2616 4.3: a response has a body iff the request is not HEAD and the response is not 1xx, 204, 304
470			*/
471			const char * request_method = HTTPExchange_get_method(exchange);
472			assert(request_method != NULL);
473			return strcmp(request_method, "HEAD") != 0 &&
474			exchange->status_code != 304 &&
475			exchange->status_code != 204 &&
476			exchange->status_code / 100 != 1;
477			}
478
479			int HTTPExchange_read_entire_response_entity_body(HTTPExchange * exchange, Stream * stream) {
480			return HTTPMessage_read_entire_entity_body(exchange->response_message, stream);
481			}
482
483			int HTTPExchange_write_response(HTTPExchange * exchange, const void * p, size_t size) {
484			int result = HTTPExchange_write_response_headers(exchange);
485			if (result != 0) {
486			return result;
487			}
488			return HTTPMessage_write(exchange->response_message, p, size);
489			}
490
491			int HTTPExchange_flush_response(HTTPExchange * exchange) {
492			int result = HTTPExchange_write_response_headers(exchange);
493			if (result != 0) {
494			return result;
495			}
496			return HTTPMessage_flush(exchange->response_message);
497			}