discordrb 3.3.0 → 3.5.0

data/lib/discordrb/voice/sodium.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Discordrb::Voice
+  # @!visibility private
+  module Sodium
+    extend ::FFI::Library
+
+    ffi_lib(['sodium', 'libsodium.so.18', 'libsodium.so.23'])
+
+    # Encryption & decryption
+    attach_function(:crypto_secretbox_xsalsa20poly1305, %i[pointer pointer ulong_long pointer pointer], :int)
+    attach_function(:crypto_secretbox_xsalsa20poly1305_open, %i[pointer pointer ulong_long pointer pointer], :int)
+
+    # Constants
+    attach_function(:crypto_secretbox_xsalsa20poly1305_keybytes, [], :size_t)
+    attach_function(:crypto_secretbox_xsalsa20poly1305_noncebytes, [], :size_t)
+    attach_function(:crypto_secretbox_xsalsa20poly1305_zerobytes, [], :size_t)
+    attach_function(:crypto_secretbox_xsalsa20poly1305_boxzerobytes, [], :size_t)
+  end
+
+  # Utility class for interacting with required `xsalsa20poly1305` functions for voice transmission
+  # @!visibility private
+  class SecretBox
+    # Exception raised when a key or nonce with invalid length is used
+    class LengthError < RuntimeError
+    end
+
+    # Exception raised when encryption or decryption fails
+    class CryptoError < RuntimeError
+    end
+
+    # Required key length
+    KEY_LENGTH = Sodium.crypto_secretbox_xsalsa20poly1305_keybytes
+
+    # Required nonce length
+    NONCE_BYTES = Sodium.crypto_secretbox_xsalsa20poly1305_noncebytes
+
+    # Zero byte padding for encryption
+    ZERO_BYTES = Sodium.crypto_secretbox_xsalsa20poly1305_zerobytes
+
+    # Zero byte padding for decryption
+    BOX_ZERO_BYTES = Sodium.crypto_secretbox_xsalsa20poly1305_boxzerobytes
+
+    # @param key [String] Crypto key of length {KEY_LENGTH}
+    def initialize(key)
+      raise(LengthError, 'Key length') if key.bytesize != KEY_LENGTH
+
+      @key = key
+    end
+
+    # Encrypts a message using this box's key
+    # @param nonce [String] encryption nonce for this message
+    # @param message [String] message to be encrypted
+    def box(nonce, message)
+      raise(LengthError, 'Nonce length') if nonce.bytesize != NONCE_BYTES
+
+      message_padded = prepend_zeroes(ZERO_BYTES, message)
+      buffer = zero_string(message_padded.bytesize)
+
+      success = Sodium.crypto_secretbox_xsalsa20poly1305(buffer, message_padded, message_padded.bytesize, nonce, @key)
+      raise(CryptoError, "Encryption failed (#{success})") unless success.zero?
+
+      remove_zeroes(BOX_ZERO_BYTES, buffer)
+    end
+
+    # Decrypts the given ciphertext using this box's key
+    # @param nonce [String] encryption nonce for this ciphertext
+    # @param ciphertext [String] ciphertext to decrypt
+    def open(nonce, ciphertext)
+      raise(LengthError, 'Nonce length') if nonce.bytesize != NONCE_BYTES
+
+      ct_padded = prepend_zeroes(BOX_ZERO_BYTES, ciphertext)
+      buffer = zero_string(ct_padded.bytesize)
+
+      success = Sodium.crypto_secretbox_xsalsa20poly1305_open(buffer, ct_padded, ct_padded.bytesize, nonce, @key)
+      raise(CryptoError, "Decryption failed (#{success})") unless success.zero?
+
+      remove_zeroes(ZERO_BYTES, buffer)
+    end
+
+    private
+
+    def zero_string(size)
+      str = "\0" * size
+      str.force_encoding('ASCII-8BIT') if str.respond_to?(:force_encoding)
+    end
+
+    def prepend_zeroes(size, string)
+      zero_string(size) + string
+    end
+
+    def remove_zeroes(size, string)
+      string.slice!(size, string.bytesize - size)
+    end
+  end
+end

data/lib/discordrb/voice/voice_bot.rb

@@ -6,7 +6,7 @@ require 'discordrb/logger'
 
 # Voice support
 module Discordrb::Voice
-  # How long one voice packet should ideally be (20 ms as defined by Discord)
+  # How long one voice packet should ideally be (20ms as defined by Discord)
   IDEAL_LENGTH = 20.0
 
   # How many bytes of data to read (1920 bytes * 2 channels) from audio PCM data
@@ -24,6 +24,9 @@ module Discordrb::Voice
     # @return [Channel] the current voice channel
     attr_reader :channel
 
