redhound 1.0.1 → 2.0.0.rc2

data/lib/redhound/capture/linux/packet_socket.rb

@@ -0,0 +1,224 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Redhound
+  # @api private
+  module Capture
+    # @api private
+    module Linux
+      # @api private
+      class PacketSocket < Source
+        attr_reader :socket, :linktype, :interfaces
+
+        # @rbs (interface: String | Integer | Interface, ?snaplen: Integer, ?promiscuous: bool, ?buffer_size: Integer?, ?direction: Symbol, ?filter: String?) -> void
+        def initialize(interface:, snaplen: 262_144, promiscuous: true, buffer_size: nil, direction: :inout, filter: nil)
+          super()
+          raise ArgumentError, 'snaplen must be between 1 and 16 MiB' unless snaplen.between?(1, File::Format::MAX_RECORD)
+          raise ArgumentError, 'direction must be in, out or inout' unless %i[in out inout].include?(direction)
+
+          @interface = interface.is_a?(Interface) ? interface : Interface.find(interface)
+          @interfaces = [@interface]
+          @snaplen, @direction = snaplen, direction
+          @linktype = @interface.linktype
+          @cooked = @linktype == 276
+          @socket = ::Socket.new(Constants::AF_PACKET, @cooked ? ::Socket::SOCK_DGRAM : ::Socket::SOCK_RAW, 0)
+          @interface_drops = interface_dropped
+          setup_receive_buffer(buffer_size)
+          attach_filter(filter ? Filter.compile(filter, linktype: @linktype, snaplen:, live: true) : nil)
+          if promiscuous && @interface.name == 'any'
+            warn 'redhound: promiscuous mode is unavailable on any'
+          elsif promiscuous
+            @socket.setsockopt(Constants::SOL_PACKET, Constants::PACKET_ADD_MEMBERSHIP, [@interface.index, Constants::PACKET_MR_PROMISC, 0, ''.b].pack('i S S a8'))
+          end
+          @socket.bind(SockaddrLL.new(index: @interface.index).to_sockaddr)
+          prime_timestamp
+          warn_vlan_offload
+          if direction == :in
+            begin
+              @socket.setsockopt(Constants::SOL_PACKET, Constants::PACKET_IGNORE_OUTGOING, [1].pack('i'))
+            rescue Errno::ENOPROTOOPT, Errno::EINVAL
+              # Older kernels are filtered by packet direction below.
+            end
+          end
+        rescue Errno::EPERM, Errno::EACCES => error
+          close_resources
+          raise PermissionDenied, "capture requires root or CAP_NET_RAW: #{error.message}"
+        rescue StandardError
+          close_resources
+          raise
+        end
+
+        # @rbs (?timeout: Numeric?) -> Packet?
+        def next_packet(timeout: nil)
+          deadline = deadline_for(timeout)
+          polled = false
+          until @stopped || @closed
+            return nil if polled && deadline && Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+            polled = true
+            result = @socket.recvfrom_nonblock(Constants::RECEIVE_SIZE, exception: false)
+            if result == :wait_readable
+              return nil unless wait_readable(@socket, deadline)
+
+              next
+            end
+
+            data, address_info = result
+            address = SockaddrLL.parse(address_info.to_sockaddr)
+            next unless accept_direction?(address)
+
+            original_length = data.bytesize
+            data = Cooked.header(address) + data if @cooked
+            original_length += 20 if @cooked
+            timestamp_ns = timestamp
+            meta = { pkttype: address.pkttype, csum_not_ready: address.hatype == 772 || address.pkttype == Constants::PACKET_OUTGOING }
+            meta[:possible_truncation] = true if original_length >= Constants::RECEIVE_SIZE + (@cooked ? 20 : 0)
+            @number += 1
+            @capture_stats.captured += 1
+            return Packet.new(data.byteslice(0, @snaplen), timestamp_ns:, original_length:, linktype: @linktype,
+                              interface: packet_interface(address), direction: address.pkttype == Constants::PACKET_OUTGOING ? :out : :in, number: @number, meta:)
+          end
+          nil
+        end
+
+        # @rbs (untyped program) -> void
+        def attach_filter(program)
+          instructions = program ? program.instructions : [[0x06, 0, 0, receive_snaplen]] #: Array[[Integer, Integer, Integer, Integer]]
+          Filter::BPF::Validator.validate!(instructions)
+          instructions = receive_filter(instructions)
+          packed = instructions.map { |instruction| instruction.pack('S C C L') }.join
+          @socket.setsockopt(::Socket::SOL_SOCKET, Constants::SO_ATTACH_FILTER, [instructions.size, packed].pack('S x6 P'))
+        end
+
+        # @rbs () -> Stats
+        def stats
+          unless @closed
+            counters = @socket.getsockopt(Constants::SOL_PACKET, Constants::PACKET_STATISTICS).data.unpack('L*')
+            @capture_stats.received += counters.fetch(0, 0)
+            @capture_stats.dropped += counters.fetch(1, 0)
+            @capture_stats.freeze_count += counters.fetch(2, 0)
+            @capture_stats.if_dropped = [interface_dropped - @interface_drops, 0].max
+          end
+          @capture_stats
+        end
+
+        # @rbs () -> void
+        def close
+          return if @closed
+
+          begin
+            stats
+          ensure
+            super
+            close_resources
+          end
+        end
+
+        protected
+
+        # Positive filter returns select packets; the source applies its configured snaplen.
+        # @rbs (Array[[Integer, Integer, Integer, Integer]] instructions) -> Array[[Integer, Integer, Integer, Integer]]
+        def receive_filter(instructions)
+          unless instructions.any? { |instruction| instruction[0] == 0x16 }
+            return instructions.map do |code, jt, jf, k|
+              [code, jt, jf, code == 0x06 && k.positive? ? receive_snaplen : k]
+            end
+          end
+
+          assembler = Filter::BPF::Assembler.new
+          labels = instructions.map { assembler.label }
+          accepted, rejected = assembler.label, assembler.label
+          instructions.each_with_index do |(code, jt, jf, k), index|
+            assembler.mark(labels.fetch(index))
+            if code == 0x16
+              assembler.branch(0x15, 0, rejected, accepted)
+            elsif code == 5
+              assembler.jump(labels.fetch(index + 1 + k))
+            elsif Filter::BPF::Validator::JUMPS.include?(code)
+              assembler.branch(code, k, labels.fetch(index + 1 + jt), labels.fetch(index + 1 + jf))
+            else
+              assembler.emit(code, code == 6 && k.positive? ? receive_snaplen : k)
+            end
+          end
+          assembler.mark(accepted)
+          assembler.emit(6, receive_snaplen)
+          assembler.mark(rejected)
+          assembler.emit(6, 0)
+          result = assembler.assemble
+          Filter::BPF::Validator.validate!(result)
+          result
+        end
+
+        # @rbs () -> void
+        def warn_vlan_offload
+          return unless instance_of?(PacketSocket) && [1, 276].include?(@linktype) && !@interface.loopback?
+
+          name = @interface.name == 'any' ? '<interface>' : @interface.name
+          warn "redhound: socket capture cannot restore stripped VLAN tags; disable receive VLAN offload with ethtool -K #{name} rxvlan off on the receiving interface"
+        end
+
+        # @rbs () -> void
+        def close_resources
+          @socket.close if @socket && !@socket.closed?
+        end
+
+        # @rbs () -> void
+        def prime_timestamp
+          @socket.ioctl(Constants::SIOCGSTAMPNS, "\0" * 16)
+        rescue Errno::ENOENT, Errno::ENOTTY, Errno::EINVAL
+          nil
+        end
+
+        # @rbs () -> Integer
+        def receive_snaplen = Constants::RECEIVE_SIZE
+
+        # @rbs (Integer? buffer_size) -> void
+        def setup_receive_buffer(buffer_size)
+          return unless buffer_size
+          raise ArgumentError, 'buffer size must be positive' unless buffer_size.positive?
+
+          @socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_RCVBUF, [buffer_size].pack('i'))
+          begin
+            @socket.setsockopt(::Socket::SOL_SOCKET, Constants::SO_RCVBUFFORCE, [buffer_size].pack('i'))
+          rescue Errno::EPERM, Errno::EACCES, Errno::ENOPROTOOPT => error
+            warn "redhound: SO_RCVBUFFORCE unavailable (#{error.message}); using SO_RCVBUF with the system limit"
+          end
+        end
+
+        # @rbs (SockaddrLL address) -> bool
+        def accept_direction?(address)
+          outgoing = address.pkttype == Constants::PACKET_OUTGOING
+          return false if outgoing && address.hatype == 772 && @direction != :out
+
+          @direction == :inout || (@direction == :out) == outgoing
+        end
+
+        # @rbs (SockaddrLL address) -> Interface
+        def packet_interface(address)
+          return @interface unless @interface.name == 'any'
+
+          @any_interfaces ||= Interface.all.to_h { |interface| [interface.index, interface] }
+          @any_interfaces.fetch(address.index) { Interface.new(name: "if#{address.index}", index: address.index, linktype: 276) }
+        end
+
+        # @rbs () -> Integer
+        def interface_dropped
+          return 0 if @interface.name == 'any'
+
+          ::File.read("/sys/class/net/#{@interface.name}/statistics/rx_dropped").to_i
+        rescue Errno::ENOENT, Errno::EACCES
+          0
+        end
+
+        # @rbs () -> Integer
+        def timestamp
+          buffer = "\0" * 16
+          @socket.ioctl(Constants::SIOCGSTAMPNS, buffer)
+          seconds, nanos = buffer.unpack('q q') #: [Integer, Integer]
+          seconds * 1_000_000_000 + nanos
+        rescue Errno::ENOENT, Errno::ENOTTY, Errno::EINVAL
+          Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
+        end
+      end
+    end
+  end
+end

