mirror of
https://github.com/apple/swift-nio
synced 2026-11-22 04:30:41 +00:00
### Motivation:
Eight doc comments name an argument that the declaration below them does
not have, so DocC has nothing to bind the description to and quietly
drops it. Nothing warns about this: Swift has no equivalent of
`-Wdocumentation`, and DocC stays silent rather than complaining, so
these sit until somebody reads the generated page and wonders where the
description went
| file | the comment says | the declaration says |
|---|---|---|
| `NIOPosix/ServerSocket.swift` | `descriptor` | `socket` |
| `NIOPosix/Socket.swift` ×2 | `descriptor` | `socket` |
| `NIOHTTP1/ByteCollectionUtils.swift` | `bytes` | `to` |
| `NIOHTTP1/HTTPTypes.swift` | `buffer` | `headers` |
| `NIOFS/BufferedStream.swift` ×2 | `sequence` | `element` |
| `NIOFS/SystemFileHandle.swift` | `executor` | `threadPool` |
The socket ones are worth a word. Each of those files has a pair: a
deprecated `init(descriptor:)` and its replacement `init(socket:)`, and
the rename is recorded right there in `@available(*, deprecated,
renamed: "init(socket:setNonBlocking:)")`. The replacement inherited the
wording of the one it replaced, so the doc still says `descriptor`. The
deprecated ones are correct and I left them alone
And the last two are the same defect in two copies of one module,
`NIOFS` and `_NIOFileSystem`, which is what a verbatim copy of a file
does to a mistake inside it. Fixing one and not the other would leave
them out of sync, so both are in here
### Modifications:
Renamed the documented argument to the one in the declaration, eleven
lines across eight files
One is slightly more than a rename: in `ByteBuffer.write(headers:)` the
entry described the buffer the method is called on rather than its
argument, so it now describes `headers` and keeps the note about the
writer index
### Result:
The parameter descriptions reach the generated documentation. No API
change, no behaviour change, comments only
btw these came out of a checker I wrote for exactly this, run over the
tree and then read by hand one by one. Six of the things it flagged
turned out to be my parser rather than your code, and those are fixed on
my side rather than sent to you 🙌🏼
all of it on a MacBook Air M3, of course
1536 lines
47 KiB
Swift
1536 lines
47 KiB
Swift
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This source file is part of the SwiftNIO open source project
|
|
//
|
|
// Copyright (c) 2017-2021 Apple Inc. and the SwiftNIO project authors
|
|
// Licensed under Apache License v2.0
|
|
//
|
|
// See LICENSE.txt for license information
|
|
// See CONTRIBUTORS.txt for the list of SwiftNIO project authors
|
|
//
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
import NIOCore
|
|
|
|
let crlf: StaticString = "\r\n"
|
|
let headerSeparator: StaticString = ": "
|
|
|
|
extension HTTPHeaders {
|
|
internal enum ConnectionHeaderValue {
|
|
case keepAlive
|
|
case close
|
|
case unspecified
|
|
}
|
|
}
|
|
|
|
// Keep track of keep alive state.
|
|
internal enum KeepAliveState {
|
|
// We know keep alive should be used.
|
|
case keepAlive
|
|
// We know we should close the connection.
|
|
case close
|
|
// We need to scan the headers to find out if keep alive is used or not
|
|
case unknown
|
|
}
|
|
|
|
/// A representation of the request line and header fields of a HTTP request.
|
|
public struct HTTPRequestHead: Equatable {
|
|
private final class _Storage {
|
|
var method: HTTPMethod
|
|
var uri: String
|
|
var version: HTTPVersion
|
|
|
|
init(method: HTTPMethod, uri: String, version: HTTPVersion) {
|
|
self.method = method
|
|
self.uri = uri
|
|
self.version = version
|
|
}
|
|
|
|
func copy() -> _Storage {
|
|
.init(method: self.method, uri: self.uri, version: self.version)
|
|
}
|
|
}
|
|
|
|
private var _storage: _Storage
|
|
|
|
/// The header fields for this HTTP request.
|
|
// warning: do not put this in `_Storage` as it'd trigger a CoW on every mutation
|
|
public var headers: HTTPHeaders
|
|
|
|
/// The HTTP method for this request.
|
|
public var method: HTTPMethod {
|
|
get {
|
|
self._storage.method
|
|
}
|
|
set {
|
|
self.copyStorageIfNotUniquelyReferenced()
|
|
self._storage.method = newValue
|
|
}
|
|
}
|
|
|
|
// This request's URI.
|
|
public var uri: String {
|
|
get {
|
|
self._storage.uri
|
|
}
|
|
set {
|
|
self.copyStorageIfNotUniquelyReferenced()
|
|
self._storage.uri = newValue
|
|
}
|
|
}
|
|
|
|
/// The version for this HTTP request.
|
|
public var version: HTTPVersion {
|
|
get {
|
|
self._storage.version
|
|
}
|
|
set {
|
|
self.copyStorageIfNotUniquelyReferenced()
|
|
self._storage.version = newValue
|
|
}
|
|
}
|
|
|
|
/// Create a `HTTPRequestHead`
|
|
///
|
|
/// - Parameters:
|
|
/// - version: The version for this HTTP request.
|
|
/// - method: The HTTP method for this request.
|
|
/// - uri: The URI used on this request.
|
|
/// - headers: This request's HTTP headers.
|
|
public init(version: HTTPVersion, method: HTTPMethod, uri: String, headers: HTTPHeaders) {
|
|
self._storage = .init(method: method, uri: uri, version: version)
|
|
self.headers = headers
|
|
}
|
|
|
|
/// Create a `HTTPRequestHead`
|
|
///
|
|
/// - Parameter version: The version for this HTTP request.
|
|
/// - Parameter method: The HTTP method for this request.
|
|
/// - Parameter uri: The URI used on this request.
|
|
public init(version: HTTPVersion, method: HTTPMethod, uri: String) {
|
|
self.init(version: version, method: method, uri: uri, headers: HTTPHeaders())
|
|
}
|
|
|
|
public static func == (lhs: HTTPRequestHead, rhs: HTTPRequestHead) -> Bool {
|
|
lhs.method == rhs.method && lhs.uri == rhs.uri && lhs.version == rhs.version && lhs.headers == rhs.headers
|
|
}
|
|
|
|
private mutating func copyStorageIfNotUniquelyReferenced() {
|
|
if !isKnownUniquelyReferenced(&self._storage) {
|
|
self._storage = self._storage.copy()
|
|
}
|
|
}
|
|
}
|
|
|
|
extension HTTPRequestHead: @unchecked Sendable {}
|
|
|
|
/// The parts of a complete HTTP message, representing either a request or a response.
|
|
///
|
|
/// An HTTP message is made up of:
|
|
/// - a request or status line with several headers, encoded by a single ``HTTPPart/head(_:)`` part,
|
|
/// - zero or more ``HTTPPart/body(_:)`` parts,
|
|
/// - and some optional trailers (represented as headers) in a single ``HTTPPart/end(_:)`` part.
|
|
///
|
|
/// To indicate that a complete HTTP message has been sent or received,
|
|
/// an ``HTTPPart/end(_:)`` part must be used, even when no trailers are included.
|
|
public enum HTTPPart<HeadT: Equatable, BodyT: Equatable> {
|
|
/// The headers of an HTTP request or response.
|
|
///
|
|
/// A single part is always used to encode all headers.
|
|
case head(HeadT)
|
|
|
|
/// A part of an HTTP request or response's body.
|
|
///
|
|
/// Zero or more body parts can be sent or received. The stream is finished when
|
|
/// an ``HTTPPart/end(_:)`` part is received.
|
|
case body(BodyT)
|
|
|
|
/// The end of an HTTP request or response, optionally containing trailers.
|
|
///
|
|
/// A single part is always used to encode all trailers.
|
|
case end(HTTPHeaders?)
|
|
}
|
|
|
|
extension HTTPPart: Sendable where HeadT: Sendable, BodyT: Sendable {}
|
|
|
|
extension HTTPPart: Equatable {}
|
|
|
|
/// The components of a HTTP request from the view of a HTTP client.
|
|
public typealias HTTPClientRequestPart = HTTPPart<HTTPRequestHead, IOData>
|
|
|
|
/// The components of a HTTP request from the view of a HTTP server.
|
|
public typealias HTTPServerRequestPart = HTTPPart<HTTPRequestHead, ByteBuffer>
|
|
|
|
/// The components of a HTTP response from the view of a HTTP client.
|
|
public typealias HTTPClientResponsePart = HTTPPart<HTTPResponseHead, ByteBuffer>
|
|
|
|
/// The components of a HTTP response from the view of a HTTP server.
|
|
public typealias HTTPServerResponsePart = HTTPPart<HTTPResponseHead, IOData>
|
|
|
|
extension HTTPRequestHead {
|
|
/// Whether this HTTP request is a keep-alive request: that is, whether the
|
|
/// connection should remain open after the request is complete.
|
|
public var isKeepAlive: Bool {
|
|
headers.isKeepAlive(version: version)
|
|
}
|
|
}
|
|
|
|
extension HTTPResponseHead {
|
|
/// Whether this HTTP response is a keep-alive request: that is, whether the
|
|
/// connection should remain open after the request is complete.
|
|
public var isKeepAlive: Bool {
|
|
self.headers.isKeepAlive(version: self.version)
|
|
}
|
|
}
|
|
|
|
/// A representation of the status line and header fields of a HTTP response.
|
|
public struct HTTPResponseHead: Equatable {
|
|
private final class _Storage {
|
|
var status: HTTPResponseStatus
|
|
var version: HTTPVersion
|
|
init(status: HTTPResponseStatus, version: HTTPVersion) {
|
|
self.status = status
|
|
self.version = version
|
|
}
|
|
func copy() -> _Storage {
|
|
.init(status: self.status, version: self.version)
|
|
}
|
|
}
|
|
|
|
private var _storage: _Storage
|
|
|
|
/// The HTTP headers on this response.
|
|
// warning: do not put this in `_Storage` as it'd trigger a CoW on every mutation
|
|
public var headers: HTTPHeaders
|
|
|
|
/// The HTTP response status.
|
|
public var status: HTTPResponseStatus {
|
|
get {
|
|
self._storage.status
|
|
}
|
|
set {
|
|
self.copyStorageIfNotUniquelyReferenced()
|
|
self._storage.status = newValue
|
|
}
|
|
}
|
|
|
|
/// The HTTP version that corresponds to this response.
|
|
public var version: HTTPVersion {
|
|
get {
|
|
self._storage.version
|
|
}
|
|
set {
|
|
self.copyStorageIfNotUniquelyReferenced()
|
|
self._storage.version = newValue
|
|
}
|
|
}
|
|
|
|
/// Create a `HTTPResponseHead`
|
|
///
|
|
/// - Parameter version: The version for this HTTP response.
|
|
/// - Parameter status: The status for this HTTP response.
|
|
/// - Parameter headers: The headers for this HTTP response.
|
|
public init(version: HTTPVersion, status: HTTPResponseStatus, headers: HTTPHeaders = HTTPHeaders()) {
|
|
self.headers = headers
|
|
self._storage = _Storage(status: status, version: version)
|
|
}
|
|
|
|
public static func == (lhs: HTTPResponseHead, rhs: HTTPResponseHead) -> Bool {
|
|
lhs.status == rhs.status && lhs.version == rhs.version && lhs.headers == rhs.headers
|
|
}
|
|
|
|
private mutating func copyStorageIfNotUniquelyReferenced() {
|
|
if !isKnownUniquelyReferenced(&self._storage) {
|
|
self._storage = self._storage.copy()
|
|
}
|
|
}
|
|
}
|
|
|
|
extension HTTPResponseHead: @unchecked Sendable {}
|
|
|
|
extension HTTPResponseHead {
|
|
/// Determines if the head is purely informational. If a head is informational another head will follow this
|
|
/// head eventually.
|
|
var isInformational: Bool {
|
|
100 <= self.status.code && self.status.code < 200 && self.status.code != 101
|
|
}
|
|
}
|
|
|
|
extension UInt8 {
|
|
fileprivate var isASCII: Bool {
|
|
self <= 127
|
|
}
|
|
}
|
|
|
|
extension HTTPHeaders {
|
|
func isKeepAlive(version: HTTPVersion) -> Bool {
|
|
switch self.keepAliveState {
|
|
case .close:
|
|
return false
|
|
case .keepAlive:
|
|
return true
|
|
case .unknown:
|
|
var state = KeepAliveState.unknown
|
|
for word in self[canonicalForm: "connection"] {
|
|
if word.utf8.compareCaseInsensitiveASCIIBytes(to: "close".utf8) {
|
|
// if we see multiple values, that's clearly bad and we default to 'close'
|
|
state = state != .unknown ? .close : .close
|
|
} else if word.utf8.compareCaseInsensitiveASCIIBytes(to: "keep-alive".utf8) {
|
|
// if we see multiple values, that's clearly bad and we default to 'close'
|
|
state = state != .unknown ? .close : .keepAlive
|
|
}
|
|
}
|
|
|
|
switch state {
|
|
case .close:
|
|
return false
|
|
case .keepAlive:
|
|
return true
|
|
case .unknown:
|
|
// HTTP 1.1 use keep-alive by default if not otherwise told.
|
|
return version.major == 1 && version.minor >= 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A representation of a block of HTTP header fields.
|
|
///
|
|
/// HTTP header fields are a complex data structure. The most natural representation
|
|
/// for these is a sequence of two-tuples of field name and field value, both as
|
|
/// strings. This structure preserves that representation, but provides a number of
|
|
/// convenience features in addition to it.
|
|
///
|
|
/// For example, this structure enables access to header fields based on the
|
|
/// case-insensitive form of the field name, but preserves the original case of the
|
|
/// field when needed. It also supports recomposing headers to a maximally joined
|
|
/// or split representation, such that header fields that are able to be repeated
|
|
/// can be represented appropriately.
|
|
public struct HTTPHeaders: CustomStringConvertible, ExpressibleByDictionaryLiteral {
|
|
@usableFromInline
|
|
internal var headers: [(String, String)]
|
|
internal var keepAliveState: KeepAliveState = .unknown
|
|
|
|
public var description: String {
|
|
self.headers.lazy.map {
|
|
"\($0.0): \($0.1)"
|
|
}
|
|
.joined(separator: "; ")
|
|
}
|
|
|
|
internal var names: [String] {
|
|
self.headers.map { $0.0 }
|
|
}
|
|
|
|
internal init(_ headers: [(String, String)], keepAliveState: KeepAliveState) {
|
|
self.headers = headers
|
|
self.keepAliveState = keepAliveState
|
|
}
|
|
|
|
internal func isConnectionHeader(_ name: String) -> Bool {
|
|
name.utf8.compareCaseInsensitiveASCIIBytes(to: "connection".utf8)
|
|
}
|
|
|
|
/// Construct a `HTTPHeaders` structure.
|
|
///
|
|
/// - Parameters
|
|
/// - headers: An initial set of headers to use to populate the header block.
|
|
/// - allocator: The allocator to use to allocate the underlying storage.
|
|
public init(_ headers: [(String, String)] = []) {
|
|
// Note: this initializer exists because of https://bugs.swift.org/browse/SR-7415.
|
|
// Otherwise we'd only have the one below with a default argument for `allocator`.
|
|
self.init(headers, keepAliveState: .unknown)
|
|
}
|
|
|
|
/// Construct a `HTTPHeaders` structure.
|
|
///
|
|
/// - Parameters
|
|
/// - elements: name, value pairs provided by a dictionary literal.
|
|
public init(dictionaryLiteral elements: (String, String)...) {
|
|
self.init(elements)
|
|
}
|
|
|
|
/// Add a header name/value pair to the block.
|
|
///
|
|
/// This method is strictly additive: if there are other values for the given header name
|
|
/// already in the block, this will add a new entry.
|
|
///
|
|
/// - Parameter name: The header field name. For maximum compatibility this should be an
|
|
/// ASCII string. For future-proofing with HTTP/2 lowercase header names are strongly
|
|
/// recommended.
|
|
/// - Parameter value: The header field value to add for the given name.
|
|
public mutating func add(name: String, value: String) {
|
|
precondition(!name.utf8.contains(where: { !$0.isASCII }), "name must be ASCII")
|
|
self.headers.append((name, value))
|
|
if self.isConnectionHeader(name) {
|
|
self.keepAliveState = .unknown
|
|
}
|
|
}
|
|
|
|
/// Add a sequence of header name/value pairs to the block.
|
|
///
|
|
/// This method is strictly additive: if there are other entries with the same header
|
|
/// name already in the block, this will add new entries.
|
|
///
|
|
/// - Parameter other: The sequence of header name/value pairs. For maximum compatibility
|
|
/// the header should be an ASCII string. For future-proofing with HTTP/2 lowercase header
|
|
/// names are strongly recommended.
|
|
@inlinable
|
|
public mutating func add<S: Sequence>(contentsOf other: S) where S.Element == (String, String) {
|
|
self.headers.reserveCapacity(self.headers.count + other.underestimatedCount)
|
|
for (name, value) in other {
|
|
self.add(name: name, value: value)
|
|
}
|
|
}
|
|
|
|
/// Add another block of headers to the block.
|
|
///
|
|
/// - Parameter other: The block of headers to add to these headers.
|
|
public mutating func add(contentsOf other: HTTPHeaders) {
|
|
self.headers.append(contentsOf: other.headers)
|
|
if other.keepAliveState == .unknown {
|
|
self.keepAliveState = .unknown
|
|
}
|
|
}
|
|
|
|
/// Add a header name/value pair to the block, replacing any previous values for the
|
|
/// same header name that are already in the block.
|
|
///
|
|
/// This is a supplemental method to `add` that essentially combines `remove` and `add`
|
|
/// in a single function. It can be used to ensure that a header block is in a
|
|
/// well-defined form without having to check whether the value was previously there.
|
|
/// Like `add`, this method performs case-insensitive comparisons of the header field
|
|
/// names.
|
|
///
|
|
/// - Parameter name: The header field name. For maximum compatibility this should be an
|
|
/// ASCII string. For future-proofing with HTTP/2 lowercase header names are strongly
|
|
// recommended.
|
|
/// - Parameter value: The header field value to add for the given name.
|
|
public mutating func replaceOrAdd(name: String, value: String) {
|
|
if self.isConnectionHeader(name) {
|
|
self.keepAliveState = .unknown
|
|
}
|
|
self.remove(name: name)
|
|
self.add(name: name, value: value)
|
|
}
|
|
|
|
/// Remove all values for a given header name from the block.
|
|
///
|
|
/// This method uses case-insensitive comparisons for the header field name.
|
|
///
|
|
/// - Parameter name: The name of the header field to remove from the block.
|
|
public mutating func remove(name: String) {
|
|
if self.isConnectionHeader(name) {
|
|
self.keepAliveState = .unknown
|
|
}
|
|
self.headers.removeAll { (headerName, _) in
|
|
if name.utf8.count != headerName.utf8.count {
|
|
return false
|
|
}
|
|
|
|
return name.utf8.compareCaseInsensitiveASCIIBytes(to: headerName.utf8)
|
|
}
|
|
}
|
|
|
|
/// Retrieve all of the values for a give header field name from the block.
|
|
///
|
|
/// This method uses case-insensitive comparisons for the header field name. It
|
|
/// does not return a maximally-decomposed list of the header fields, but instead
|
|
/// returns them in their original representation: that means that a comma-separated
|
|
/// header field list may contain more than one entry, some of which contain commas
|
|
/// and some do not. If you want a representation of the header fields suitable for
|
|
/// performing computation on, consider `subscript(canonicalForm:)`.
|
|
///
|
|
/// - Parameter name: The header field name whose values are to be retrieved.
|
|
/// - Returns: A list of the values for that header field name.
|
|
public subscript(name: String) -> [String] {
|
|
self.headers.reduce(into: []) { target, lr in
|
|
let (key, value) = lr
|
|
if key.utf8.compareCaseInsensitiveASCIIBytes(to: name.utf8) {
|
|
target.append(value)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Retrieves the first value for a given header field name from the block.
|
|
///
|
|
/// This method uses case-insensitive comparisons for the header field name. It
|
|
/// does not return the first value from a maximally-decomposed list of the header fields,
|
|
/// but instead returns the first value from the original representation: that means
|
|
/// that a comma-separated header field list may contain more than one entry, some of
|
|
/// which contain commas and some do not. If you want a representation of the header fields
|
|
/// suitable for performing computation on, consider `subscript(canonicalForm:)`.
|
|
///
|
|
/// - Parameter name: The header field name whose first value should be retrieved.
|
|
/// - Returns: The first value for the header field name.
|
|
public func first(name: String) -> String? {
|
|
guard !self.headers.isEmpty else {
|
|
return nil
|
|
}
|
|
|
|
return self.headers.first { header in header.0.isEqualCaseInsensitiveASCIIBytes(to: name) }?.1
|
|
}
|
|
|
|
/// Checks if a header is present
|
|
///
|
|
/// - Parameters:
|
|
/// - name: The name of the header
|
|
// - returns: `true` if a header with the name (and value) exists, `false` otherwise.
|
|
public func contains(name: String) -> Bool {
|
|
for kv in self.headers {
|
|
if kv.0.utf8.compareCaseInsensitiveASCIIBytes(to: name.utf8) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
/// Retrieves the header values for the given header field in "canonical form": that is,
|
|
/// splitting them on commas as extensively as possible such that multiple values received on the
|
|
/// one line are returned as separate entries. Also respects the fact that Set-Cookie should not
|
|
/// be split in this way.
|
|
///
|
|
/// - Parameter name: The header field name whose values are to be retrieved.
|
|
/// - Returns: A list of the values for that header field name.
|
|
public subscript(canonicalForm name: String) -> [Substring] {
|
|
let result = self[name]
|
|
|
|
guard result.count > 0 else {
|
|
return []
|
|
}
|
|
|
|
// It's not safe to split Set-Cookie on comma.
|
|
guard name.lowercased() != "set-cookie" else {
|
|
return result.map { $0[...] }
|
|
}
|
|
|
|
return result.flatMap { $0.split(separator: ",").map { $0.trimWhitespace() } }
|
|
}
|
|
}
|
|
|
|
extension HTTPHeaders: Sendable {}
|
|
|
|
extension HTTPHeaders {
|
|
|
|
/// The total number of headers that can be contained without allocating new storage.
|
|
public var capacity: Int {
|
|
self.headers.capacity
|
|
}
|
|
|
|
/// Reserves enough space to store the specified number of headers.
|
|
///
|
|
/// - Parameter minimumCapacity: The requested number of headers to store.
|
|
public mutating func reserveCapacity(_ minimumCapacity: Int) {
|
|
self.headers.reserveCapacity(minimumCapacity)
|
|
}
|
|
}
|
|
|
|
extension ByteBuffer {
|
|
|
|
/// Serializes this HTTP header block to bytes suitable for writing to the wire.
|
|
///
|
|
/// - Parameter headers: The header block to serialize. Writing it will increment
|
|
/// the writer index of this buffer.
|
|
mutating func write(headers: HTTPHeaders) {
|
|
for header in headers.headers {
|
|
self.writeString(header.0)
|
|
self.writeStaticString(headerSeparator)
|
|
self.writeString(header.1)
|
|
self.writeStaticString(crlf)
|
|
}
|
|
self.writeStaticString(crlf)
|
|
}
|
|
}
|
|
|
|
extension HTTPHeaders: RandomAccessCollection {
|
|
public typealias Element = (name: String, value: String)
|
|
|
|
public struct Index: Comparable, Sendable {
|
|
fileprivate let base: Array<(String, String)>.Index
|
|
public static func < (lhs: Index, rhs: Index) -> Bool {
|
|
lhs.base < rhs.base
|
|
}
|
|
}
|
|
|
|
public var startIndex: HTTPHeaders.Index {
|
|
.init(base: self.headers.startIndex)
|
|
}
|
|
|
|
public var endIndex: HTTPHeaders.Index {
|
|
.init(base: self.headers.endIndex)
|
|
}
|
|
|
|
public func index(before i: HTTPHeaders.Index) -> HTTPHeaders.Index {
|
|
.init(base: self.headers.index(before: i.base))
|
|
}
|
|
|
|
public func index(after i: HTTPHeaders.Index) -> HTTPHeaders.Index {
|
|
.init(base: self.headers.index(after: i.base))
|
|
}
|
|
|
|
public subscript(position: HTTPHeaders.Index) -> Element {
|
|
self.headers[position.base]
|
|
}
|
|
}
|
|
|
|
extension UTF8.CodeUnit {
|
|
var isASCIIWhitespace: Bool {
|
|
switch self {
|
|
case UInt8(ascii: " "),
|
|
UInt8(ascii: "\t"):
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
extension String {
|
|
func trimASCIIWhitespace() -> Substring {
|
|
Substring(self).trimWhitespace()
|
|
}
|
|
}
|
|
|
|
extension Substring {
|
|
fileprivate func trimWhitespace() -> Substring {
|
|
guard let firstNonWhitespace = self.utf8.firstIndex(where: { !$0.isASCIIWhitespace }) else {
|
|
// The whole substring is ASCII whitespace.
|
|
return Substring()
|
|
}
|
|
|
|
// There must be at least one non-ascii whitespace character, so banging here is safe.
|
|
let lastNonWhitespace = self.utf8.lastIndex(where: { !$0.isASCIIWhitespace })!
|
|
return Substring(self.utf8[firstNonWhitespace...lastNonWhitespace])
|
|
}
|
|
}
|
|
|
|
extension HTTPHeaders: Equatable {
|
|
public static func == (lhs: HTTPHeaders, rhs: HTTPHeaders) -> Bool {
|
|
guard lhs.headers.count == rhs.headers.count else {
|
|
return false
|
|
}
|
|
let lhsNames = Set(lhs.names.map { $0.lowercased() })
|
|
let rhsNames = Set(rhs.names.map { $0.lowercased() })
|
|
guard lhsNames == rhsNames else {
|
|
return false
|
|
}
|
|
|
|
for name in lhsNames {
|
|
guard lhs[name].sorted() == rhs[name].sorted() else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
}
|
|
|
|
public enum HTTPMethod: Equatable, Sendable {
|
|
internal enum HasBody {
|
|
case yes
|
|
case no
|
|
case unlikely
|
|
}
|
|
|
|
case GET
|
|
case PUT
|
|
case ACL
|
|
case HEAD
|
|
case POST
|
|
case COPY
|
|
case LOCK
|
|
case MOVE
|
|
case BIND
|
|
case LINK
|
|
case PATCH
|
|
case TRACE
|
|
case MKCOL
|
|
case MERGE
|
|
case PURGE
|
|
case NOTIFY
|
|
case SEARCH
|
|
case UNLOCK
|
|
case REBIND
|
|
case UNBIND
|
|
case REPORT
|
|
case DELETE
|
|
case UNLINK
|
|
case CONNECT
|
|
case MSEARCH
|
|
case OPTIONS
|
|
case PROPFIND
|
|
case CHECKOUT
|
|
case PROPPATCH
|
|
case SUBSCRIBE
|
|
case MKCALENDAR
|
|
case MKACTIVITY
|
|
case UNSUBSCRIBE
|
|
case SOURCE
|
|
case RAW(value: String)
|
|
|
|
/// Whether requests with this verb may have a request body.
|
|
internal var hasRequestBody: HasBody {
|
|
switch self {
|
|
case .TRACE:
|
|
return .no
|
|
case .POST, .PUT, .PATCH:
|
|
return .yes
|
|
case .GET, .CONNECT, .OPTIONS, .HEAD, .DELETE:
|
|
fallthrough
|
|
default:
|
|
return .unlikely
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A structure representing a HTTP version.
|
|
public struct HTTPVersion: Equatable, Sendable {
|
|
/// Create a HTTP version.
|
|
///
|
|
/// - Parameter major: The major version number.
|
|
/// - Parameter minor: The minor version number.
|
|
@inlinable
|
|
public init(major: Int, minor: Int) {
|
|
self._major = UInt16(major)
|
|
self._minor = UInt16(minor)
|
|
}
|
|
|
|
@usableFromInline var _minor: UInt16
|
|
@usableFromInline var _major: UInt16
|
|
|
|
/// The major version number.
|
|
@inlinable
|
|
public var major: Int {
|
|
get {
|
|
Int(self._major)
|
|
}
|
|
set {
|
|
self._major = UInt16(newValue)
|
|
}
|
|
}
|
|
|
|
/// The minor version number.
|
|
@inlinable
|
|
public var minor: Int {
|
|
get {
|
|
Int(self._minor)
|
|
}
|
|
set {
|
|
self._minor = UInt16(newValue)
|
|
}
|
|
}
|
|
|
|
/// HTTP/3
|
|
@inlinable
|
|
public static var http3: HTTPVersion {
|
|
HTTPVersion(major: 3, minor: 0)
|
|
}
|
|
|
|
/// HTTP/2
|
|
@inlinable
|
|
public static var http2: HTTPVersion {
|
|
HTTPVersion(major: 2, minor: 0)
|
|
}
|
|
|
|
/// HTTP/1.1
|
|
@inlinable
|
|
public static var http1_1: HTTPVersion {
|
|
HTTPVersion(major: 1, minor: 1)
|
|
}
|
|
|
|
/// HTTP/1.0
|
|
@inlinable
|
|
public static var http1_0: HTTPVersion {
|
|
HTTPVersion(major: 1, minor: 0)
|
|
}
|
|
|
|
/// HTTP/0.9 (not supported by SwiftNIO)
|
|
@inlinable
|
|
public static var http0_9: HTTPVersion {
|
|
HTTPVersion(major: 0, minor: 9)
|
|
}
|
|
}
|
|
|
|
extension HTTPParserError: CustomDebugStringConvertible {
|
|
public var debugDescription: String {
|
|
switch self {
|
|
case .invalidCharactersUsed:
|
|
return "illegal characters used in URL/headers"
|
|
case .trailingGarbage:
|
|
return "trailing garbage bytes"
|
|
case .invalidEOFState:
|
|
return "stream ended at an unexpected time"
|
|
case .headerOverflow:
|
|
return "too many header bytes seen; overflow detected"
|
|
case .closedConnection:
|
|
return "data received after completed connection: close message"
|
|
case .invalidVersion:
|
|
return "invalid HTTP version"
|
|
case .invalidStatus:
|
|
return "invalid HTTP status code"
|
|
case .invalidMethod:
|
|
return "invalid HTTP method"
|
|
case .invalidURL:
|
|
return "invalid URL"
|
|
case .invalidHost:
|
|
return "invalid host"
|
|
case .invalidPort:
|
|
return "invalid port"
|
|
case .invalidPath:
|
|
return "invalid path"
|
|
case .invalidQueryString:
|
|
return "invalid query string"
|
|
case .invalidFragment:
|
|
return "invalid fragment"
|
|
case .lfExpected:
|
|
return "LF character expected"
|
|
case .invalidHeaderToken:
|
|
return "invalid character in header"
|
|
case .invalidContentLength:
|
|
return "invalid character in content-length header"
|
|
case .unexpectedContentLength:
|
|
return "unexpected content-length header"
|
|
case .invalidChunkSize:
|
|
return "invalid character in chunk size header"
|
|
case .invalidConstant:
|
|
return "invalid constant string"
|
|
case .invalidInternalState:
|
|
return "invalid internal state (swift-http-parser error)"
|
|
case .strictModeAssertion:
|
|
return "strict mode assertion"
|
|
case .paused:
|
|
return "paused (swift-http-parser error)"
|
|
case .unknown:
|
|
return "unknown (http_parser error)"
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Errors that can be raised while parsing HTTP/1.1.
|
|
public enum HTTPParserError: Error {
|
|
case invalidCharactersUsed
|
|
case trailingGarbage
|
|
// from CHTTPParser
|
|
case invalidEOFState
|
|
case headerOverflow
|
|
case closedConnection
|
|
case invalidVersion
|
|
case invalidStatus
|
|
case invalidMethod
|
|
case invalidURL
|
|
|
|
@available(*, deprecated, message: "Cannot be thrown")
|
|
case invalidHost
|
|
|
|
@available(*, deprecated, message: "Cannot be thrown")
|
|
case invalidPort
|
|
|
|
@available(*, deprecated, message: "Cannot be thrown")
|
|
case invalidPath
|
|
|
|
@available(*, deprecated, message: "Cannot be thrown")
|
|
case invalidQueryString
|
|
|
|
@available(*, deprecated, message: "Cannot be thrown")
|
|
case invalidFragment
|
|
case lfExpected
|
|
case invalidHeaderToken
|
|
case invalidContentLength
|
|
case unexpectedContentLength
|
|
case invalidChunkSize
|
|
case invalidConstant
|
|
case invalidInternalState
|
|
case strictModeAssertion
|
|
case paused
|
|
case unknown
|
|
}
|
|
|
|
extension HTTPResponseStatus {
|
|
/// The numerical status code for a given HTTP response status.
|
|
public var code: UInt {
|
|
get {
|
|
switch self {
|
|
case .continue:
|
|
return 100
|
|
case .switchingProtocols:
|
|
return 101
|
|
case .processing:
|
|
return 102
|
|
case .ok:
|
|
return 200
|
|
case .created:
|
|
return 201
|
|
case .accepted:
|
|
return 202
|
|
case .nonAuthoritativeInformation:
|
|
return 203
|
|
case .noContent:
|
|
return 204
|
|
case .resetContent:
|
|
return 205
|
|
case .partialContent:
|
|
return 206
|
|
case .multiStatus:
|
|
return 207
|
|
case .alreadyReported:
|
|
return 208
|
|
case .imUsed:
|
|
return 226
|
|
case .multipleChoices:
|
|
return 300
|
|
case .movedPermanently:
|
|
return 301
|
|
case .found:
|
|
return 302
|
|
case .seeOther:
|
|
return 303
|
|
case .notModified:
|
|
return 304
|
|
case .useProxy:
|
|
return 305
|
|
case .temporaryRedirect:
|
|
return 307
|
|
case .permanentRedirect:
|
|
return 308
|
|
case .badRequest:
|
|
return 400
|
|
case .unauthorized:
|
|
return 401
|
|
case .paymentRequired:
|
|
return 402
|
|
case .forbidden:
|
|
return 403
|
|
case .notFound:
|
|
return 404
|
|
case .methodNotAllowed:
|
|
return 405
|
|
case .notAcceptable:
|
|
return 406
|
|
case .proxyAuthenticationRequired:
|
|
return 407
|
|
case .requestTimeout:
|
|
return 408
|
|
case .conflict:
|
|
return 409
|
|
case .gone:
|
|
return 410
|
|
case .lengthRequired:
|
|
return 411
|
|
case .preconditionFailed:
|
|
return 412
|
|
case .payloadTooLarge:
|
|
return 413
|
|
case .uriTooLong:
|
|
return 414
|
|
case .unsupportedMediaType:
|
|
return 415
|
|
case .rangeNotSatisfiable:
|
|
return 416
|
|
case .expectationFailed:
|
|
return 417
|
|
case .imATeapot:
|
|
return 418
|
|
case .misdirectedRequest:
|
|
return 421
|
|
case .unprocessableEntity:
|
|
return 422
|
|
case .locked:
|
|
return 423
|
|
case .failedDependency:
|
|
return 424
|
|
case .upgradeRequired:
|
|
return 426
|
|
case .preconditionRequired:
|
|
return 428
|
|
case .tooManyRequests:
|
|
return 429
|
|
case .requestHeaderFieldsTooLarge:
|
|
return 431
|
|
case .unavailableForLegalReasons:
|
|
return 451
|
|
case .internalServerError:
|
|
return 500
|
|
case .notImplemented:
|
|
return 501
|
|
case .badGateway:
|
|
return 502
|
|
case .serviceUnavailable:
|
|
return 503
|
|
case .gatewayTimeout:
|
|
return 504
|
|
case .httpVersionNotSupported:
|
|
return 505
|
|
case .variantAlsoNegotiates:
|
|
return 506
|
|
case .insufficientStorage:
|
|
return 507
|
|
case .loopDetected:
|
|
return 508
|
|
case .notExtended:
|
|
return 510
|
|
case .networkAuthenticationRequired:
|
|
return 511
|
|
case .custom(let code, reasonPhrase: _):
|
|
return code
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The string reason phrase for a given HTTP response status.
|
|
public var reasonPhrase: String {
|
|
get {
|
|
switch self {
|
|
case .continue:
|
|
return "Continue"
|
|
case .switchingProtocols:
|
|
return "Switching Protocols"
|
|
case .processing:
|
|
return "Processing"
|
|
case .ok:
|
|
return "OK"
|
|
case .created:
|
|
return "Created"
|
|
case .accepted:
|
|
return "Accepted"
|
|
case .nonAuthoritativeInformation:
|
|
return "Non-Authoritative Information"
|
|
case .noContent:
|
|
return "No Content"
|
|
case .resetContent:
|
|
return "Reset Content"
|
|
case .partialContent:
|
|
return "Partial Content"
|
|
case .multiStatus:
|
|
return "Multi-Status"
|
|
case .alreadyReported:
|
|
return "Already Reported"
|
|
case .imUsed:
|
|
return "IM Used"
|
|
case .multipleChoices:
|
|
return "Multiple Choices"
|
|
case .movedPermanently:
|
|
return "Moved Permanently"
|
|
case .found:
|
|
return "Found"
|
|
case .seeOther:
|
|
return "See Other"
|
|
case .notModified:
|
|
return "Not Modified"
|
|
case .useProxy:
|
|
return "Use Proxy"
|
|
case .temporaryRedirect:
|
|
return "Temporary Redirect"
|
|
case .permanentRedirect:
|
|
return "Permanent Redirect"
|
|
case .badRequest:
|
|
return "Bad Request"
|
|
case .unauthorized:
|
|
return "Unauthorized"
|
|
case .paymentRequired:
|
|
return "Payment Required"
|
|
case .forbidden:
|
|
return "Forbidden"
|
|
case .notFound:
|
|
return "Not Found"
|
|
case .methodNotAllowed:
|
|
return "Method Not Allowed"
|
|
case .notAcceptable:
|
|
return "Not Acceptable"
|
|
case .proxyAuthenticationRequired:
|
|
return "Proxy Authentication Required"
|
|
case .requestTimeout:
|
|
return "Request Timeout"
|
|
case .conflict:
|
|
return "Conflict"
|
|
case .gone:
|
|
return "Gone"
|
|
case .lengthRequired:
|
|
return "Length Required"
|
|
case .preconditionFailed:
|
|
return "Precondition Failed"
|
|
case .payloadTooLarge:
|
|
return "Payload Too Large"
|
|
case .uriTooLong:
|
|
return "URI Too Long"
|
|
case .unsupportedMediaType:
|
|
return "Unsupported Media Type"
|
|
case .rangeNotSatisfiable:
|
|
return "Range Not Satisfiable"
|
|
case .expectationFailed:
|
|
return "Expectation Failed"
|
|
case .imATeapot:
|
|
return "I'm a teapot"
|
|
case .misdirectedRequest:
|
|
return "Misdirected Request"
|
|
case .unprocessableEntity:
|
|
return "Unprocessable Entity"
|
|
case .locked:
|
|
return "Locked"
|
|
case .failedDependency:
|
|
return "Failed Dependency"
|
|
case .upgradeRequired:
|
|
return "Upgrade Required"
|
|
case .preconditionRequired:
|
|
return "Precondition Required"
|
|
case .tooManyRequests:
|
|
return "Too Many Requests"
|
|
case .requestHeaderFieldsTooLarge:
|
|
return "Request Header Fields Too Large"
|
|
case .unavailableForLegalReasons:
|
|
return "Unavailable For Legal Reasons"
|
|
case .internalServerError:
|
|
return "Internal Server Error"
|
|
case .notImplemented:
|
|
return "Not Implemented"
|
|
case .badGateway:
|
|
return "Bad Gateway"
|
|
case .serviceUnavailable:
|
|
return "Service Unavailable"
|
|
case .gatewayTimeout:
|
|
return "Gateway Timeout"
|
|
case .httpVersionNotSupported:
|
|
return "HTTP Version Not Supported"
|
|
case .variantAlsoNegotiates:
|
|
return "Variant Also Negotiates"
|
|
case .insufficientStorage:
|
|
return "Insufficient Storage"
|
|
case .loopDetected:
|
|
return "Loop Detected"
|
|
case .notExtended:
|
|
return "Not Extended"
|
|
case .networkAuthenticationRequired:
|
|
return "Network Authentication Required"
|
|
case .custom(code: _, reasonPhrase: let phrase):
|
|
return phrase
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A HTTP response status code.
|
|
public enum HTTPResponseStatus: Sendable {
|
|
// use custom if you want to use a non-standard response code or
|
|
// have it available in a (UInt, String) pair from a higher-level web framework.
|
|
case custom(code: UInt, reasonPhrase: String)
|
|
|
|
// all the codes from http://www.iana.org/assignments/http-status-codes
|
|
|
|
// 1xx
|
|
case `continue`
|
|
case switchingProtocols
|
|
case processing
|
|
// TODO: add '103: Early Hints' (requires bumping SemVer major).
|
|
|
|
// 2xx
|
|
case ok
|
|
case created
|
|
case accepted
|
|
case nonAuthoritativeInformation
|
|
case noContent
|
|
case resetContent
|
|
case partialContent
|
|
case multiStatus
|
|
case alreadyReported
|
|
case imUsed
|
|
|
|
// 3xx
|
|
case multipleChoices
|
|
case movedPermanently
|
|
case found
|
|
case seeOther
|
|
case notModified
|
|
case useProxy
|
|
case temporaryRedirect
|
|
case permanentRedirect
|
|
|
|
// 4xx
|
|
case badRequest
|
|
case unauthorized
|
|
case paymentRequired
|
|
case forbidden
|
|
case notFound
|
|
case methodNotAllowed
|
|
case notAcceptable
|
|
case proxyAuthenticationRequired
|
|
case requestTimeout
|
|
case conflict
|
|
case gone
|
|
case lengthRequired
|
|
case preconditionFailed
|
|
case payloadTooLarge
|
|
case uriTooLong
|
|
case unsupportedMediaType
|
|
case rangeNotSatisfiable
|
|
case expectationFailed
|
|
case imATeapot
|
|
case misdirectedRequest
|
|
case unprocessableEntity
|
|
case locked
|
|
case failedDependency
|
|
case upgradeRequired
|
|
case preconditionRequired
|
|
case tooManyRequests
|
|
case requestHeaderFieldsTooLarge
|
|
case unavailableForLegalReasons
|
|
|
|
// 5xx
|
|
case internalServerError
|
|
case notImplemented
|
|
case badGateway
|
|
case serviceUnavailable
|
|
case gatewayTimeout
|
|
case httpVersionNotSupported
|
|
case variantAlsoNegotiates
|
|
case insufficientStorage
|
|
case loopDetected
|
|
case notExtended
|
|
case networkAuthenticationRequired
|
|
|
|
/// Whether responses with this status code may have a response body.
|
|
public var mayHaveResponseBody: Bool {
|
|
switch self {
|
|
case .`continue`,
|
|
.switchingProtocols,
|
|
.processing,
|
|
.noContent,
|
|
.notModified,
|
|
.custom where (code < 200) && (code >= 100):
|
|
return false
|
|
default:
|
|
return true
|
|
}
|
|
}
|
|
|
|
/// Initialize a `HTTPResponseStatus` from a given status and reason.
|
|
///
|
|
/// - Parameter statusCode: The integer value of the HTTP response status code
|
|
/// - Parameter reasonPhrase: The textual reason phrase from the response. This will be
|
|
/// discarded in favor of the default if the `statusCode` matches one that we know.
|
|
public init(statusCode: Int, reasonPhrase: String = "") {
|
|
switch statusCode {
|
|
case 100:
|
|
self = .`continue`
|
|
case 101:
|
|
self = .switchingProtocols
|
|
case 102:
|
|
self = .processing
|
|
case 200:
|
|
self = .ok
|
|
case 201:
|
|
self = .created
|
|
case 202:
|
|
self = .accepted
|
|
case 203:
|
|
self = .nonAuthoritativeInformation
|
|
case 204:
|
|
self = .noContent
|
|
case 205:
|
|
self = .resetContent
|
|
case 206:
|
|
self = .partialContent
|
|
case 207:
|
|
self = .multiStatus
|
|
case 208:
|
|
self = .alreadyReported
|
|
case 226:
|
|
self = .imUsed
|
|
case 300:
|
|
self = .multipleChoices
|
|
case 301:
|
|
self = .movedPermanently
|
|
case 302:
|
|
self = .found
|
|
case 303:
|
|
self = .seeOther
|
|
case 304:
|
|
self = .notModified
|
|
case 305:
|
|
self = .useProxy
|
|
case 307:
|
|
self = .temporaryRedirect
|
|
case 308:
|
|
self = .permanentRedirect
|
|
case 400:
|
|
self = .badRequest
|
|
case 401:
|
|
self = .unauthorized
|
|
case 402:
|
|
self = .paymentRequired
|
|
case 403:
|
|
self = .forbidden
|
|
case 404:
|
|
self = .notFound
|
|
case 405:
|
|
self = .methodNotAllowed
|
|
case 406:
|
|
self = .notAcceptable
|
|
case 407:
|
|
self = .proxyAuthenticationRequired
|
|
case 408:
|
|
self = .requestTimeout
|
|
case 409:
|
|
self = .conflict
|
|
case 410:
|
|
self = .gone
|
|
case 411:
|
|
self = .lengthRequired
|
|
case 412:
|
|
self = .preconditionFailed
|
|
case 413:
|
|
self = .payloadTooLarge
|
|
case 414:
|
|
self = .uriTooLong
|
|
case 415:
|
|
self = .unsupportedMediaType
|
|
case 416:
|
|
self = .rangeNotSatisfiable
|
|
case 417:
|
|
self = .expectationFailed
|
|
case 418:
|
|
self = .imATeapot
|
|
case 421:
|
|
self = .misdirectedRequest
|
|
case 422:
|
|
self = .unprocessableEntity
|
|
case 423:
|
|
self = .locked
|
|
case 424:
|
|
self = .failedDependency
|
|
case 426:
|
|
self = .upgradeRequired
|
|
case 428:
|
|
self = .preconditionRequired
|
|
case 429:
|
|
self = .tooManyRequests
|
|
case 431:
|
|
self = .requestHeaderFieldsTooLarge
|
|
case 451:
|
|
self = .unavailableForLegalReasons
|
|
case 500:
|
|
self = .internalServerError
|
|
case 501:
|
|
self = .notImplemented
|
|
case 502:
|
|
self = .badGateway
|
|
case 503:
|
|
self = .serviceUnavailable
|
|
case 504:
|
|
self = .gatewayTimeout
|
|
case 505:
|
|
self = .httpVersionNotSupported
|
|
case 506:
|
|
self = .variantAlsoNegotiates
|
|
case 507:
|
|
self = .insufficientStorage
|
|
case 508:
|
|
self = .loopDetected
|
|
case 510:
|
|
self = .notExtended
|
|
case 511:
|
|
self = .networkAuthenticationRequired
|
|
default:
|
|
self = .custom(code: UInt(statusCode), reasonPhrase: reasonPhrase)
|
|
}
|
|
}
|
|
}
|
|
|
|
extension HTTPResponseStatus: Equatable {}
|
|
|
|
extension HTTPResponseStatus: Hashable {}
|
|
|
|
extension HTTPRequestHead: CustomStringConvertible {
|
|
public var description: String {
|
|
"HTTPRequestHead { method: \(self.method), uri: \"\(self.uri)\", version: \(self.version), headers: \(self.headers) }"
|
|
}
|
|
}
|
|
|
|
extension HTTPResponseStatus: CustomStringConvertible {
|
|
public var description: String {
|
|
"\(self.code) \(self.reasonPhrase)"
|
|
}
|
|
}
|
|
|
|
extension HTTPResponseHead: CustomStringConvertible {
|
|
public var description: String {
|
|
"HTTPResponseHead { version: \(self.version), status: \(self.status), headers: \(self.headers) }"
|
|
}
|
|
}
|
|
|
|
extension HTTPVersion: CustomStringConvertible {
|
|
public var description: String {
|
|
"HTTP/\(self.major).\(self.minor)"
|
|
}
|
|
}
|
|
|
|
extension HTTPMethod: RawRepresentable {
|
|
public var rawValue: String {
|
|
switch self {
|
|
case .GET:
|
|
return "GET"
|
|
case .PUT:
|
|
return "PUT"
|
|
case .ACL:
|
|
return "ACL"
|
|
case .HEAD:
|
|
return "HEAD"
|
|
case .POST:
|
|
return "POST"
|
|
case .COPY:
|
|
return "COPY"
|
|
case .LOCK:
|
|
return "LOCK"
|
|
case .MOVE:
|
|
return "MOVE"
|
|
case .BIND:
|
|
return "BIND"
|
|
case .LINK:
|
|
return "LINK"
|
|
case .PATCH:
|
|
return "PATCH"
|
|
case .TRACE:
|
|
return "TRACE"
|
|
case .MKCOL:
|
|
return "MKCOL"
|
|
case .MERGE:
|
|
return "MERGE"
|
|
case .PURGE:
|
|
return "PURGE"
|
|
case .NOTIFY:
|
|
return "NOTIFY"
|
|
case .SEARCH:
|
|
return "SEARCH"
|
|
case .UNLOCK:
|
|
return "UNLOCK"
|
|
case .REBIND:
|
|
return "REBIND"
|
|
case .UNBIND:
|
|
return "UNBIND"
|
|
case .REPORT:
|
|
return "REPORT"
|
|
case .DELETE:
|
|
return "DELETE"
|
|
case .UNLINK:
|
|
return "UNLINK"
|
|
case .CONNECT:
|
|
return "CONNECT"
|
|
case .MSEARCH:
|
|
return "MSEARCH"
|
|
case .OPTIONS:
|
|
return "OPTIONS"
|
|
case .PROPFIND:
|
|
return "PROPFIND"
|
|
case .CHECKOUT:
|
|
return "CHECKOUT"
|
|
case .PROPPATCH:
|
|
return "PROPPATCH"
|
|
case .SUBSCRIBE:
|
|
return "SUBSCRIBE"
|
|
case .MKCALENDAR:
|
|
return "MKCALENDAR"
|
|
case .MKACTIVITY:
|
|
return "MKACTIVITY"
|
|
case .UNSUBSCRIBE:
|
|
return "UNSUBSCRIBE"
|
|
case .SOURCE:
|
|
return "SOURCE"
|
|
case let .RAW(value):
|
|
return value
|
|
}
|
|
}
|
|
|
|
public init(rawValue: String) {
|
|
switch rawValue {
|
|
case "GET":
|
|
self = .GET
|
|
case "PUT":
|
|
self = .PUT
|
|
case "ACL":
|
|
self = .ACL
|
|
case "HEAD":
|
|
self = .HEAD
|
|
case "POST":
|
|
self = .POST
|
|
case "COPY":
|
|
self = .COPY
|
|
case "LOCK":
|
|
self = .LOCK
|
|
case "MOVE":
|
|
self = .MOVE
|
|
case "BIND":
|
|
self = .BIND
|
|
case "LINK":
|
|
self = .LINK
|
|
case "PATCH":
|
|
self = .PATCH
|
|
case "TRACE":
|
|
self = .TRACE
|
|
case "MKCOL":
|
|
self = .MKCOL
|
|
case "MERGE":
|
|
self = .MERGE
|
|
case "PURGE":
|
|
self = .PURGE
|
|
case "NOTIFY":
|
|
self = .NOTIFY
|
|
case "SEARCH":
|
|
self = .SEARCH
|
|
case "UNLOCK":
|
|
self = .UNLOCK
|
|
case "REBIND":
|
|
self = .REBIND
|
|
case "UNBIND":
|
|
self = .UNBIND
|
|
case "REPORT":
|
|
self = .REPORT
|
|
case "DELETE":
|
|
self = .DELETE
|
|
case "UNLINK":
|
|
self = .UNLINK
|
|
case "CONNECT":
|
|
self = .CONNECT
|
|
case "MSEARCH":
|
|
self = .MSEARCH
|
|
case "OPTIONS":
|
|
self = .OPTIONS
|
|
case "PROPFIND":
|
|
self = .PROPFIND
|
|
case "CHECKOUT":
|
|
self = .CHECKOUT
|
|
case "PROPPATCH":
|
|
self = .PROPPATCH
|
|
case "SUBSCRIBE":
|
|
self = .SUBSCRIBE
|
|
case "MKCALENDAR":
|
|
self = .MKCALENDAR
|
|
case "MKACTIVITY":
|
|
self = .MKACTIVITY
|
|
case "UNSUBSCRIBE":
|
|
self = .UNSUBSCRIBE
|
|
case "SOURCE":
|
|
self = .SOURCE
|
|
default:
|
|
self = .RAW(value: rawValue)
|
|
}
|
|
}
|
|
}
|
|
|
|
extension HTTPResponseHead {
|
|
internal var contentLength: Int? {
|
|
headers.contentLength
|
|
}
|
|
}
|
|
|
|
extension HTTPRequestHead {
|
|
internal var contentLength: Int? {
|
|
headers.contentLength
|
|
}
|
|
}
|
|
|
|
extension HTTPHeaders {
|
|
internal var contentLength: Int? {
|
|
self.first(name: "content-length").flatMap { Int($0) }
|
|
}
|
|
}
|