+    # @!visibility private
+    attr_writer :channel
+
     # @return [Integer, nil] the amount of time the stream has been playing, or `nil` if nothing has been played yet.
     attr_reader :stream_time
 
@@ -36,7 +39,7 @@ module Discordrb::Voice
     # play parts back too fast. How often these measurements should be done depends a lot on the system, and if it's
     # done too quickly, especially on slow connections, the playback speed will vary wildly; if it's done too slowly
     # however, small errors will cause quality problems for a longer time.
-    # @return [Integer] how frequently audio length adjustments should be done, in ideal packets (20 ms).
+    # @return [Integer] how frequently audio length adjustments should be done, in ideal packets (20ms).
     attr_accessor :adjust_interval
 
     # This particular value is also important because ffmpeg may take longer to process the first few packets. It is
@@ -44,7 +47,7 @@ module Discordrb::Voice
     # shouldn't be any higher than {#adjust_interval}, otherwise no adjustments will take place. If {#adjust_interval}
     # is at a value higher than 10, this value should not be changed at all.
     # @see #adjust_interval
-    # @return [Integer] the packet number (1 packet = 20 ms) at which length adjustments should start.
+    # @return [Integer] the packet number (1 packet = 20ms) at which length adjustments should start.
     attr_accessor :adjust_offset
 
     # This value determines whether or not the adjustment length should be averaged with the previous value. This may
@@ -60,8 +63,8 @@ module Discordrb::Voice
     attr_accessor :adjust_debug
 
     # If this value is set, no length adjustments will ever be done and this value will always be used as the length
-    # (i. e. packets will be sent every N seconds). Be careful not to set it too low as to not spam Discord's servers.
-    # The ideal length is 20 ms (accessible by the {Discordrb::Voice::IDEAL_LENGTH} constant), this value should be
+    # (i.e. packets will be sent every N seconds). Be careful not to set it too low as to not spam Discord's servers.
+    # The ideal length is 20ms (accessible by the {Discordrb::Voice::IDEAL_LENGTH} constant), this value should be
     # slightly lower than that because encoding + sending takes time. Note that sending DCA files is significantly
     # faster than sending regular audio files (usually about four times as fast), so you might want to set this value
     # to something else if you're sending a DCA file.
@@ -74,13 +77,12 @@ module Discordrb::Voice
     attr_accessor :volume
 
     # @!visibility private
-    def initialize(channel, bot, token, session, endpoint, encrypted)
+    def initialize(channel, bot, token, session, endpoint)
       @bot = bot
       @channel = channel
 
       @ws = VoiceWS.new(channel, bot, token, session, endpoint)
       @udp = @ws.udp
-      @udp.encrypted = encrypted
 
       @sequence = @time = 0
       @skips = 0
@@ -95,14 +97,15 @@ module Discordrb::Voice
 
       @encoder = Encoder.new
       @ws.connect
-    rescue => e
+    rescue StandardError => e
       Discordrb::LOGGER.log_exception(e)
       raise
     end
 
     # @return [true, false] whether audio data sent will be encrypted.
+    # @deprecated Discord no longer supports unencrypted voice communication.
     def encrypted?
-      @udp.encrypted?
+      true
     end
 
     # Set the filter volume. This volume is applied as a filter for decoded audio data. It has the advantage that using
@@ -132,7 +135,7 @@ module Discordrb::Voice
 
     alias_method :isplaying?, :playing?
 
-    # Continue playback. This change may take up to 100 ms to take effect, which is usually negligible.
+    # Continue playback. This change may take up to 100ms to take effect, which is usually negligible.
     def continue
       @paused = false
     end
@@ -145,7 +148,8 @@ module Discordrb::Voice
     end
 
     # Sets whether or not the bot is speaking (green circle around user).
-    # @param value [true, false] whether or not the bot should be speaking.
+    # @param value [true, false, Integer] whether or not the bot should be speaking, or a bitmask denoting the audio type
+    # @note https://discord.com/developers/docs/topics/voice-connections#speaking for information on the speaking bitmask
     def speaking=(value)
       @playing = value
       @ws.send_speaking(value)
@@ -161,6 +165,7 @@ module Discordrb::Voice
       sleep IDEAL_LENGTH / 1000.0 if @was_playing_before
 
       return unless wait_for_confirmation
+
       @has_stopped_playing = false
       sleep IDEAL_LENGTH / 1000.0 until @has_stopped_playing
       @has_stopped_playing = false
@@ -173,7 +178,7 @@ module Discordrb::Voice
       @ws.destroy
     end
 
-    # Plays a stream of raw data to the channel. All playback methods are blocking, i. e. they wait for the playback to
+    # Plays a stream of raw data to the channel. All playback methods are blocking, i.e. they wait for the playback to
     # finish before exiting the method. This doesn't cause a problem if you just use discordrb events/commands to
     # play stuff, as these are fully threaded, but if you don't want this behaviour anyway, be sure to call these
     # methods in separate threads.