data/lib/redhound/capture/linux/sockaddr_ll.rb

@@ -0,0 +1,33 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Redhound
+  # @api private
+  module Capture
+    # @api private
+    module Linux
+      # @api private
+      class SockaddrLL
+        attr_reader :protocol, :index, :hatype, :pkttype, :address
+
+        # @rbs (?protocol: Integer, ?index: Integer, ?hatype: Integer, ?pkttype: Integer, ?address: String) -> void
+        def initialize(protocol: Constants::ETH_P_ALL, index: 0, hatype: 0, pkttype: 0, address: ''.b)
+          @protocol, @index, @hatype, @pkttype, @address = protocol, index, hatype, pkttype, address.byteslice(0, 8)
+        end
+
+        # @rbs () -> String
+        def to_sockaddr
+          [Constants::AF_PACKET, @protocol, @index, @hatype, @pkttype, @address.bytesize, @address].pack('S n l S C C a8')
+        end
+
+        # @rbs (String bytes) -> SockaddrLL
+        def self.parse(bytes)
+          raise CaptureError, 'truncated sockaddr_ll' if bytes.bytesize < 20
+
+          _family, protocol, index, hatype, pkttype, length, address = bytes.unpack('S n l S C C a8') #: [Integer, Integer, Integer, Integer, Integer, Integer, String]
+          new(protocol:, index:, hatype:, pkttype:, address: address.byteslice(0, [length, 8].min) || ''.b)
+        end
+      end
+    end
+  end
+end

