For the moment we will concentrate on getting the client-to-server/server-to-client round-trip working so the initial representation of an HTTP Response will be distinctly minimal.
1.0 HTTP Response: The RFC 2616 Definition
1.1 Response
An HTTP Response is defined like this
Response = Status-Line ; Section 6.1
*(( general-header ; Section 4.5
| response-header ; Section 6.2
| entity-header ) CRLF) ; Section 7.1
CRLF
[ message-body ] ; Section 7.21.2 Status-Line
Status-Line is defined like this
Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF
The Status-Code is a three digit integer, 404 probably being the most familiar example, and the Reason-Phrase is any text excluding CR and/or LF, the counterpart to 404 being Not Found
2.0 Representing A Response
2.1 The Components
2.1.1 Status
The Status struct represents both the Status-Code and the Reason-Phrase since they are always paired.
pub struct Status
{
code: uint,
reason: &'static str
}The Status-Code/Reason-Phrase pairs can then be represented as static items, like so
pub static NOT_FOUND: Status = Status { code: 404, reason: "Not Found" };2.2 The Response
For the moment the Response struct only holds a Status value.
pub struct Response
{
priv status: Status
}3.0 Building A Response
A Response is constructed using a ResponseBuilder.
For the moment it implements a single static method notFound
impl ResponseBuilder
{
pub fn notFound() -> Response
{
Response { status: NOT_FOUND }
}
}4.0 Writing A Response
4.1 ResponseWriter
A ResponseWriter is the counterpart of a RequestBuffer.
It knows how to write the lines that make up the HTTP Response to the connection but it does not know how an HTTP Response is represented.
4.2 The Response write Method
The write method implemented by the Response struct writes the most minimal HTTP Response possible
pub fn write(&self, writer: &mut ResponseWriter)
{
writer.beginResponse();
writer.writeStatus(self.status.code, self.status.reason);
writer.endResponse();
}4.0 Source Files
4.1 HTTP.rs
// HTTP.rs
// part of httpd v0.5
use std::net::url;
pub static CR: u8 = 13;
pub static LF: u8 = 10;
pub static SP: u8 = 32;
//
pub static VERSION: &'static str = "HTTP/1.1";
//
pub enum Method
{
CONNECT,
DELETE,
GET,
HEAD,
OPTIONS,
POST,
PUT,
TRACE
}
impl Method
{
pub fn fromString(s: &str) -> Method
{
match s
{
"CONNECT" => CONNECT,
"DELETE" => DELETE,
"GET" => GET,
"HEAD" => HEAD,
"OPTIONS" => OPTIONS,
"POST" => POST,
"PUT" => PUT,
"TRACE" => TRACE,
_ =>
{
fail!(fmt!("Unrecognized method %s", s));
}
}
}
}
//
pub enum RequestURI
{
AbsolutePath(~str),
AbsoluteURI(url::Url),
Authority(~str),
Wildcard
}
impl RequestURI
{
pub fn fromString(method: Method, s: &str) -> RequestURI
{
match method
{
CONNECT =>
{
Authority(s.to_str())
},
_ =>
{
let length = s.len();
if (length == 1)
{
match s.char_at(0)
{
'*' =>
{
Wildcard
},
'/' =>
{
AbsolutePath(~"/")
},
_ =>
{
fail!(fmt!("Invalid URI: %s", s));
}
}
}
else
{
match s.char_at(0)
{
'/' =>
{
AbsolutePath(s.to_str())
}
_ =>
{
match url::from_str(s)
{
Ok(url) => AbsoluteURI(url),
Err(err) => fail!(err)
}
}
}
}
}
}
}
}
//
pub struct Status
{
code: uint,
reason: &'static str
}
pub static OK: Status = Status { code: 200, reason: "OK" };
pub static NOT_FOUND: Status = Status { code: 404, reason: "Not Found" };
4.2 response.rs
// response.rs
// part of httpd v0.5
use HTTP::Status;
use HTTP::NOT_FOUND;
use writer::ResponseWriter;
pub struct Response
{
priv status: Status
}
impl Response
{
pub fn write(&self, writer: &mut ResponseWriter)
{
writer.beginResponse();
writer.writeStatus(self.status.code, self.status.reason);
writer.endResponse();
}
}
pub struct ResponseBuilder
{
priv status: Status
}
impl ResponseBuilder
{
pub fn notFound() -> Response
{
Response { status: NOT_FOUND }
}
}
4.3 writer.rs
// writer.rs
// part of httpd v0.5
use std::net::tcp::TcpSocketBuf;
use HTTP::CR;
use HTTP::LF;
use HTTP::SP;
use HTTP::VERSION;
enum State
{
INIT,
STATUS,
HEADERS
}
pub struct ResponseWriter
{
priv socketBuf: TcpSocketBuf,
priv state: State,
priv buffer: ~[u8]
}
static SIZE: uint = 1024;
//
static COLON: u8 = 58;
impl ResponseWriter
{
pub fn new(socketBuf: TcpSocketBuf) -> ResponseWriter
{
ResponseWriter { socketBuf: socketBuf, state: INIT, buffer: ~[0u8, ..SIZE] }
}
//
pub fn beginResponse(&mut self)
{
self.state = INIT;
self.buffer.clear();
}
pub fn writeStatus(&mut self, code: uint, reason: &str)
{
match self.state
{
INIT =>
{
// build status line
self.appendString(VERSION);
self.append(SP);
self.appendString(code.to_str());
self.append(SP);
self.appendString(reason);
//
self.writeLine();
//
self.state = STATUS;
}
_ =>
{
fail!(~"Internal Error");
}
}
}
pub fn writeHeader(&mut self, key: &str, value: &str)
{
match self.state
{
STATUS|HEADERS =>
{
// build message-header
self.appendString(key);
self.append(COLON);
self.append(SP);
self.appendString(value);
//
self.writeLine();
//
self.state = HEADERS;
}
_ =>
{
fail!(~"Internal Error");
}
}
}
pub fn endResponse(&mut self)
{
match self.state
{
STATUS|HEADERS =>
{
self.writeLine();
}
_ =>
{
fail!(~"Internal Error");
}
}
}
//
fn writeLine(&mut self)
{
io::println(str::from_bytes(self.buffer));
self.append(CR);
self.append(LF);
self.socketBuf.write(self.buffer);
self.buffer.clear();
}
fn append(&mut self, byte: u8)
{
self.buffer.push(byte);
}
fn appendBytes(&mut self, bytes: &[u8])
{
self.buffer.push_all(bytes);
}
fn appendString(&mut self, s: &str)
{
self.appendBytes(s.to_bytes());
}
}Copyright (c) 2013 By Simon Lewis. All Rights Reserved.
Unauthorized use and/or duplication of this material without express and written permission from this blog’s author and owner Simon Lewis is strictly prohibited.
Excerpts and links may be used, provided that full and clear credit is given to Simon Lewis and justanapplication.wordpress.com with appropriate and specific direction to the original content.
Just An Application 