@@ -206,7 +211,7 @@ module Discordrb::Voice
         end
 
         # Adjust volume
-        buf = @encoder.adjust_volume(buf, @volume) if @volume != 1.0
+        buf = @encoder.adjust_volume(buf, @volume) if @volume != 1.0 # rubocop:disable Lint/FloatComparison
 
         @first_packet = false
 
@@ -215,12 +220,15 @@ module Discordrb::Voice
       end
 
       # If the stream is a process, kill it
-      if encoded_io.respond_to? :pid
+      if encoded_io&.pid
         Discordrb::LOGGER.debug("Killing ffmpeg process with pid #{encoded_io.pid.inspect}")
 
         begin
-          Process.kill('TERM', encoded_io.pid)
-        rescue => e
+          pid = encoded_io.pid
+          # Windows does not support TERM as a kill signal, so we use KILL. `Process.waitpid` verifies that our
+          # child process has not already completed.
+          Process.kill(Gem.win_platform? ? 'KILL' : 'TERM', pid) if Process.waitpid(pid, Process::WNOHANG).nil?
+        rescue StandardError => e
           Discordrb::LOGGER.warn('Failed to kill ffmpeg process! You *might* have a process leak now.')
           Discordrb::LOGGER.warn("Reason: #{e}")
         end
@@ -255,13 +263,13 @@ module Discordrb::Voice
       stop_playing(true) if @playing
 
       @bot.debug "Reading DCA file #{file}"
-      input_stream = open(file)
+      input_stream = File.open(file)
 
       magic = input_stream.read(4)
       raise ArgumentError, 'Not a DCA1 file! The file might have been corrupted, please recreate it.' unless magic == 'DCA1'
 
       # Read the metadata header, then read the metadata and discard it as we don't care about it
-      metadata_header = input_stream.read(4).unpack('l<')[0]
+      metadata_header = input_stream.read(4).unpack1('l<')
       input_stream.read(metadata_header)
 
       # Play the data, without re-encoding it to opus
@@ -275,9 +283,9 @@ module Discordrb::Voice
             next :stop
           end
 
-          header = header_str.unpack('s<')[0]
+          header = header_str.unpack1('s<')
 
-          raise 'Negative header in DCA file! Your file is likely corrupted.' if header < 0
+          raise 'Negative header in DCA file! Your file is likely corrupted.' if header.negative?
         rescue EOFError
           @bot.debug 'Finished DCA parsing (EOFError)'
           next :stop
@@ -292,7 +300,7 @@ module Discordrb::Voice
 
     private
 
-    # Plays the data from the @io stream as Discord requires it
+    # Plays the data from the IO stream as Discord requires it
     def play_internal
       count = 0
       @playing = true
@@ -311,7 +319,7 @@ module Discordrb::Voice
         break unless @playing
 
         # If we should skip, get some data, discard it and go to the next iteration
-        if @skips > 0
+        if @skips.positive?
           @skips -= 1
           yield
           next
@@ -364,7 +372,7 @@ module Discordrb::Voice
         # If paused, wait
         sleep 0.1 while @paused
 
-        if @length > 0
+        if @length.positive?
           # Wait `length` ms, then send the next packet
           sleep @length / 1000.0
         else
@@ -378,13 +386,13 @@ module Discordrb::Voice
         increment_packet_headers
         @udp.send_audio(Encoder::OPUS_SILENCE, @sequence, @time)
 
-        # Length adjustments don't matter here, we can just wait 20 ms since nobody is going to hear it anyway
+        # Length adjustments don't matter here, we can just wait 20ms since nobody is going to hear it anyway
         sleep IDEAL_LENGTH / 1000.0
       end
 
       @bot.debug('Performing final cleanup after stream ended')
 
-      # Final cleanup
+      # Final clean-up
       stop_playing
 
       # Notify any stop_playing methods running right now that we have actually stopped

data/lib/discordrb/webhooks.rb

@@ -4,6 +4,8 @@ require 'discordrb/webhooks/version'
 require 'discordrb/webhooks/embeds'
 require 'discordrb/webhooks/client'
 require 'discordrb/webhooks/builder'
+require 'discordrb/webhooks/view'
+require 'discordrb/webhooks/modal'
 
 module Discordrb
   # Webhook client

data/lib/discordrb.rb

@@ -10,7 +10,113 @@ module Discordrb
   Thread.current[:discordrb_name] = 'main'
 
   # The default debug logger used by discordrb.
