ircinch 2.4.0

data/lib/cinch/dcc/incoming/send.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+require "socket"
+
+module Cinch
+  module DCC
+    module Incoming
+      # DCC SEND is a protocol for transferring files, usually found
+      # in IRC. While the handshake, i.e. the details of the file
+      # transfer, are transferred over IRC, the actual file transfer
+      # happens directly between two clients. As such it doesn't put
+      # stress on the IRC server.
+      #
+      # When someone tries to send a file to the bot, the `:dcc_send`
+      # event will be triggered, in which the DCC request can be
+      # inspected and optionally accepted.
+      #
+      # The event handler receives the plain message object as well as
+      # an instance of this class. That instance contains information
+      # about {#filename the suggested file name} (in a sanitized way)
+      # and allows for checking the origin.
+      #
+      # It is advised to reject transfers that seem to originate from
+      # a {#from_private_ip? private IP} or {#from_localhost? the
+      # local IP itself} unless that is expected. Otherwise, specially
+      # crafted requests could cause the bot to connect to internal
+      # services.
+      #
+      # Finally, the file transfer can be {#accept accepted} and
+      # written to any object that implements a `#<<` method, which
+      # includes File objects as well as plain strings.
+      #
+      # @example Saving a transfer to a temporary file
+      #   require "tempfile"
+      #
+      #   listen_to :dcc_send, method: :incoming_dcc
+      #   def incoming_dcc(m, dcc)
+      #     if dcc.from_private_ip? || dcc.from_localhost?
+      #       @bot.loggers.debug "Not accepting potentially dangerous file transfer"
+      #       return
+      #     end
+      #
+      #     t = Tempfile.new(dcc.filename)
+      #     dcc.accept(t)
+      #     t.close
+      #   end
+      #
+      # @attr_reader filename
+      class Send
+        # @private
+        PRIVATE_NETS = [IPAddr.new("fc00::/7"),
+          IPAddr.new("10.0.0.0/8"),
+          IPAddr.new("172.16.0.0/12"),
+          IPAddr.new("192.168.0.0/16")]
+
+        # @private
+        LOCAL_NETS = [IPAddr.new("127.0.0.0/8"),
+          IPAddr.new("::1/128")]
+
+        # @return [User]
+        attr_reader :user
+
+        # @return [Integer]
+        attr_reader :size
+
+        # @return [String]
+        attr_reader :ip
+
+        # @return [Fixnum]
+        attr_reader :port
+
+        # @param [Hash] opts
+        # @option opts [User] user
+        # @option opts [String] filename
+        # @option opts [Integer] size
+        # @option opts [String] ip
+        # @option opts [Fixnum] port
+        # @api private
+        def initialize(opts)
+          @user, @filename, @size, @ip, @port = opts.values_at(:user, :filename, :size, :ip, :port)
+        end
+
+        # @return [String] The basename of the file name, with
+        #   (back)slashes removed.
+        def filename
+          File.basename(File.expand_path(@filename)).delete("/\\")
+        end
+
+        # This method is used for accepting a DCC SEND offer. It
+        # expects an object to save the result to (usually an instance
+        # of IO or String).
+        #
+        # @param [#<<] io The object to write the data to.
+        # @return [Boolean] True if the transfer finished
+        #   successfully, false otherwise.
+        # @note This method blocks.
+        # @example Saving to a file
+        #   f = File.open("/tmp/foo", "w")
+        #   dcc.accept(f)
+        #   f.close
+        #
+        # @example Saving to a string
+        #   s = ""
+        #   dcc.accept(s)
+        def accept(io)
+          socket = TCPSocket.new(@ip, @port)
+          total = 0
+
+          while (buf = socket.readpartial(8192))
+            total += buf.bytesize
+
+            begin
+              socket.write_nonblock [total].pack("N")
+            rescue Errno::EWOULDBLOCK, Errno::AGAIN
+              # Nobody cares about ACKs, really. And if the sender
+              # couldn't receive it at this point, they probably don't
+              # care, either.
+            end
+            io << buf
+
+            # Break here in case the sender doesn't close the
+            # connection on the final ACK.
+            break if total == @size
+          end
+
+          socket.close
+          true
+        rescue EOFError
+          false
+        end
+
+        # @return [Boolean] True if the DCC originates from a private ip
+        # @see #from_localhost?
+        def from_private_ip?
+          ip = IPAddr.new(@ip)
+          PRIVATE_NETS.any? { |n| n.include?(ip) }
+        end
+
+        # @return [Boolean] True if the DCC originates from localhost
+        # @see #from_private_ip?
+        def from_localhost?
+          ip = IPAddr.new(@ip)
+          LOCAL_NETS.any? { |n| n.include?(ip) }
+        end
+      end
+    end
+  end
+end

