discordrb 3.1.1 → 3.4.0

data/lib/discordrb/voice/network.rb

@@ -1,58 +1,66 @@
 # frozen_string_literal: true
 
 require 'websocket-client-simple'
-require 'resolv'
 require 'socket'
 require 'json'
 
 require 'discordrb/websocket'
 
 begin
-  RBNACL_AVAILABLE = if ENV['DISCORDRB_NONACL']
-                       false
-                     else
-                       require 'rbnacl'
-                       true
-                     end
+  LIBSODIUM_AVAILABLE = if ENV['DISCORDRB_NONACL']
+                          false
+                        else
+                          require 'discordrb/voice/sodium'
+                        end
 rescue LoadError
   puts "libsodium not available! You can continue to use discordrb as normal but voice support won't work.
-        Read https://github.com/meew0/discordrb/wiki/Installing-libsodium for more details."
-  RBNACL_AVAILABLE = false
+        Read https://github.com/shardlab/discordrb/wiki/Installing-libsodium for more details."
+  LIBSODIUM_AVAILABLE = false
 end
 
 module Discordrb::Voice
   # Signifies to Discord that encryption should be used
-  ENCRYPTED_MODE = 'xsalsa20_poly1305'.freeze
+  # @deprecated Discord now supports multiple encryption options.
+  # TODO: Resolve replacement for this constant.
+  ENCRYPTED_MODE = 'xsalsa20_poly1305'
 
   # Signifies to Discord that no encryption should be used
-  PLAIN_MODE = 'plain'.freeze
+  # @deprecated Discord no longer supports unencrypted voice communication.
+  PLAIN_MODE = 'plain'
+
+  # Encryption modes supported by Discord
+  ENCRYPTION_MODES = %w[xsalsa20_poly1305_lite xsalsa20_poly1305_suffix xsalsa20_poly1305].freeze
 
   # Represents a UDP connection to a voice server. This connection is used to send the actual audio data.
   class VoiceUDP
     # @return [true, false] whether or not UDP communications are encrypted.
+    # @deprecated Discord no longer supports unencrypted voice communication.
     attr_accessor :encrypted
     alias_method :encrypted?, :encrypted
 
     # Sets the secret key used for encryption
     attr_writer :secret_key
 
+    # The UDP encryption mode
+    attr_reader :mode # rubocop:disable Style/BisectedAttrAccessor
+
+    # @!visibility private
+    attr_writer :mode # rubocop:disable Style/BisectedAttrAccessor
+
     # Creates a new UDP connection. Only creates a socket as the discovery reply may come before the data is
     # initialized.
     def initialize
       @socket = UDPSocket.new
+      @encrypted = true
     end
 
     # Initializes the UDP socket with data obtained from opcode 2.
-    # @param endpoint [String] The voice endpoint to connect to.
+    # @param ip [String] The IP address to connect to.
     # @param port [Integer] The port to connect to.
     # @param ssrc [Integer] The Super Secret Relay Code (SSRC). Discord uses this to identify different voice users
     #   on the same endpoint.
-    def connect(endpoint, port, ssrc)
-      @endpoint = endpoint
-      @endpoint = @endpoint[6..-1] if @endpoint.start_with? 'wss://'
-      @endpoint = @endpoint.gsub(':80', '') # The endpoint may contain a port, we don't want that
-      @endpoint = Resolv.getaddress @endpoint
-
+    def connect(ip, port, ssrc)
+      @ip = ip
       @port = port
       @ssrc = ssrc
     end
@@ -63,7 +71,7 @@ module Discordrb::Voice
       # Wait for a UDP message
       message = @socket.recv(70)
       ip = message[4..-3].delete("\0")
-      port = message[-2..-1].to_i
+      port = message[-2..-1].unpack1('n')
       [ip, port]
     end
 
@@ -76,10 +84,15 @@ module Discordrb::Voice
       # Header of the audio packet
       header = [0x80, 0x78, sequence, time, @ssrc].pack('CCnNN')
 
-      # Encrypt data, if necessary
-      buf = encrypt_audio(header, buf) if encrypted?
+      nonce = generate_nonce(header)
+      buf = encrypt_audio(buf, nonce)
 
-      send_packet(header + buf)
+      data = header + buf
+
+      # xsalsa20_poly1305 does not require an appended nonce
+      data += nonce unless @mode == 'xsalsa20_poly1305'
+
+      send_packet(data)
     end
 
     # Sends the UDP discovery packet with the internally stored SSRC. Discord will send a reply afterwards which can
@@ -94,22 +107,47 @@ module Discordrb::Voice
 
     private
 
-    # Encrypts audio data using RbNaCl
-    # @param header [String] The header of the packet, to be used as the nonce
+    # Encrypts audio data using libsodium
     # @param buf [String] The encoded audio data to be encrypted