-  LOGGER = Logger.new(ENV['DISCORDRB_FANCY_LOG'])
+  LOGGER = Logger.new(ENV.fetch('DISCORDRB_FANCY_LOG', false))
+
+  # The Unix timestamp Discord IDs are based on
+  DISCORD_EPOCH = 1_420_070_400_000
+
+  # Used to declare what events you wish to recieve from Discord.
+  # @see https://discord.com/developers/docs/topics/gateway#gateway-intents
+  INTENTS = {
+    servers: 1 << 0,
+    server_members: 1 << 1,
+    server_bans: 1 << 2,
+    server_emojis: 1 << 3,
+    server_integrations: 1 << 4,
+    server_webhooks: 1 << 5,
+    server_invites: 1 << 6,
+    server_voice_states: 1 << 7,
+    server_presences: 1 << 8,
+    server_messages: 1 << 9,
+    server_message_reactions: 1 << 10,
+    server_message_typing: 1 << 11,
+    direct_messages: 1 << 12,
+    direct_message_reactions: 1 << 13,
+    direct_message_typing: 1 << 14
+  }.freeze
+
+  # All available intents
+  ALL_INTENTS = INTENTS.values.reduce(&:|)
+
+  # All unprivileged intents
+  # @see https://discord.com/developers/docs/topics/gateway#privileged-intents
+  UNPRIVILEGED_INTENTS = ALL_INTENTS & ~(INTENTS[:server_members] | INTENTS[:server_presences])
+
+  # No intents
+  NO_INTENTS = 0
+
+  # Compares two objects based on IDs - either the objects' IDs are equal, or one object is equal to the other's ID.
+  def self.id_compare(one_id, other)
+    other.respond_to?(:resolve_id) ? (one_id.resolve_id == other.resolve_id) : (one_id == other)
+  end
+
+  # The maximum length a Discord message can have
+  CHARACTER_LIMIT = 2000
+
+  # For creating timestamps with {timestamp}
+  # @see https://discord.com/developers/docs/reference#message-formatting-timestamp-styles
+  TIMESTAMP_STYLES = {
+    short_time: 't', # 16:20
+    long_time: 'T', # 16:20:30
+    short_date: 'd', # 20/04/2021
+    long_date: 'D', # 20 April 2021
+    short_datetime: 'f', # 20 April 2021 16:20
+    long_datetime: 'F', # Tuesday, 20 April 2021 16:20
+    relative: 'R' # 2 months ago
+  }.freeze
+
+  # Splits a message into chunks of 2000 characters. Attempts to split by lines if possible.
+  # @param msg [String] The message to split.
+  # @return [Array<String>] the message split into chunks
+  def self.split_message(msg)
+    # If the messages is empty, return an empty array
+    return [] if msg.empty?
+
+    # Split the message into lines
+    lines = msg.lines
+
+    # Turn the message into a "triangle" of consecutively longer slices, for example the array [1,2,3,4] would become
+    # [
+    #  [1],
+    #  [1, 2],
+    #  [1, 2, 3],
+    #  [1, 2, 3, 4]
+    # ]
+    tri = (0...lines.length).map { |i| lines.combination(i + 1).first }
+
+    # Join the individual elements together to get an array of strings with consecutively more lines
+    joined = tri.map(&:join)
+
+    # Find the largest element that is still below the character limit, or if none such element exists return the first
+    ideal = joined.max_by { |e| e.length > CHARACTER_LIMIT ? -1 : e.length }
+
+    # If it's still larger than the character limit (none was smaller than it) split it into the largest chunk without
+    # cutting words apart, breaking on the nearest space within character limit, otherwise just return an array with one element
+    ideal_ary = ideal.length > CHARACTER_LIMIT ? ideal.split(/(.{1,#{CHARACTER_LIMIT}}\b|.{1,#{CHARACTER_LIMIT}})/o).reject(&:empty?) : [ideal]
+
+    # Slice off the ideal part and strip newlines
+    rest = msg[ideal.length..].strip
+
+    # If none remains, return an empty array -> we're done
+    return [] unless rest
+
+    # Otherwise, call the method recursively to split the rest of the string and add it onto the ideal array
+    ideal_ary + split_message(rest)
+  end
+
+  # @param time [Time, Integer] The time to create the timestamp from, or a unix timestamp integer.
+  # @param style [Symbol, String] One of the keys from {TIMESTAMP_STYLES} or a string with the style.
+  # @return [String]
+  # @example
+  #   Discordrb.timestamp(Time.now, :short_time)
+  #   # => "<t:1632146954:t>"
+  def self.timestamp(time, style = nil)
+    if style.nil?
+      "<t:#{time.to_i}>"
+    else
+      "<t:#{time.to_i}:#{TIMESTAMP_STYLES[style] || style}>"
+    end
+  end
 end
 
 # In discordrb, Integer and {String} are monkey-patched to allow for easy resolution of IDs