data/lib/cinch/dcc/incoming.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "incoming/send"

data/lib/cinch/dcc/outgoing/send.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+require "socket"
+require "timeout"
+
+module Cinch
+  module DCC
+    module Outgoing
+      # DCC SEND is a protocol for transferring files, usually found
+      # in IRC. While the handshake, i.e. the details of the file
+      # transfer, are transferred over IRC, the actual file transfer
+      # happens directly between two clients. As such it doesn't put
+      # stress on the IRC server.
+      #
+      # Cinch allows sending files by either using
+      # {Cinch::User#dcc_send}, which takes care of all parameters as
+      # well as setting up resume support, or by creating instances of
+      # this class directly. The latter will only be useful to people
+      # working on the Cinch code itself.
+      #
+      # {Cinch::User#dcc_send} expects an object to send as well as
+      # optionaly a file name, which is sent to the receiver as a
+      # suggestion where to save the file. If no file name is
+      # provided, the method will use the object's `#path` method to
+      # determine it.
+      #
+      # Any object that implements {DCC::DCCableObject} can be sent,
+      # but sending files will probably be the most common case.
+      #
+      # If you're behind a NAT it is necessary to explicitly set the
+      # external IP using the {file:docs/bot_options.md#dccownip dcc.own_ip
+      # option}.
+      #
+      # @example Sending a file to a user
+      #   match "send me something"
+      #   def execute(m)
+      #     m.user.dcc_send(open("/tmp/cookies"))
+      #   end
+      class Send
+        # @param [Hash] opts
+        # @option opts [User] receiver
+        # @option opts [String] filename
+        # @option opts [File] io
+        # @option opts [String] own_ip
+        def initialize(opts = {})
+          @receiver, @filename, @io, @own_ip = opts.values_at(:receiver, :filename, :io, :own_ip)
+        end
+
+        # Start the server
+        #
+        # @return [void]
+        def start_server
+          @socket = TCPServer.new(0)
+          @socket.listen(1)
+        end
+
+        # Send the handshake to the user.
+        #
+        # @return [void]
+        def send_handshake
+          handshake = "\001DCC SEND %s %d %d %d\001" % [@filename, IPAddr.new(@own_ip).to_i, port, @io.size]
+          @receiver.send(handshake)
+        end
+
+        # Listen for an incoming connection.
+        #
+        # This starts listening for an incoming connection to the server
+        # started by {#start_server}. After a client successfully
+        # connected, the server socket will be closed and the file
+        # transferred to the client.
+        #
+        # @raise [Timeout::Error] Raised if the receiver did not connect
+        #   within 30 seconds
+        # @return [void]
+        # @note This method blocks.
+        def listen
+          fd = nil
+          Timeout.timeout(30) do
+            fd, _ = @socket.accept
+          end
+          send_data(fd)
+          fd.close
+        ensure
+          @socket.close
+        end
+
+        # Seek to `pos` in the data.
+        #
+        # @param [Integer] pos
+        # @return [void]
+        # @api private
+        def seek(pos)
+          @io.seek(pos)
+        end
+
+        # @return [Fixnum] The port used for the socket
+        def port
+          @port ||= @socket.addr[1]
+        end
+
+        private
+
+        def send_data(fd)
+          @io.advise(:sequential)
+
+          while (chunk = @io.read(8096))
+            loop do
+              rs, ws = IO.select([fd], [fd])
+              if !rs.empty?
+                rs.first.recv(8096)
+              end
+              if !ws.empty?
+                ws.first.write(chunk)
+                break
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cinch/dcc/outgoing.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "outgoing/send"