data/lib/redhound/capture/linux/tpacket_v3.rb

@@ -0,0 +1,137 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Redhound
+  # @api private
+  module Capture
+    # @api private
+    module Linux
+      # @api private
+      class TPacketV3 < PacketSocket
+        # @rbs (?timeout: Numeric?) -> Packet?
+        def next_packet(timeout: nil)
+          deadline = deadline_for(timeout)
+          polled = false
+          until @stopped || @closed
+            return nil if polled && deadline && Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+            polled = true
+            unless @pending_count.positive?
+              base = @current_block * @block_size
+              unless (u32(base + 8) & Constants::TP_STATUS_USER).positive?
+                return nil unless wait_readable(@socket, deadline)
+                next
+              end
+              @block_end = base + u32(base + 20)
+              @pending_count = u32(base + 12)
+              @packet_offset = base + u32(base + 16)
+              if @pending_count.zero?
+                release_block
+                next
+              end
+            end
+
+            offset = @packet_offset
+            check_ring_bounds(offset, 68)
+            next_offset, seconds, nanos, caplen, original_length, status = @ring.get_string(offset, 24).unpack('L6')
+            mac_offset = @ring.get_value(:u16, offset + 24)
+            check_ring_bounds(offset + mac_offset, caplen)
+            data = @ring.get_string(offset + mac_offset, caplen)
+            address = SockaddrLL.parse(@ring.get_string(offset + 48, 20))
+            meta = { pkttype: address.pkttype, csum_not_ready: (status & Constants::TP_STATUS_CSUMNOTREADY).positive?,
+                     csum_valid: (status & Constants::TP_STATUS_CSUM_VALID).positive? }
+            if (status & Constants::TP_STATUS_VLAN_VALID).positive?
+              tci = u32(offset + 32) & 0xffff
+              tpid = (status & Constants::TP_STATUS_VLAN_TPID_VALID).positive? ? @ring.get_value(:u16, offset + 36) : 0x8100
+              meta[:vlan_tci], meta[:vlan_tpid] = tci, tpid
+              if !@cooked && @linktype == 1
+                original_length += 4
+                data = data.byteslice(0, 12) + [tpid, tci].pack('n2') + data.byteslice(12..) if data.bytesize >= 12
+              elsif @cooked
+                data = [tci, address.protocol].pack('n2') + data
+                original_length += 4
+                address = SockaddrLL.new(protocol: tpid, index: address.index, hatype: address.hatype,
+                                         pkttype: address.pkttype, address: address.address)
+              end
+            end
+            if @cooked
+              data = Cooked.header(address) + data
+              original_length += 20
+            end
+            @pending_count -= 1
+            if @pending_count.zero?
+              release_block
+            else
+              raise CaptureError, 'invalid ring packet offset' if next_offset < 68
+              @packet_offset += next_offset
+            end
+            next unless accept_direction?(address)
+
+            @number += 1
+            @capture_stats.captured += 1
+            return Packet.new(data.byteslice(0, @snaplen), timestamp_ns: seconds * 1_000_000_000 + nanos,
+                              original_length:, linktype: @linktype, interface: packet_interface(address),
+                              direction: address.pkttype == Constants::PACKET_OUTGOING ? :out : :in, number: @number, meta:)
+          end
+          nil
+        end
+
+        protected
+
+        # @rbs () -> void
+        def close_resources
+          begin
+            @ring.free if @ring
+          ensure
+            @ring = nil
+            super
+          end
+        end
+
+        # @rbs () -> Integer
+        def receive_snaplen = @cooked ? [@snaplen - 20, 1].max : @snaplen
+
+        # @rbs (Integer? buffer_size) -> void
+        def setup_receive_buffer(buffer_size)
+          raise ArgumentError, 'buffer size must be positive' if buffer_size && !buffer_size.positive?
+
+          @block_size = 1 << 20
+          @block_size *= 2 while @block_size < @snaplen + 128
+          @block_count = buffer_size ? [(buffer_size.to_f / @block_size).ceil, 1].max : 8
+          frame_size = 2048
+          request = [@block_size, @block_count, frame_size, @block_size * @block_count / frame_size, 50, 0, 0].pack('L7')
+          @socket.setsockopt(Constants::SOL_PACKET, Constants::PACKET_VERSION, [Constants::TPACKET_V3].pack('i'))
+          @socket.setsockopt(Constants::SOL_PACKET, Constants::PACKET_RX_RING, request)
+          experimental = Warning[:experimental]
+          begin
+            Warning[:experimental] = false
+            @ring = IO::Buffer.map(@socket, @block_size * @block_count, 0)
+          rescue ArgumentError => error
+            raise UnsupportedPlatform, "Ruby #{RUBY_VERSION} IO::Buffer.map cannot map a packet socket: #{error.message}"
+          ensure
+            Warning[:experimental] = experimental
+          end
+          @current_block, @pending_count, @packet_offset, @block_end = 0, 0, 0, 0
+        end
+
+        private
+
+        # @rbs (Integer offset) -> Integer
+        def u32(offset) = @ring.get_value(:u32, offset)
+
+        # @rbs (Integer offset, Integer length) -> void
+        def check_ring_bounds(offset, length)
+          unless offset >= @current_block * @block_size && length >= 0 && offset + length <= @block_end && @block_end <= (@current_block + 1) * @block_size
+            raise CaptureError, 'invalid ring packet bounds'
+          end
+        end
+
+        # @rbs () -> void
+        def release_block
+          @ring.set_value(:u32, @current_block * @block_size + 8, 0)
+          @current_block = (@current_block + 1) % @block_count
+          @pending_count = 0
+        end
+      end
+    end
+  end
+end

