mirror of
https://github.com/apple/swift-nio.git
synced 2026-05-20 20:30:36 +00:00
aryan-25
a1605a3303
### Motivation:
Swift does not currently generic specialize static methods on final
classes that have no parent classes when the method is implemented in a
protocol. This means that calling such methods through `Self` will not
involve a generic specialization, whereas using the explicit type name
will.
This pattern manifests in the `[un]wrap{In}{Out}bound{In}{Out}` static
methods defined in the
[`ChannelInboundHandler`](https://github.com/apple/swift-nio/blob/27146d484478b1bb0f150e848758f3a34ed9cbd0/Sources/NIOCore/TypeAssistedChannelHandler.swift#L60)
and
[`ChannelOutboundHandler`](https://github.com/apple/swift-nio/blob/27146d484478b1bb0f150e848758f3a34ed9cbd0/Sources/NIOCore/TypeAssistedChannelHandler.swift#L95)
protocols and their use from all channel handler classes. As such, we
should replace the `Self` part in all
`Self.[un]wrap{In}{Out}bound{In}{Out}` calls with the explicit class
name.
### Modifications:
Replaced all `Self.[un]wrap{In}{Out}bound{In}{Out}` calls to use the
explicit class name.
### Result:
Eliminates unnecessary overhead.
77 lines
3.3 KiB
Swift
77 lines
3.3 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
|
|
|
|
/// A simple channel handler that catches errors emitted by parsing HTTP requests
|
|
/// and sends 400 Bad Request responses.
|
|
///
|
|
/// This channel handler provides the basic behaviour that the majority of simple HTTP
|
|
/// servers want. This handler does not suppress the parser errors: it allows them to
|
|
/// continue to pass through the pipeline so that other handlers (e.g. logging ones) can
|
|
/// deal with the error.
|
|
public final class HTTPServerProtocolErrorHandler: ChannelDuplexHandler, RemovableChannelHandler {
|
|
public typealias InboundIn = HTTPServerRequestPart
|
|
public typealias InboundOut = HTTPServerRequestPart
|
|
public typealias OutboundIn = HTTPServerResponsePart
|
|
public typealias OutboundOut = HTTPServerResponsePart
|
|
|
|
private var hasUnterminatedResponse: Bool = false
|
|
|
|
public init() {}
|
|
|
|
public func errorCaught(context: ChannelHandlerContext, error: Error) {
|
|
guard error is HTTPParserError else {
|
|
context.fireErrorCaught(error)
|
|
return
|
|
}
|
|
|
|
// Any HTTPParserError is automatically fatal, and we don't actually need (or want) to
|
|
// provide that error to the client: we just want to tell it that it screwed up and then
|
|
// let the rest of the pipeline shut the door in its face. However, we can only send an
|
|
// HTTP error response if another response hasn't started yet.
|
|
//
|
|
// A side note here: we cannot block or do any delayed work. ByteToMessageDecoder is going
|
|
// to come along and close the channel right after we return from this function.
|
|
if !self.hasUnterminatedResponse {
|
|
let headers = HTTPHeaders([("Connection", "close"), ("Content-Length", "0")])
|
|
let head = HTTPResponseHead(version: .http1_1, status: .badRequest, headers: headers)
|
|
context.write(HTTPServerProtocolErrorHandler.wrapOutboundOut(.head(head)), promise: nil)
|
|
context.writeAndFlush(HTTPServerProtocolErrorHandler.wrapOutboundOut(.end(nil)), promise: nil)
|
|
}
|
|
|
|
// Now pass the error on in case someone else wants to see it.
|
|
context.fireErrorCaught(error)
|
|
}
|
|
|
|
public func write(context: ChannelHandlerContext, data: NIOAny, promise: EventLoopPromise<Void>?) {
|
|
let res = HTTPServerProtocolErrorHandler.unwrapOutboundIn(data)
|
|
switch res {
|
|
case .head(let head) where head.isInformational:
|
|
precondition(!self.hasUnterminatedResponse)
|
|
case .head:
|
|
precondition(!self.hasUnterminatedResponse)
|
|
self.hasUnterminatedResponse = true
|
|
case .body:
|
|
precondition(self.hasUnterminatedResponse)
|
|
case .end:
|
|
precondition(self.hasUnterminatedResponse)
|
|
self.hasUnterminatedResponse = false
|
|
}
|
|
context.write(data, promise: promise)
|
|
}
|
|
}
|
|
|
|
@available(*, unavailable)
|
|
extension HTTPServerProtocolErrorHandler: Sendable {}
|