Function getNamefromData has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

    static func getNamefromData(_ data: Data, offset: Int, base: Int = 0) -> (String, Int) {
        let scanner = BinaryDataScanner(data: data, littleEndian: false)
        scanner.skip(to: offset)

        var len: UInt8 = 0

• Read up
  Read up

Function readCallback has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

    private func readCallback(data: Data?) {
        guard !cancelled else {
            return
        }

• Read up
  Read up

Function getNamefromData has 34 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    static func getNamefromData(_ data: Data, offset: Int, base: Int = 0) -> (String, Int) {
        let scanner = BinaryDataScanner(data: data, littleEndian: false)
        scanner.skip(to: offset)

        var len: UInt8 = 0

Function getCrypto has 34 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        private func getCrypto(_ operation: CryptoOperation) -> StreamCryptoProtocol {
            switch algorithm {
            case .AES128CFB, .AES192CFB, .AES256CFB:
                switch operation {
                case .decrypt:

Function didRead has 34 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    override public func didRead(data: Data, from: RawTCPSocketProtocol) {
        super.didRead(data: data, from: from)
        
        let result: HTTPStreamScanner.Result
        do {

Function didReceive has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

    open func didReceive(rawResponse: Data) {
        guard let message = DNSMessage(payload: rawResponse) else {
            DDLogError("Failed to parse response from remote DNS server.")
            return
        }

• Read up
  Read up

Function parseServerAdapterFactory has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

    static func parseServerAdapterFactory(_ config: Yaml, type: HTTPAuthenticationAdapterFactory.Type) throws -> ServerAdapterFactory {
        guard let host = config["host"].string else {
            throw ConfigurationParserError.adapterParsingError(errorInfo: "Host (host) is required.")
        }

• Read up
  Read up

Function outputSession has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    fileprivate func outputSession(_ session: DNSSession) {
        guard let result = session.matchResult else {
            return
        }

Function spec has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    override func spec() {
        let testCases: [(String, Bool, String?, String?, Int?, String)] = [
            ("http://google.com/ncr", true, "http", "google.com", nil, "ncr"),
            ("http://google.com/", true, "http", "google.com", nil, ""),
            ("http://google.com:8080/", true, "http", "google.com", 8080, ""),

Function checkReadData has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    fileprivate func checkReadData() {
        if pendingReadData.count > 0 {
            queueCall {
                guard self.reading else {
                    // no queued read request

Function parseAdapterFactoryManager has 29 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    static func parseAdapterFactoryManager(_ config: Yaml) throws -> AdapterFactoryManager {
        var factoryDict: [String: AdapterFactory] = [:]
        factoryDict["direct"] = DirectAdapterFactory()
        guard let adapterConfigs = config.array else {
            throw ConfigurationParserError.noAdapterDefined

Function buildMessage has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    func buildMessage() -> Bool {
        payload = Data(count: bytesLength)
        if transactionID == 0 {
            transactionID = UInt16(arc4random_uniform(UInt32(UInt16.max)))
        }

Function rewritePacket has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    public func rewritePacket(packet: IPMutablePacket) -> IPMutablePacket? {
        // Support only TCP as for now
        guard packet.proto == .TCP else {
            return nil
        }

• Read up
  Read up

Function rewritePacket has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public func rewritePacket(packet: IPMutablePacket) -> IPMutablePacket? {
        // Support only TCP as for now
        guard packet.proto == .TCP else {
            return nil
        }

Function didReceive has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    open func didReceive(rawResponse: Data) {
        guard let message = DNSMessage(payload: rawResponse) else {
            DDLogError("Failed to parse response from remote DNS server.")
            return
        }

Function readAndProcessPackets has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    func readAndProcessPackets() {
        NetworkInterface.TunnelProvider.packetFlow.readPacketsWithCompletionHandler() {
            var outputPackets = [IPMutablePacket]()
            let packets = $0.0.map { data in
                IPMutablePacket(payload: data)

Function readAndProcessPackets has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    func readAndProcessPackets() {
        NetworkInterface.TunnelProvider.packetFlow.readPacketsWithCompletionHandler() {
            var outputPackets = [IPMutablePacket]()
            let packets = $0.0.map { data in
                IPMutablePacket(payload: data)

• Read up
  Read up

Function findSocket has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    fileprivate func findSocket(connectInfo: ConnectInfo?, socket: NWUDPSocket?) -> (ConnectInfo, NWUDPSocket)? {
        var result: (ConnectInfo, NWUDPSocket)?

        queue.sync {
            if connectInfo != nil {

• Read up
  Read up

Function writeAllRecordAt has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    fileprivate func writeAllRecordAt(_ at: Int) -> Bool {
        var position = at
        for query in queries {
            guard writeDNSQuery(query, at: position) else {
                return false

• Read up
  Read up

Function input has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

            public override func input(data: Data) throws {
                if readingFakeHeader {
                    buffer.append(data: data)
                    if buffer.get(to: Utils.HTTPData.DoubleCRLF) != nil {
                        readingFakeHeader = false

• Read up
  Read up