data/lib/redhound/capture/source.rb

@@ -0,0 +1,79 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Redhound
+  # @api private
+  module Capture
+    # @api private
+    class Source
+      include Enumerable #[Packet]
+
+      # @rbs () -> void
+      def initialize
+        @stopped = false
+        @closed = false
+        @number = 0
+        @capture_stats = Stats.new
+      end
+
+      # @rbs () { (Packet) -> void } -> self
+      # @rbs () -> Enumerator[Packet, self]
+      def each_packet
+        return enum_for(:each_packet) unless block_given?
+
+        until @stopped || @closed
+          packet = next_packet(timeout: 0.1)
+          yield packet if packet
+        end
+        self
+      end
+
+      alias each each_packet
+
+      # @rbs (?timeout: Numeric?) -> Packet?
+      def next_packet(timeout: nil)
+        raise NotImplementedError
+      end
+
+      # @rbs () -> Stats
+      def stats = @capture_stats
+
+      # @rbs () -> bool
+      def stopped? = @stopped
+
+      # @rbs () -> void
+      def stop
+        @stopped = true
+      end
+
+      # @rbs () -> void
+      def close
+        stop
+        @closed = true
+      end
+
+      private
+
+      # @rbs (IO io, Numeric? deadline) -> bool
+      def wait_readable(io, deadline)
+        until @stopped || @closed
+          remaining = deadline && deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          return !!IO.select([io], nil, nil, 0) if remaining && remaining <= 0
+          return true if IO.select([io], nil, nil, remaining ? [remaining, 0.1].min : 0.1)
+        end
+        false
+      rescue IOError, Errno::EBADF
+        return false if @closed || @stopped
+
+        raise
+      end
+
+      # @rbs (Numeric? timeout) -> Numeric?
+      def deadline_for(timeout)
+        raise ArgumentError, 'timeout must be nonnegative' if timeout && timeout.negative?
+
+        timeout && Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+      end
+    end
+  end
+end

