mtproto 0.0.8 → 0.0.9

data/lib/mtproto/tl/objects/update.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class Update
+      CONSTRUCTOR_NEW_MESSAGE = 0x1f2b0afd
+      MESSAGE_CONSTRUCTOR = 0x9815cec8
+
+      attr_reader :type, :text
+
+      def initialize(type, text: nil)
+        @type = type
+        @text = text
+      end
+
+      def self.parse(bytes)
+        constructor_id = bytes[0, 4].unpack1('L<')
+        type = type_name(constructor_id)
+
+        case constructor_id
+        when CONSTRUCTOR_NEW_MESSAGE
+          text = extract_new_message_text(bytes)
+          new(type, text: text)
+        else
+          new(type)
+        end
+      end
+
+      class << self
+        private
+
+        def type_name(constructor_id)
+          name = Constructors::NAMES.fetch(constructor_id)
+          name.sub(/^update/, '')
+              .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+              .downcase
+        end
+
+        def extract_new_message_text(bytes)
+          offset = 4 # skip updateNewMessage constructor
+
+          msg_constructor = bytes[offset, 4].unpack1('L<')
+          return nil unless msg_constructor == MESSAGE_CONSTRUCTOR
+
+          offset += 4
+          flags = bytes[offset, 4].unpack1('L<')
+          offset += 4
+          flags2 = bytes[offset, 4].unpack1('L<')
+          offset += 4
+          offset += 4 # id
+
+          offset += 12 if flags & (1 << 8) != 0 # from_id: Peer
+          offset += 12 # peer_id: Peer
+          offset += 12 if flags & (1 << 28) != 0 # saved_peer_id: Peer
+          return nil if flags & (1 << 2) != 0 # fwd_from: variable length
+
+          offset += 8 if flags & (1 << 11) != 0 # via_bot_id: long
+          offset += 8 if flags2 & 1 != 0           # via_business_bot_id: long
+          return nil if flags & (1 << 3) != 0      # reply_to: variable length
+
+          offset += 4 # date
+          read_tl_string(bytes, offset)
+        end
+
+        def read_tl_string(bytes, offset)
+          first_byte = bytes.getbyte(offset)
+          if first_byte == 254
+            len = bytes.getbyte(offset + 1) |
+                  (bytes.getbyte(offset + 2) << 8) |
+                  (bytes.getbyte(offset + 3) << 16)
+            bytes[offset + 4, len]
+          else
+            bytes[offset + 1, first_byte]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/update_short.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class UpdateShort
+      CONSTRUCTOR = 0x78d4dec1
+
+      attr_reader :update, :date
+
+      def initialize(update, date)
+        @update = update
+        @date = date
+      end
+
+      def self.parse(bytes)
+        date = bytes[-4, 4].unpack1('l<')
+        update = Update.parse(bytes[4...-4])
+        new(update, date)
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/update_short_message.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class UpdateShortMessage
+      CONSTRUCTOR = 0x313bc7f8
+
+      attr_reader :flags, :id, :user_id, :text, :pts, :pts_count, :date
+
+      def initialize(flags:, id:, user_id:, text:, pts:, pts_count:, date:)
+        @flags = flags
+        @id = id
+        @user_id = user_id
+        @text = text
+        @pts = pts
+        @pts_count = pts_count
+        @date = date
+      end
+
+      def out?
+        flags & (1 << 1) != 0
+      end
+
+      def mentioned?
+        flags & (1 << 4) != 0
+      end
+
+      def self.parse(bytes)
+        offset = 4 # skip constructor
+        flags = bytes[offset, 4].unpack1('L<')
+        offset += 4
+        id = bytes[offset, 4].unpack1('l<')
+        offset += 4
+        user_id = bytes[offset, 8].unpack1('q<')
+        offset += 8
+        text, offset = read_tl_string(bytes, offset)
+        pts = bytes[offset, 4].unpack1('l<')
+        offset += 4
+        pts_count = bytes[offset, 4].unpack1('l<')
+        offset += 4
+        date = bytes[offset, 4].unpack1('l<')
+
+        new(flags: flags, id: id, user_id: user_id, text: text,
+          pts: pts, pts_count: pts_count, date: date)
+      end
+
+      class << self
+        private
+
+        def read_tl_string(bytes, offset)
+          first_byte = bytes.getbyte(offset)
+          if first_byte == 254
+            len = bytes.getbyte(offset + 1) |
+                  (bytes.getbyte(offset + 2) << 8) |
+                  (bytes.getbyte(offset + 3) << 16)
+            total = 4 + len
+          else
+            len = first_byte
+            total = 1 + len
+          end
+          padding = (4 - (total % 4)) % 4
+          [bytes[offset + (total - len), len], offset + total + padding]
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/updates_difference.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class UpdatesDifference
+      CONSTRUCTOR_EMPTY = 0x5d75a138
+      CONSTRUCTOR_DIFFERENCE = 0x00f49ca0
+      CONSTRUCTOR_SLICE = 0xa8fb1981
+      CONSTRUCTOR_TOO_LONG = 0x4afe8f6d
+
+      attr_reader :type, :date, :seq, :new_messages, :users, :pts, :state
+
+      def initialize(type:, date: nil, seq: nil, new_messages: [], users: [], pts: nil, state: nil)
+        @type = type
+        @date = date
+        @seq = seq
+        @new_messages = new_messages
+        @users = users
+        @pts = pts
+        @state = state
+      end
+
+      def self.parse(data)
+        constructor = data[0, 4].unpack1('L<')
+
+        case constructor
+        when CONSTRUCTOR_EMPTY
+          parse_empty(data)
+        when CONSTRUCTOR_DIFFERENCE, CONSTRUCTOR_SLICE
+          parse_difference(data, constructor)
+        when CONSTRUCTOR_TOO_LONG
+          new(type: :too_long, pts: data[4, 4].unpack1('L<'))
+        else
+          warn "Unknown Difference constructor: 0x#{constructor.to_s(16)}, treating as empty"
+          new(type: :empty, date: Time.now.to_i, seq: 0)
+        end
+      end
+
+      class << self
+        private
+
+        def parse_empty(data)
+          new(
+            type: :empty,
+            date: data[4, 4].unpack1('L<'),
+            seq: data[8, 4].unpack1('L<')
+          )
+        end
+
+        def parse_difference(data, constructor)
+          offset = 4
+
+          messages, offset = parse_messages_vector(data, offset)
+          offset = skip_vector(data, offset) # encrypted_messages
+          offset = skip_vector(data, offset) # other_updates
+          offset = skip_vector(data, offset) # chats
+          users, = parse_users_vector(data, offset)
+
+          new(
+            type: constructor == CONSTRUCTOR_DIFFERENCE ? :difference : :slice,
+            new_messages: messages,
+            users: users
+          )
+        end
+
+        def parse_messages_vector(data, offset)
+          offset += 4 # vector constructor
+          count = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          messages = []
+          count.times do
+            msg, offset = parse_message(data, offset)
+            messages << msg if msg
+          end
+          [messages, offset]
+        end
+
+        def parse_message(data, offset)
+          msg_constructor = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          return [nil, offset] unless msg_constructor == 0x452c0e65
+
+          flags = data[offset, 4].unpack1('L<')
+          offset += 4
+          id = data[offset, 4].unpack1('L<')
+          offset += 4
+          offset += 12 if flags.anybits?(1 << 8) # from_id
+          offset += 4 if flags.anybits?(1 << 29) # from_boosts_applied
+          offset += 12 # peer_id
+          offset += 8 if flags.anybits?(1 << 11) # via_bot_id
+          date = data[offset, 4].unpack1('L<')
+          offset += 4
+          message_text, offset = read_tl_string(data, offset)
+
+          [{ id: id, date: date, message: message_text, flags: flags }, offset]
+        rescue StandardError
+          [nil, offset]
+        end
+
+        def parse_users_vector(data, offset)
+          offset += 4 # vector constructor
+          count = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          users = []
+          count.times do
+            user_constructor = data[offset, 4].unpack1('L<')
+            offset += 4
+            next unless user_constructor == 0x20b1422
+
+            flags = data[offset, 4].unpack1('L<')
+            offset += 4
+            offset += 4 # flags2
+            user_id = data[offset, 8].unpack1('Q<')
+            offset += 8
+
+            access_hash = nil
+            if flags.anybits?(1 << 0)
+              access_hash = data[offset, 8].unpack1('Q<')
+              offset += 8
+            end
+
+            users << { id: user_id, access_hash: access_hash }
+          rescue StandardError
+            break
+          end
+          [users, offset]
+        end
+
+        def skip_vector(data, offset)
+          offset += 4 # vector constructor
+          count = data[offset, 4].unpack1('L<')
+          offset += 4
+          count.times { offset += 4 }
+          offset
+        end
+
+        def read_tl_string(data, offset)
+          first_byte = data.getbyte(offset)
+          if first_byte == 254
+            len = data.getbyte(offset + 1) |
+                  (data.getbyte(offset + 2) << 8) |
+                  (data.getbyte(offset + 3) << 16)
+            total = 4 + len
+          else
+            len = first_byte
+            total = 1 + len
+          end
+          padding = (4 - (total % 4)) % 4
+          [data[offset + (total - len), len], offset + total + padding]
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/updates_state.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class UpdatesState
+      CONSTRUCTOR = 0xa56c2a3e
+
+      attr_accessor :pts, :qts, :date, :seq, :unread_count
+
+      def initialize(pts:, qts:, date:, seq:, unread_count:)
+        @pts = pts
+        @qts = qts
+        @date = date
+        @seq = seq
+        @unread_count = unread_count
+      end
+
+      def self.parse(data)
+        constructor = data[0, 4].unpack1('L<')
+        raise UnexpectedConstructorError, constructor unless constructor == CONSTRUCTOR
+
+        offset = 4
+        pts = data[offset, 4].unpack1('L<')
+        offset += 4
+        qts = data[offset, 4].unpack1('L<')
+        offset += 4
+        date = data[offset, 4].unpack1('L<')
+        offset += 4
+        seq = data[offset, 4].unpack1('L<')
+        offset += 4
+        unread_count = data[offset, 4].unpack1('L<')
+
+        new(pts: pts, qts: qts, date: date, seq: seq, unread_count: unread_count)
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/users.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class Users
+      VECTOR_CONSTRUCTOR = 0x1cb5c415
+      USER_CONSTRUCTOR = 0x020b1422
+
+      User = Struct.new(:id, :access_hash, :first_name, :last_name, :username, :phone, :flags, :flags2,
+        keyword_init: true)
+
+      def self.parse(data)
+        constructor = data[0, 4].unpack1('L<')
+        raise "Expected Vector constructor, got 0x#{constructor.to_s(16)}" unless constructor == VECTOR_CONSTRUCTOR
+
+        offset = 4
+        count = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        users = []
+        count.times do
+          user_constructor = data[offset, 4].unpack1('L<')
+          offset += 4
+          next unless user_constructor == USER_CONSTRUCTOR
+
+          flags = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          flags2 = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          id = data[offset, 8].unpack1('Q<')
+          offset += 8
+
+          access_hash = nil
+          if flags.anybits?(1 << 0)
+            access_hash = data[offset, 8].unpack1('Q<')
+            offset += 8
+          end
+
+          first_name = nil
+          first_name, offset = read_tl_string(data, offset) if flags.anybits?(1 << 1)
+
+          last_name = nil
+          last_name, offset = read_tl_string(data, offset) if flags.anybits?(1 << 2)
+
+          username = nil
+          username, offset = read_tl_string(data, offset) if flags.anybits?(1 << 3)
+
+          phone = nil
+          phone, offset = read_tl_string(data, offset) if flags.anybits?(1 << 4)
+
+          users << User.new(
+            id: id, access_hash: access_hash,
+            first_name: first_name, last_name: last_name,
+            username: username, phone: phone,
+            flags: flags, flags2: flags2
+          )
+
+          break
+        end
+
+        users
+      end
+
+      class << self
+        private
+
+        def read_tl_string(data, offset)
+          first_byte = data.getbyte(offset)
+          if first_byte == 254
+            len = data.getbyte(offset + 1) |
+                  (data.getbyte(offset + 2) << 8) |
+                  (data.getbyte(offset + 3) << 16)
+            total = 4 + len
+          else
+            len = first_byte
+            total = 1 + len
+          end
+          padding = (4 - (total % 4)) % 4
+          [data[offset + (total - len), len], offset + total + padding]
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/transport/abridged_packet_codec.rb