data/lib/cinch/dcc.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "dcc/incoming"
+require_relative "dcc/outgoing"
+
+module Cinch
+  # Cinch supports the following DCC commands:
+  #
+  # - SEND (both {DCC::Incoming::Send incoming} and
+  #   {DCC::Outgoing::Send outgoing})
+  # @since 2.0.0
+  module DCC
+  end
+end

data/lib/cinch/exceptions.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Cinch
+  # A collection of exceptions.
+  module Exceptions
+    # Generic error. Superclass for all Cinch-specific errors.
+    class Generic < ::StandardError
+    end
+
+    # Generic error when an argument is too long.
+    class ArgumentTooLong < Generic
+    end
+
+    # Error that is raised when a topic is too long to be set.
+    class TopicTooLong < ArgumentTooLong
+    end
+
+    # Error that is raised when a nick is too long to be used.
+    class NickTooLong < ArgumentTooLong
+    end
+
+    # Error that is raised when a kick reason is too long.
+    class KickReasonTooLong < ArgumentTooLong
+    end
+
+    # Raised whenever Cinch discovers a feature it doesn't support
+    # yet.
+    class UnsupportedFeature < Generic
+    end
+
+    # Raised when Cinch discovers a user or channel mode, which it
+    # doesn't support yet.
+    class UnsupportedMode < Generic
+      def initialize(mode)
+        super "Cinch does not support the mode '#{mode}' yet."
+      end
+    end
+
+    # Error stating that an invalid mode string was encountered.
+    class InvalidModeString < Generic
+    end
+
+    # Raised when a synced attribute hasn't been available for too
+    # long.
+    class SyncedAttributeNotAvailable < Generic
+    end
+  end
+end