data/lib/redhound/capture/stats.rb

@@ -0,0 +1,22 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Redhound
+  # @api private
+  module Capture
+    # @api private
+    class Stats
+      attr_accessor :received, :dropped, :if_dropped, :freeze_count, :captured
+
+      # @rbs (?received: Integer, ?dropped: Integer, ?if_dropped: Integer, ?freeze_count: Integer, ?captured: Integer) -> void
+      def initialize(received: 0, dropped: 0, if_dropped: 0, freeze_count: 0, captured: 0)
+        @received, @dropped, @if_dropped, @freeze_count, @captured = received, dropped, if_dropped, freeze_count, captured
+      end
+
+      # @rbs () -> Hash[Symbol, Integer]
+      def to_h
+        { received: @received, dropped: @dropped, if_dropped: @if_dropped, freeze_count: @freeze_count, captured: @captured }
+      end
+    end
+  end
+end

data/lib/redhound/capture.rb

@@ -0,0 +1,70 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require_relative 'capture/linktype'
+require_relative 'capture/interface'
+require_relative 'capture/stats'
+require_relative 'capture/source'
+require_relative 'capture/linux/constants'
+require_relative 'capture/linux/sockaddr_ll'
+require_relative 'capture/linux/ifreq'
+require_relative 'capture/linux/cooked'
+require_relative 'capture/linux/packet_socket'
+require_relative 'capture/linux/tpacket_v3'
+require_relative 'capture/bsd/constants'
+require_relative 'capture/bsd/ifreq'
+require_relative 'capture/bsd/bpf_device'
+require_relative 'file/format'
+require_relative 'file/pcap_reader'
+require_relative 'file/pcapng_reader'
+require_relative 'file/pcap_writer'
+require_relative 'file/pcapng_writer'
+require_relative 'file/rotating_writer'
+require_relative 'capture/file_source'
+require_relative 'reader'
+
+module Redhound
+  # @api private
+  module Capture
+    # @rbs (interface: String | Integer | Interface, ?backend: Symbol | String, ?snaplen: Integer, ?promiscuous: bool, ?buffer_size: Integer?, ?direction: Symbol, ?filter: String?) -> Source
+    # @rbs [T] (interface: String | Integer | Interface, ?backend: Symbol | String, ?snaplen: Integer, ?promiscuous: bool, ?buffer_size: Integer?, ?direction: Symbol, ?filter: String?) { (Source) -> T } -> T
+    def self.open(interface:, backend: :auto, snaplen: 262_144, promiscuous: true, buffer_size: nil, direction: :inout, filter: nil)
+      options = { snaplen:, promiscuous:, buffer_size:, direction:, filter: } #: Hash[Symbol, untyped]
+      backend = backend.to_sym
+      source = if RUBY_PLATFORM.include?('linux')
+                 case backend
+                 when :socket then Linux::PacketSocket.new(interface:, **options)
+                 when :ring then Linux::TPacketV3.new(interface:, **options)
+                 when :auto
+                   if RUBY_PLATFORM.start_with?('x86_64-', 'aarch64-', 'arm64-')
+                     begin
+                       Linux::TPacketV3.new(interface:, **options)
+                     rescue SystemCallError, IO::Buffer::AccessError, IO::Buffer::AllocationError, NotImplementedError, UnsupportedPlatform => error
+                       warn "redhound: ring backend unavailable (#{error.message}); using socket"
+                       Linux::PacketSocket.new(interface:, **options)
+                     end
+                   else
+                     Linux::PacketSocket.new(interface:, **options)
+                   end
+                 else raise ArgumentError, "invalid Linux capture backend: #{backend}"
+                 end
+               elsif RUBY_PLATFORM.include?('darwin')
+                 raise ArgumentError, "invalid macOS capture backend: #{backend}" unless %i[auto bpf].include?(backend)
+
+                 Bsd::BpfDevice.new(interface:, **options)
+               else
+                 raise UnsupportedPlatform, "unsupported capture platform: #{RUBY_PLATFORM}"
+               end
+      return source unless block_given?
+
+      begin
+        yield source
+      ensure
+        source.close
+      end
+    end
+
+    # @rbs () -> Array[Interface]
+    def self.interfaces = Interface.all
+  end
+end