+    # @param nonce [String] The nonce to be used to encrypt the data
     # @return [String] the audio data, encrypted
-    def encrypt_audio(header, buf)
+    def encrypt_audio(buf, nonce)
       raise 'No secret key found, despite encryption being enabled!' unless @secret_key
-      box = RbNaCl::SecretBox.new(@secret_key)
 
-      # The nonce is the header of the voice packet with 12 null bytes appended
-      nonce = header + ([0] * 12).pack('C*')
+      secret_box = Discordrb::Voice::SecretBox.new(@secret_key)
 
-      box.encrypt(nonce, buf)
+      # Nonces must be 24 bytes in length. We right pad with null bytes for poly1305 and poly1305_lite
+      secret_box.box(nonce.ljust(24, "\0"), buf)
     end
 
     def send_packet(packet)
-      @socket.send(packet, 0, @endpoint, @port)
+      @socket.send(packet, 0, @ip, @port)
+    end
+
+    # @param header [String] The header of the packet, to be used as the nonce
+    # @return [String]
+    # @note
+    #   The nonce generated depends on the encryption mode.
+    #   In xsalsa20_poly1305 the nonce is the header plus twelve null bytes for padding.
+    #   In xsalsa20_poly1305_suffix, the nonce is 24 random bytes
+    #   In xsalsa20_poly1305_lite, the nonce is an incremental 4 byte int.
+    def generate_nonce(header)
+      case @mode
+      when 'xsalsa20_poly1305'
+        header
+      when 'xsalsa20_poly1305_suffix'
+        Random.urandom(24)
+      when 'xsalsa20_poly1305_lite'
+        case @lite_nonce
+        when nil, 0xff_ff_ff_ff
+          @lite_nonce = 0
+        else
+          @lite_nonce += 1
+        end
+        [@lite_nonce].pack('N')
+      else
+        raise "`#{@mode}' is not a supported encryption mode"
+      end
     end
   end
 
@@ -117,6 +155,9 @@ module Discordrb::Voice
   # used to manage general data about the connection, such as sending the speaking packet, which determines the green
   # circle around users on Discord, and obtaining UDP connection info.
   class VoiceWS
+    # The version of the voice gateway that's supposed to be used.
+    VOICE_GATEWAY_VERSION = 4
+
     # @return [VoiceUDP] the UDP voice connection over which the actual audio data is sent.
     attr_reader :udp
 
@@ -127,14 +168,14 @@ module Discordrb::Voice
     # @param session [String] The voice session ID Discord sends over the regular websocket
     # @param endpoint [String] The endpoint URL to connect to
     def initialize(channel, bot, token, session, endpoint)
-      raise 'RbNaCl is unavailable - unable to create voice bot! Please read https://github.com/meew0/discordrb/wiki/Installing-libsodium' unless RBNACL_AVAILABLE
+      raise 'libsodium is unavailable - unable to create voice bot! Please read https://github.com/shardlab/discordrb/wiki/Installing-libsodium' unless LIBSODIUM_AVAILABLE
 
       @channel = channel
       @bot = bot
       @token = token
       @session = session
 
-      @endpoint = endpoint.gsub(':80', '')
+      @endpoint = endpoint.split(':').first
 
       @udp = VoiceUDP.new
     end
@@ -181,12 +222,12 @@ module Discordrb::Voice
 
       @client.send({
         op: 3,
-        d: nil
+        d: millis
       }.to_json)
     end
 
     # Send a speaking packet (op 5). This determines the green circle around the avatar in the voice channel
