struct Request {
remote_addr: SocketAddr,
method: Method,
uri: Uri,
version: (uint, uint),
cert: Option<X509Certificate>,
headers: HeaderCollection
}
HeaderCollection
struct HeaderCollection {
// RFC 2616, Section 4.5: General Header Fields
cache_control: Option<CacheControl>,
connection: Option<~[Connection]>,
date: Option<Tm>,
pragma: Option<Pragma>,
trailer: Option<~str>,
transfer_encoding: Option<~[TransferCoding]>,
upgrade: Option<Upgrade>,
via: Option<Via>,
warning: Option<Warning>,
// RFC 2616, Section 5.3: Request Header Fields
accept: Option<Accept>,
accept_charset: Option<~[AcceptCharset]>,
accept_encoding: Option<~[AcceptEncoding]>,
accept_language: Option<~[AcceptLanguage]>,
authorization: Option<Credentials>,
expect: Option<~[Expectation]>,
from: Option<~str>,
host: Option<Host>,
if_match: Option<~[IfMatch]>,
if_modified_since: Option<Tm>,
if_none_match: Option<IfMatch>,
if_range: Option<IfRange>,
if_unmodified_since: Option<Tm>,
max_forwards: Option<uint>,
proxy_authorization: Option<Credentials>,
range: Option<Range>,
referer: Option<Url>,
te: Option<~[Te]>,
user_agent: Option<UserAgent>,
// RFC 2616, Section 7.1: Entity Header Fields
allow: Option<~[Method]>,
content_encoding: Option<~str>,
content_language: Option<~str>,
content_length: Option<uint>,
content_location: Option<~str>,
content_md5: Option<~str>,
content_range: Option<~str>,
content_type: Option<MediaType>,
expires: Option<Tm>,
last_modified Option<Tm>
}
enum Connection {
Token(~str),
Close
}
type CacheControl = ~[CacheDirective]
enum CacheDirective {
Request(RequestDirective),
Response(ResponseDirective)
}
enum RequestDirective {
NoCache,
NoStore,
MaxAge(uint),
MaxStale(Option<uint>),
MinFresh(uint),
NoTransform,
OnlyIfCached,
Extension(CacheExtension)
}
enum ResponseDirective {
Public,
Private(Option<~[~str]>),
NoCache(Option<~[~str]>),
NoStore,
NoTransform,
MustRevalidate,
ProxyRevalidate,
MaxAge(uint),
SMaxAge(uint),
Extension(Map<~str, Option<~str>>)
}
enum Pragma {
NoCache,
Extension(Map<~str, Option<~str>>)
}
enum TransferCoding {
Chunked,
TransferExtension(~str, ~[(~str, ~str)])
}
struct Product {
product: ~str,
version: ~str
}
type Upgrade = ~[Product];
type Via = ~[ViaEntry]
struct ViaEntry {
protocol_name: Option<~str>,
protocol_version: ~str,
received_by: ReceivedBy,
comment: ~str
}
enum ReceivedBy {
Location(IpAddr, uint),
Pseudonym(~str)
}
type Warning = ~[WarningValue];
struct WarningValue {
warn_code: uint,
warn_agent: WarnAgent,
warn_text: ~str,
warn_date: Tm
}
enum WarnAgent {
Location(IpAddr, uint),
Pseudonym(~str)
}
type Accept = ~[MediaRange];
struct MediaRange {
media_type: MediaType,
parameters: Option<Map<~str, ~str>>,
accept_params: AcceptParams
}
struct AcceptParams {
quality: Option<f32>,
extensions: Option<Map<~str, Option<~str>>
}
enum MediaType {
Any,
AnySubtype(~str),
Specific(~str, ~str)
}
struct AcceptCharset {
charset: Charset,
quality: Option<f32>
}
enum Charset {
Any,
Charset(~str)
}
struct AcceptEncoding {
codings: Codings,
quality: Option<f32>
}
enum Codings {
Any,
Coding(~str)
}
struct AcceptLanguage {
range: LanguageRange,
quality: Option<f32>
}
enum LanguageRange {
Any,
Range(~[~str])
}
struct Credentials {
auth_scheme: ~str,
auth_params: Option<Map<~str, Option<~str>>
}
enum Expectation {
Continue,
Extension(Map<~str, ~[ExpectationValue]>)
}
struct ExpectationValue {
value: ~str,
params: Map<~str, ~str>
}
enum IfMatch {
Any,
ETag(~[EntityTag])
}
struct EntityTag {
weak: bool,
tag: ~str
}
enum IfRange {
ETag(EntityTag),
Date(Tm)
}
enum Range {
ByteRange(uint, Option<uint>),
SuffixByteRange(uint)
}
enum Te {
Trailers,
Codings(TransferExtension, Option<AcceptParams>)
}
enum UserAgent {
Product(Product),
Comment(~str)
}
enum Method {
Options,
Get,
Head,
Post,
Put,
Delete,
Trace,
Connect,
Patch, // RFC 5789
ExtensionMethod(~str),
}
struct MediaType {
type_: ~str,
subtype: ~str,
parameters: ~[(~str, ~str)]
}