@@ -6,29 +6,52 @@ module MTProto
       TAG = "\xef".b
       OBFUSCATE_TAG = "\xef\xef\xef\xef".b
 
-      def encode_packet(data)
-        length = data.bytesize >> 2
+      def initialize(stream)
+        @stream = stream
+      end
+
+      def send(packet)
+        length = packet.size >> 2
 
-        length_prefix = if length < 127
-          [length].pack('C')
+        if length < 127
+          @stream.write [length].pack('C')
         else
-          "\x7f".b + [length].pack('L<')[0, 3]
+          @stream.write "\x7f".b + [length].pack('L<')[0, 3]
         end
 
-        length_prefix + data
+        @stream.write packet.data.pack('C*')
       end
 
-      def decode_packet(data)
-        length = data.unpack1('C')
-        offset = 1
+      MAX_PACKET_SIZE = 1_048_576
+
+      def scan
+        first_byte = read_exactly(1)
+        length = first_byte.unpack1('C')
 
         if length >= 127
-          length = (data[1, 3] + "\x00").unpack1('L<')
-          offset = 4
+          length_bytes = read_exactly(3)
+          length = "#{length_bytes}\x00".unpack1('L<')
         end
 
         actual_length = length << 2
-        data[offset, actual_length]
+
+        raise PacketReadError, "Packet too large: #{actual_length} bytes" if actual_length > MAX_PACKET_SIZE
+
+        data = read_exactly(actual_length)
+        Packet.new(data.bytes)
+      end
+
+      private
+
+      def read_exactly(bytes_needed)
+        result = ''.b
+        while result.bytesize < bytes_needed
+          chunk = @stream.read(bytes_needed - result.bytesize)
+          raise IOError, 'EOF while reading' if chunk.nil? || chunk.empty?
+
+          result += chunk
+        end
+        result
       end
     end
   end