-    # @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, can also be a bitmask denoting audio type.
     def send_speaking(value)
       @bot.debug("Speaking: #{value}")
       @client.send({
@@ -218,18 +259,23 @@ module Discordrb::Voice
         # Opcode 2 contains data to initialize the UDP connection
         @ws_data = packet['d']
 
-        @heartbeat_interval = @ws_data['heartbeat_interval']
         @ssrc = @ws_data['ssrc']
         @port = @ws_data['port']
-        @udp_mode = mode
 
-        @udp.connect(@endpoint, @port, @ssrc)
+        @udp_mode = (ENCRYPTION_MODES & @ws_data['modes']).first
+
+        @udp.connect(@ws_data['ip'], @port, @ssrc)
         @udp.send_discovery
       when 4
         # Opcode 4 sends the secret key used for encryption
         @ws_data = packet['d']
+
         @ready = true
         @udp.secret_key = @ws_data['secret_key'].pack('C*')
+        @udp.mode = @ws_data['mode']
+      when 8
+        # Opcode 8 contains the heartbeat interval.
+        @heartbeat_interval = packet['d']['heartbeat_interval']
       end
     end
 
@@ -276,11 +322,6 @@ module Discordrb::Voice
 
     private
 
-    # @return [String] the mode string that signifies whether encryption should be used or not
-    def mode
-      @udp.encrypted? ? ENCRYPTED_MODE : PLAIN_MODE
-    end
-
     def heartbeat_loop
       @heartbeat_running = true
       while @heartbeat_running
@@ -295,7 +336,7 @@ module Discordrb::Voice
     end
 
     def init_ws
-      host = "wss://#{@endpoint}:443"
+      host = "wss://#{@endpoint}:443/?v=#{VOICE_GATEWAY_VERSION}"
       @bot.debug("Connecting VWS to host: #{host}")
 
       # Connect the WS
@@ -303,8 +344,8 @@ module Discordrb::Voice
         host,
         method(:websocket_open),
         method(:websocket_message),
-        proc { |e| Discordrb::Logger.error "VWS error: #{e}" },
-        proc { |e| Discordrb::Logger.warn "VWS close: #{e}" }
+        proc { |e| Discordrb::LOGGER.error "VWS error: #{e}" },
+        proc { |e| Discordrb::LOGGER.warn "VWS close: #{e}" }
       )
 
       @bot.debug('VWS connected')

data/lib/discordrb/voice/sodium.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+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
@@ -22,7 +22,10 @@ module Discordrb::Voice
   # {VoiceBot#adjust_offset}, and {VoiceBot#adjust_average}.
   class VoiceBot
     # @return [Channel] the current voice channel
-    attr_reader :channel
+    attr_reader :channel # rubocop:disable Style/BisectedAttrAccessor
+
+    # @!visibility private
+    attr_writer :channel # rubocop:disable Style/BisectedAttrAccessor
 
     # @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://discordapp.com/developers/docs/topics/voice-connections#speaking for information on the speaking bitmask
     def speaking=(value)
       @playing = value
       @ws.send_speaking(value)
@@ -160,11 +164,11 @@ module Discordrb::Voice
       @playing = false
       sleep IDEAL_LENGTH / 1000.0 if @was_playing_before
 
-      if wait_for_confirmation
-        @has_stopped_playing = false
-        sleep IDEAL_LENGTH / 1000.0 until @has_stopped_playing
-        @has_stopped_playing = false
-      end
+      return unless wait_for_confirmation
+
+      @has_stopped_playing = false
+      sleep IDEAL_LENGTH / 1000.0 until @has_stopped_playing
+      @has_stopped_playing = false
     end
 
     # Permanently disconnects from the voice channel; to reconnect you will have to call {Bot#voice_connect} again.
@@ -174,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.
@@ -194,20 +198,20 @@ module Discordrb::Voice
           raise IOError, 'File or stream not found!' if @first_packet
 
           @bot.debug('EOF while reading, breaking immediately')
-          break
+          next :stop
         end
 
         # Check whether the buffer has enough data
         if !buf || buf.length != DATA_LENGTH
           @bot.debug("No data is available! Retrying #{@retry_attempts} more times")
-          break if @retry_attempts.zero?
+          next :stop if @retry_attempts.zero?
 
           @retry_attempts -= 1
           next
         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
 
@@ -216,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
@@ -234,15 +241,15 @@ module Discordrb::Voice
     # Plays an encoded audio file of arbitrary format to the channel.
     # @see Encoder#encode_file
     # @see #play
-    def play_file(file)
-      play @encoder.encode_file(file)
+    def play_file(file, options = '')
+      play @encoder.encode_file(file, options)
     end
 
     # Plays a stream of encoded audio data of arbitrary format to the channel.
     # @see Encoder#encode_io
     # @see #play
-    def play_io(io)
-      play @encoder.encode_io(io)
+    def play_io(io, options = '')
+      play @encoder.encode_io(io, options)
     end
 
     # Plays a stream of audio data in the DCA format. This format has the advantage that no recoding has to be
@@ -256,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
@@ -273,15 +280,15 @@ module Discordrb::Voice
 
           unless header_str
             @bot.debug 'Finished DCA parsing (header is nil)'
-            break
+            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)'
-          break
+          next :stop
         end
 
         # Read bytes
@@ -293,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
@@ -312,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
@@ -324,6 +331,11 @@ module Discordrb::Voice
 
         # Get packet data
         buf = yield
+
+        # Stop doing anything if the stop signal was sent
+        break if buf == :stop
+
+        # Proceed to the next packet if we got nil
         next unless buf
 
         # Track intermediate adjustment so we can measure how much encoding contributes to the total time
@@ -360,11 +372,11 @@ 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
-          Discordrb::Logger.warn('Audio encoding and sending together took longer than Discord expects one packet to be (20 ms)! This may be indicative of network problems.')
+          Discordrb::LOGGER.warn('Audio encoding and sending together took longer than Discord expects one packet to be (20 ms)! This may be indicative of network problems.')
         end
       end
 
@@ -374,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