iOS/Pods/Alamofire/Source/Validation.swift

   1 //
   2 //  Validation.swift
   3 //
   4 //  Copyright (c) 2014-2017 Alamofire Software Foundation (http://alamofire.org/)
   5 //
   6 //  Permission is hereby granted, free of charge, to any person obtaining a copy
   7 //  of this software and associated documentation files (the "Software"), to deal
   8 //  in the Software without restriction, including without limitation the rights
   9 //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10 //  copies of the Software, and to permit persons to whom the Software is
  11 //  furnished to do so, subject to the following conditions:
  12 //
  13 //  The above copyright notice and this permission notice shall be included in
  14 //  all copies or substantial portions of the Software.
  15 //
  16 //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17 //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18 //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19 //  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20 //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22 //  THE SOFTWARE.
  23 //
  24
  25 import Foundation
  26
  27 extension Request {
  28
  29     // MARK: Helper Types
  30
  31     fileprivate typealias ErrorReason = AFError.ResponseValidationFailureReason
  32
  33     /// Used to represent whether validation was successful or encountered an error resulting in a failure.
  34     ///
  35     /// - success: The validation was successful.
  36     /// - failure: The validation failed encountering the provided error.
  37     public enum ValidationResult {
  38         case success
  39         case failure(Error)
  40     }
  41
  42     fileprivate struct MIMEType {
  43         let type: String
  44         let subtype: String
  45
  46         var isWildcard: Bool { return type == "*" && subtype == "*" }
  47
  48         init?(_ string: String) {
  49             let components: [String] = {
  50                 let stripped = string.trimmingCharacters(in: .whitespacesAndNewlines)
  51
  52             #if swift(>=3.2)
  53                 let split = stripped[..<(stripped.range(of: ";")?.lowerBound ?? stripped.endIndex)]
  54             #else
  55                 let split = stripped.substring(to: stripped.range(of: ";")?.lowerBound ?? stripped.endIndex)
  56             #endif
  57
  58                 return split.components(separatedBy: "/")
  59             }()
  60
  61             if let type = components.first, let subtype = components.last {
  62                 self.type = type
  63                 self.subtype = subtype
  64             } else {
  65                 return nil
  66             }
  67         }
  68
  69         func matches(_ mime: MIMEType) -> Bool {
  70             switch (type, subtype) {
  71             case (mime.type, mime.subtype), (mime.type, "*"), ("*", mime.subtype), ("*", "*"):
  72                 return true
  73             default:
  74                 return false
  75             }
  76         }
  77     }
  78
  79     // MARK: Properties
  80
  81     fileprivate var acceptableStatusCodes: [Int] { return Array(200..<300) }
  82
  83     fileprivate var acceptableContentTypes: [String] {
  84         if let accept = request?.value(forHTTPHeaderField: "Accept") {
  85             return accept.components(separatedBy: ",")
  86         }
  87
  88         return ["*/*"]
  89     }
  90
  91     // MARK: Status Code
  92
  93     fileprivate func validate<S: Sequence>(
  94         statusCode acceptableStatusCodes: S,
  95         response: HTTPURLResponse)
  96         -> ValidationResult
  97         where S.Iterator.Element == Int
  98     {
  99         if acceptableStatusCodes.contains(response.statusCode) {
 100             return .success
 101         } else {
 102             let reason: ErrorReason = .unacceptableStatusCode(code: response.statusCode)
 103             return .failure(AFError.responseValidationFailed(reason: reason))
 104         }
 105     }
 106
 107     // MARK: Content Type
 108
 109     fileprivate func validate<S: Sequence>(
 110         contentType acceptableContentTypes: S,
 111         response: HTTPURLResponse,
 112         data: Data?)
 113         -> ValidationResult
 114         where S.Iterator.Element == String
 115     {
 116         guard let data = data, data.count > 0 else { return .success }
 117
 118         guard
 119             let responseContentType = response.mimeType,
 120             let responseMIMEType = MIMEType(responseContentType)
 121         else {
 122             for contentType in acceptableContentTypes {
 123                 if let mimeType = MIMEType(contentType), mimeType.isWildcard {
 124                     return .success
 125                 }
 126             }
 127
 128             let error: AFError = {
 129                 let reason: ErrorReason = .missingContentType(acceptableContentTypes: Array(acceptableContentTypes))
 130                 return AFError.responseValidationFailed(reason: reason)
 131             }()
 132
 133             return .failure(error)
 134         }
 135
 136         for contentType in acceptableContentTypes {
 137             if let acceptableMIMEType = MIMEType(contentType), acceptableMIMEType.matches(responseMIMEType) {
 138                 return .success
 139             }
 140         }
 141
 142         let error: AFError = {
 143             let reason: ErrorReason = .unacceptableContentType(
 144                 acceptableContentTypes: Array(acceptableContentTypes),
 145                 responseContentType: responseContentType
 146             )
 147
 148             return AFError.responseValidationFailed(reason: reason)
 149         }()
 150
 151         return .failure(error)
 152     }
 153 }
 154
 155 // MARK: -
 156
 157 extension DataRequest {
 158     /// A closure used to validate a request that takes a URL request, a URL response and data, and returns whether the
 159     /// request was valid.
 160     public typealias Validation = (URLRequest?, HTTPURLResponse, Data?) -> ValidationResult
 161
 162     /// Validates the request, using the specified closure.
 163     ///
 164     /// If validation fails, subsequent calls to response handlers will have an associated error.
 165     ///
 166     /// - parameter validation: A closure to validate the request.
 167     ///
 168     /// - returns: The request.
 169     @discardableResult
 170     public func validate(_ validation: @escaping Validation) -> Self {
 171         let validationExecution: () -> Void = { [unowned self] in
 172             if
 173                 let response = self.response,
 174                 self.delegate.error == nil,
 175                 case let .failure(error) = validation(self.request, response, self.delegate.data)
 176             {
 177                 self.delegate.error = error
 178             }
 179         }
 180
 181         validations.append(validationExecution)
 182
 183         return self
 184     }
 185
 186     /// Validates that the response has a status code in the specified sequence.
 187     ///
 188     /// If validation fails, subsequent calls to response handlers will have an associated error.
 189     ///
 190     /// - parameter range: The range of acceptable status codes.
 191     ///
 192     /// - returns: The request.
 193     @discardableResult
 194     public func validate<S: Sequence>(statusCode acceptableStatusCodes: S) -> Self where S.Iterator.Element == Int {
 195         return validate { [unowned self] _, response, _ in
 196             return self.validate(statusCode: acceptableStatusCodes, response: response)
 197         }
 198     }
 199
 200     /// Validates that the response has a content type in the specified sequence.
 201     ///
 202     /// If validation fails, subsequent calls to response handlers will have an associated error.
 203     ///
 204     /// - parameter contentType: The acceptable content types, which may specify wildcard types and/or subtypes.
 205     ///
 206     /// - returns: The request.
 207     @discardableResult
 208     public func validate<S: Sequence>(contentType acceptableContentTypes: S) -> Self where S.Iterator.Element == String {
 209         return validate { [unowned self] _, response, data in
 210             return self.validate(contentType: acceptableContentTypes, response: response, data: data)
 211         }
 212     }
 213
 214     /// Validates that the response has a status code in the default acceptable range of 200...299, and that the content
 215     /// type matches any specified in the Accept HTTP header field.
 216     ///
 217     /// If validation fails, subsequent calls to response handlers will have an associated error.
 218     ///
 219     /// - returns: The request.
 220     @discardableResult
 221     public func validate() -> Self {
 222         return validate(statusCode: self.acceptableStatusCodes).validate(contentType: self.acceptableContentTypes)
 223     }
 224 }
 225
 226 // MARK: -
 227
 228 extension DownloadRequest {
 229     /// A closure used to validate a request that takes a URL request, a URL response, a temporary URL and a
 230     /// destination URL, and returns whether the request was valid.
 231     public typealias Validation = (
 232         _ request: URLRequest?,
 233         _ response: HTTPURLResponse,
 234         _ temporaryURL: URL?,
 235         _ destinationURL: URL?)
 236         -> ValidationResult
 237
 238     /// Validates the request, using the specified closure.
 239     ///
 240     /// If validation fails, subsequent calls to response handlers will have an associated error.
 241     ///
 242     /// - parameter validation: A closure to validate the request.
 243     ///
 244     /// - returns: The request.
 245     @discardableResult
 246     public func validate(_ validation: @escaping Validation) -> Self {
 247         let validationExecution: () -> Void = { [unowned self] in
 248             let request = self.request
 249             let temporaryURL = self.downloadDelegate.temporaryURL
 250             let destinationURL = self.downloadDelegate.destinationURL
 251
 252             if
 253                 let response = self.response,
 254                 self.delegate.error == nil,
 255                 case let .failure(error) = validation(request, response, temporaryURL, destinationURL)
 256             {
 257                 self.delegate.error = error
 258             }
 259         }
 260
 261         validations.append(validationExecution)
 262
 263         return self
 264     }
 265
 266     /// Validates that the response has a status code in the specified sequence.
 267     ///
 268     /// If validation fails, subsequent calls to response handlers will have an associated error.
 269     ///
 270     /// - parameter range: The range of acceptable status codes.
 271     ///
 272     /// - returns: The request.
 273     @discardableResult
 274     public func validate<S: Sequence>(statusCode acceptableStatusCodes: S) -> Self where S.Iterator.Element == Int {
 275         return validate { [unowned self] _, response, _, _ in
 276             return self.validate(statusCode: acceptableStatusCodes, response: response)
 277         }
 278     }
 279
 280     /// Validates that the response has a content type in the specified sequence.
 281     ///
 282     /// If validation fails, subsequent calls to response handlers will have an associated error.
 283     ///
 284     /// - parameter contentType: The acceptable content types, which may specify wildcard types and/or subtypes.
 285     ///
 286     /// - returns: The request.
 287     @discardableResult
 288     public func validate<S: Sequence>(contentType acceptableContentTypes: S) -> Self where S.Iterator.Element == String {
 289         return validate { [unowned self] _, response, _, _ in
 290             let fileURL = self.downloadDelegate.fileURL
 291
 292             guard let validFileURL = fileURL else {
 293                 return .failure(AFError.responseValidationFailed(reason: .dataFileNil))
 294             }
 295
 296             do {
 297                 let data = try Data(contentsOf: validFileURL)
 298                 return self.validate(contentType: acceptableContentTypes, response: response, data: data)
 299             } catch {
 300                 return .failure(AFError.responseValidationFailed(reason: .dataFileReadFailed(at: validFileURL)))
 301             }
 302         }
 303     }
 304
 305     /// Validates that the response has a status code in the default acceptable range of 200...299, and that the content
 306     /// type matches any specified in the Accept HTTP header field.
 307     ///
 308     /// If validation fails, subsequent calls to response handlers will have an associated error.
 309     ///
 310     /// - returns: The request.
 311     @discardableResult
 312     public func validate() -> Self {
 313         return validate(statusCode: self.acceptableStatusCodes).validate(contentType: self.acceptableContentTypes)
 314     }
 315 }