data/lib/mtproto/transport/connection.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module MTProto
+  module Transport
+    class Connection
+      extend DelegateMethods
+
+      attr_reader :transport
+
+      def initialize(transport, wait_timeout: 60, read_timeout: 30)
+        @transport = transport
+        @transport.wait_timeout = wait_timeout
+        @transport.read_timeout = read_timeout
+      end
+
+      delegate :connect!, :disconnect!, :connected?, :not_connected?,
+        :send, :receive,
+        :wait_timeout, :wait_timeout=,
+        :read_timeout, :read_timeout=,
+        to: :transport
+    end
+  end
+end

data/lib/mtproto/transport/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module MTProto
+  module Transport
+    class ConnectionError < StandardError; end
+    class NotConnectedError < ConnectionError; end
+    class ConnectionClosedError < ConnectionError; end
+    class ReceiveTimeoutError < ConnectionError; end
+    class PacketReadError < ConnectionError; end
+  end
+end

data/lib/mtproto/transport/packet.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module MTProto
+  module Transport
+    class Packet
+      attr_reader :data
+
+      def initialize(data)
+        raise ArgumentError, 'data must be an Array' unless data.is_a?(Array)
+
+        @data = data
+      end
+
+      def size
+        data.length
+      end
+    end
+  end
+end