data/lib/cinch/formatting.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Cinch
+  # This module can be used for adding and removing colors and
+  # formatting to/from messages.
+  #
+  # The format codes used are those defined by mIRC, which are also
+  # the ones supported by most clients.
+  #
+  # For usage instructions and examples, see {.format}.
+  #
+  # List of valid colors
+  # =========================
+  # - aqua
+  # - black
+  # - blue
+  # - brown
+  # - green
+  # - grey
+  # - lime
+  # - orange
+  # - pink
+  # - purple
+  # - red
+  # - royal
+  # - silver
+  # - teal
+  # - white
+  # - yellow
+  #
+  # List of valid attributes
+  # ========================
+  # - bold
+  # - italic
+  # - reverse/reversed
+  # - underline/underlined
+  #
+  # Other
+  # =====
+  # - reset (Resets all formatting to the client's defaults)
+  #
+  # @since 2.0.0
+  module Formatting
+    # @private
+    COLORS = {
+      white: "00",
+      black: "01",
+      blue: "02",
+      green: "03",
+      red: "04",
+      brown: "05",
+      purple: "06",
+      orange: "07",
+      yellow: "08",
+      lime: "09",
+      teal: "10",
+      aqua: "11",
+      royal: "12",
+      pink: "13",
+      grey: "14",
+      silver: "15"
+    }
+
+    # @private
+    ATTRIBUTES = {
+      bold: 2.chr,
+      underlined: 31.chr,
+      underline: 31.chr,
+      reversed: 22.chr,
+      reverse: 22.chr,
+      italic: 29.chr,
+      reset: 15.chr
+    }
+
+    # @param [Array<Symbol>] settings The colors and attributes to apply.
+    #   When supplying two colors, the first will be used for the
+    #   foreground and the second for the background.
+    # @param [String] string The string to format.
+    # @return [String] the formatted string
+    # @since 2.0.0
+    # @raise [ArgumentError] When passing more than two colors as arguments.
+    # @see Helpers#Format Helpers#Format for easier access to this method.
+    #
+    # @example Nested formatting, combining text styles and colors
+    #   reply = Format(:underline, "Hello %s! Is your favourite color %s?" % [Format(:bold, "stranger"), Format(:red, "red")])
+    def self.format(*settings, string)
+      string = string.dup
+
+      attributes = settings.select { |k| ATTRIBUTES.has_key?(k) }.map { |k| ATTRIBUTES[k] }
+      colors = settings.select { |k| COLORS.has_key?(k) }.map { |k| COLORS[k] }
+      if colors.size > 2
+        raise ArgumentError, "At most two colors (foreground and background) might be specified"
+      end
+
+      attribute_string = attributes.join
+      color_string = if colors.empty?
+        ""
+      else
+        "\x03#{colors.join(",")}"
+      end
+
+      prepend = attribute_string + color_string
+      append = ATTRIBUTES[:reset]
+
+      # Attributes act as toggles, so e.g. underline+underline = no
+      # underline. We thus have to delete all duplicate attributes
+      # from nested strings.
+      string.delete!(attribute_string)
+
+      # Replace the reset code of nested strings to continue the
+      # formattings of the outer string.
+      string.gsub!(/#{ATTRIBUTES[:reset]}/, ATTRIBUTES[:reset] + prepend)
+      prepend + string + append
+    end
+
+    # Deletes all mIRC formatting codes from the string. This strips
+    # formatting for bold, underline and so on, as well as color
+    # codes. This does include removing the numeric arguments.
+    #
+    # @param [String] string The string to filter
+    # @return [String] The filtered string
+    # @since 2.2.0
+    def self.unformat(string)
+      string.gsub(/[\x02\x0f\x16\x1f\x12]|\x03(\d{1,2}(,\d{1,2})?)?/, "")
+    end
+  end
+end

data/lib/cinch/handler.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Cinch
+  # @since 2.0.0
+  class Handler
+    # @return [Bot]
+    attr_reader :bot
+
+    # @return [Symbol]
+    attr_reader :event
+
+    # @return [Pattern]
+    attr_reader :pattern
+
+    # @return [Array]
+    attr_reader :args
+
+    # @return [Proc]
+    attr_reader :block
+
+    # @return [Symbol]
+    attr_reader :group
+
+    # @return [Boolean]
+    attr_reader :strip_colors
+
+    # @return [ThreadGroup]
+    # @api private
+    attr_reader :thread_group
+
+    # @param [Bot] bot
+    # @param [Symbol] event
+    # @param [Pattern] pattern
+    # @param [Hash] options
+    # @option options [Symbol] :group (nil) Match group the h belongs
+    #   to.
+    # @option options [Boolean] :execute_in_callback (false) Whether
+    #   to execute the handler in an instance of {Callback}
+    # @option options [Boolean] :strip_colors (false) Strip colors
+    #   from message before attemping match
+    # @option options [Array] :args ([]) Additional arguments to pass
+    #   to the block
+    def initialize(bot, event, pattern, options = {}, &block)
+      options = {
+        group: nil,
+        execute_in_callback: false,
+        strip_colors: false,
+        args: []
+      }.merge(options)
+      @bot = bot
+      @event = event
+      @pattern = pattern
+      @group = options[:group]
+      @execute_in_callback = options[:execute_in_callback]
+      @strip_colors = options[:strip_colors]
+      @args = options[:args]
+      @block = block
+
+      @thread_group = ThreadGroup.new
+    end
+
+    # Unregisters the handler.
+    #
+    # @return [void]
+    def unregister
+      @bot.handlers.unregister(self)
+    end
+
+    # Stops execution of the handler. This means stopping and killing
+    # all associated threads.
+    #
+    # @return [void]
+    def stop
+      @bot.loggers.debug "[Stopping handler] Stopping all threads of handler #{self}: #{@thread_group.list.size} threads..."
+      @thread_group.list.each do |thread|
+        Thread.new do
+          @bot.loggers.debug "[Ending thread] Waiting 10 seconds for #{thread} to finish..."
+          thread.join(10)
+          @bot.loggers.debug "[Killing thread] Killing #{thread}"
+          thread.kill
+        end
+      end
+    end
+
+    # Executes the handler.
+    #
+    # @param [Message] message Message that caused the invocation
+    # @param [Array] captures Capture groups of the pattern that are
+    #   being passed as arguments
+    # @return [Thread]
+    def call(message, captures, arguments)
+      bargs = captures + arguments
+
+      thread = Thread.new {
+        @bot.loggers.debug "[New thread] For #{self}: #{Thread.current} -- #{@thread_group.list.size} in total."
+
+        begin
+          if @execute_in_callback
+            @bot.callback.instance_exec(message, *@args, *bargs, &@block)
+          else
+            @block.call(message, *@args, *bargs)
+          end
+        rescue => e
+          @bot.loggers.exception(e)
+        ensure
+          @bot.loggers.debug "[Thread done] For #{self}: #{Thread.current} -- #{@thread_group.list.size - 1} remaining."
+        end
+      }
+
+      @thread_group.add(thread)
+      thread
+    end
+
+    # @return [String]
+    def to_s
+      # TODO maybe add the number of running threads to the output?
+      "#<Cinch::Handler @event=#{@event.inspect} pattern=#{@pattern.inspect}>"
+    end
+  end
+end

data/lib/cinch/handler_list.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "set"
+
+require_relative "cached_list"
+
+module Cinch
+  # @since 2.0.0
+  class HandlerList
+    include Enumerable
+
+    def initialize
+      @handlers = Hash.new { |h, k| h[k] = [] }
+      @mutex = Mutex.new
+    end
+
+    def register(handler)
+      @mutex.synchronize do
+        handler.bot.loggers.debug "[on handler] Registering handler with pattern `#{handler.pattern.inspect}`, reacting on `#{handler.event}`"
+        @handlers[handler.event] << handler
+      end
+    end
+
+    # @param [Handler, Array<Handler>] handlers The handlers to unregister
+    # @return [void]
+    # @see Handler#unregister
+    def unregister(*handlers)
+      @mutex.synchronize do
+        handlers.each do |handler|
+          @handlers[handler.event].delete(handler)
+        end
+      end
+    end
+
+    # @api private
+    # @return [Array<Handler>]
+    def find(type, msg = nil)
+      if (handlers = @handlers[type])
+        if msg.nil?
+          return handlers
+        end
+
+        handlers = handlers.select { |handler|
+          msg.match(handler.pattern.to_r(msg), type, handler.strip_colors)
+        }.group_by { |handler| handler.group }
+
+        handlers.values_at(*(handlers.keys - [nil])).map(&:first) + (handlers[nil] || [])
+      end
+    end
+
+    # @param [Symbol] event The event type
+    # @param [Message, nil] msg The message which is responsible for
+    #   and attached to the event, or nil.
+    # @param [Array] arguments A list of additional arguments to pass
+    #   to event handlers
+    # @return [Array<Thread>]
+    def dispatch(event, msg = nil, *arguments)
+      threads = []
+
+      if (handlers = find(event, msg))
+        already_run = Set.new
+        handlers.each do |handler|
+          next if already_run.include?(handler.block)
+          already_run << handler.block
+          # calling Message#match multiple times is not a problem
+          # because we cache the result
+          captures = if msg
+            msg.match(handler.pattern.to_r(msg), event, handler.strip_colors).captures
+          else
+            []
+          end
+
+          threads << handler.call(msg, captures, arguments)
+        end
+      end
+
+      threads
+    end
+
+    # @yield [handler] Yields all registered handlers
+    # @yieldparam [Handler] handler
+    # @return [void]
+    def each(&block)
+      @handlers.values.flatten.each(&block)
+    end
+
+    # @api private
+    def stop_all
+      each { |h| h.stop }
+    end
+  end
+end