data/lib/redhound/cli/command.rb

@@ -0,0 +1,42 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Redhound
+  # @api private
+  module CLI
+    # @api private
+    class Command
+      # @rbs (Array[String] argv, ?out: untyped, ?err: untyped) -> Integer
+      def run(argv, out: $stdout, err: $stderr)
+        options = Options.new(argv)
+        values = options.values
+        values[:plugins].each { |path| require ::File.expand_path(path) }
+        if values[:help]
+          out.puts(options.parser)
+        elsif values[:version]
+          out.puts("Redhound #{VERSION}")
+        elsif values[:list_interfaces]
+          Capture.interfaces.each { |i| out.puts(i.to_s) }
+        elsif values[:list_protocols]
+          Registry.default.protocols.each_value do |klass|
+            fields = klass.compiled_header&.definitions&.map(&:name) || []
+            out.puts("#{klass.protocol_id}: #{klass.protocol_name} #{fields.join(' ')}")
+          end
+        else
+          Runner.new(values, out: out, err: err).run
+        end
+        0
+      rescue ConfigurationError, FilterError, ArgumentError => e
+        err.puts("redhound: #{e.message}")
+        if e.is_a?(FilterSyntaxError) && e.expression && e.position
+          err.puts("  #{e.expression}", "  #{' ' * e.position}^")
+        end
+        2
+      rescue Error, SystemCallError, IOError, SocketError, LoadError => e
+        err.puts("redhound: #{e.message}")
+        err.puts(e.backtrace) if values && (values[:debug] || ENV['REDHOUND_DEBUG'] == '1')
+        1
+      end
+    end
+  end
+end