mtproto 0.0.14 → 0.0.17

data/lib/mtproto/auth_key_generator.rb

@@ -86,13 +86,13 @@ module MTProto
     private
 
     def send_and_receive(rpc, response_class)
-      message = Message.new(rpc.serialize)
+      message = UnencryptedMessage.new(rpc.serialize)
       @connection.send(Transport::Packet.new(message.bytes))
 
       response_packet = @connection.receive
       raise 'Receive timeout' if response_packet.nil?
 
-      result = response_class.deserialize(Message.parse(response_packet))
+      result = response_class.deserialize(UnencryptedMessage.parse(response_packet))
 
       raise 'Nonce mismatch!' if rpc.respond_to?(:nonce) && result.nonce != rpc.nonce
       raise 'Server nonce mismatch!' if rpc.respond_to?(:server_nonce) && result.server_nonce != rpc.server_nonce

data/lib/mtproto/client/api/export_authorization.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../../tl/objects/export_authorization'
+require_relative '../../tl/objects/exported_authorization'
+
+module MTProto
+  class Client
+    class API
+      def export_authorization(dc_id:)
+        rpc_call(
+          TL::ExportAuthorization.new(dc_id: dc_id),
+          TL::ExportedAuthorization
+        ).body
+      end
+    end
+  end
+end

data/lib/mtproto/client/api/import_authorization.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../../tl/objects/import_authorization'
+require_relative '../../tl/objects/authorization'
+
+module MTProto
+  class Client
+    class API
+      def import_authorization(id:, bytes:)
+        result = rpc_call(
+          TL::ImportAuthorization.new(id: id, bytes: bytes),
+          TL::Authorization
+        ).body
+
+        if result.authorization? && result.user_id
+          @client.update_user(user_id: result.user_id, access_hash: result.access_hash)
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/mtproto/client/api.rb

@@ -2,6 +2,8 @@
 
 require_relative 'api/send_code'
 require_relative 'api/sign_in'
+require_relative 'api/export_authorization'
+require_relative 'api/import_authorization'
 require_relative 'api/export_login_token'
 require_relative 'api/import_login_token'
 require_relative 'api/check_password'

data/lib/mtproto/client/rpc.rb

@@ -1,11 +1,16 @@
 # frozen_string_literal: true
 
+require 'securerandom'
 require_relative '../message_id'
 require_relative 'rpc/response'
 
 module MTProto
   class Client
     class RPC
+      MSGS_ACK = 0x62d6b459
+      VECTOR = 0x1cb5c415
+      PING_DELAY_DISCONNECT = 0xf3427b8c
+
       attr_reader :pending_requests
 
       def initialize(client)
@@ -66,6 +71,34 @@ module MTProto
         @pending_requests.clear
       end
 
+      # Acknowledge received server messages (msgs_ack). Without this the server
+      # keeps the unacknowledged messages, resends them, and drops the connection
+      # after a fixed window. Fire-and-forget — no rpc_result is expected.
+      def send_ack(msg_ids)
+        return if msg_ids.nil? || msg_ids.empty?
+
+        send_encrypted(self.class.ack_body(msg_ids), content_related: false)
+      end
+
+      # Keepalive: ping_delay_disconnect asks the server to disconnect us only if
+      # we stop pinging within disconnect_delay seconds. Fire-and-forget (the pong
+      # is ignored by process_message).
+      def send_ping(disconnect_delay = 75)
+        send_encrypted(self.class.ping_body(SecureRandom.random_number(2**63), disconnect_delay),
+          content_related: false)
+      end
+
+      # Serialized msgs_ack body (no envelope) — extracted for unit testing.
+      def self.ack_body(msg_ids)
+        [MSGS_ACK].pack('L<') + [VECTOR].pack('L<') + [msg_ids.length].pack('L<') +
+          msg_ids.map { |id| [id].pack('Q<') }.join
+      end
+
+      # Serialized ping_delay_disconnect body (no envelope) — extracted for testing.
+      def self.ping_body(ping_id, disconnect_delay)
+        [PING_DELAY_DISCONNECT].pack('L<') + [ping_id].pack('Q<') + [disconnect_delay].pack('l<')
+      end
+
       private
 
       def serialize_request(request)

data/lib/mtproto/client.rb

@@ -20,7 +20,7 @@ module MTProto
   class Client
     extend DelegateMethods
 
-    API_LAYER = 214
+    API_LAYER = 227
 
     attr_reader :connection, :server_key, :auth_key, :server_salt, :time_offset, :session,
       :timeout, :user_id, :access_hash, :dc_number
@@ -77,10 +77,17 @@ module MTProto
       @lang_code = 'en'
 
       @receiver_task = nil
+      @keepalive_task = nil
+      @ack_ids = []
       @running = false
       @on_update_callbacks = []
     end
 
+    # Keepalive cadence: flush pending acks every ACK_INTERVAL seconds, send a
+    # ping every PING_INTERVAL seconds.
+    ACK_INTERVAL = 5
+    PING_INTERVAL = 30
+
     def on_update(&block)
       @on_update_callbacks << block
     end
@@ -111,6 +118,7 @@ module MTProto
       raise 'Mainloop already running' if @running
 
       @running = true
+      @ack_ids = []
       @receiver_task = Async do
         @connection.receive do |packet, error|
           if error
@@ -124,15 +132,20 @@ module MTProto
             sender: :server
           )
 
+          collect_ack(decrypted[:msg_id], decrypted[:seq_no], decrypted[:body])
           process_message(decrypted[:body])
         end
       end
+      @keepalive_task = Async { keepalive_loop }
     end
 
     def disconnect!
       @running = false
+      @keepalive_task&.stop
+      @keepalive_task = nil
       @receiver_task&.stop
       @receiver_task = nil
+      @ack_ids = []
 
       rpc.signal_all_error(Transport::ConnectionError.new('Client shutting down'))
 
@@ -232,6 +245,46 @@ module MTProto
 
     private
 
+    # Periodically acknowledge received messages and ping, so the server doesn't
+    # drop a long-lived connection. Ends when the connection dies (the wrapper
+    # reconnects) or when the task is stopped on disconnect!.
+    def keepalive_loop
+      elapsed = 0
+      loop do
+        sleep ACK_INTERVAL
+        flush_acks
+        elapsed += ACK_INTERVAL
+        next if elapsed < PING_INTERVAL
+
+        elapsed = 0
+        rpc.send_ping
+      end
+    rescue StandardError
+      nil
+    end
+
+    # Queue msg_ids of received content-related server messages for msgs_ack.
+    # A container carries its own inner msg_ids; content-related messages have an
+    # odd seq_no and must be acknowledged (acks/pongs are even and need none).
+    def collect_ack(msg_id, seq_no, body)
+      constructor = body[0, 4].unpack1('L<')
+      if constructor == TL::Constructors::MSG_CONTAINER
+        TL::MsgContainer.deserialize(body).messages.each do |msg|
+          collect_ack(msg[:msg_id], msg[:seqno], msg[:body])
+        end
+      elsif seq_no.odd?
+        @ack_ids << msg_id
+      end
+    end
+
+    def flush_acks
+      return if @ack_ids.empty?
+
+      ids = @ack_ids
+      @ack_ids = []
+      rpc.send_ack(ids)
+    end
+
     def process_message(response_body)
       constructor = response_body[0, 4].unpack1('L<')
 

data/lib/mtproto/file_downloader.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative 'tl/objects/get_file'
+require_relative 'tl/objects/raw_response'
+
+module MTProto
+  # Downloads a file's bytes via upload.getFile, handling the case where the file
+  # lives on a DC other than the home client's. For a foreign DC it opens one
+  # extra connection to that DC, transfers the home authorization there
+  # (auth.exportAuthorization on the home client + auth.importAuthorization on the
+  # new connection) and runs getFile on it. A FILE_MIGRATE_X reply is honoured the
+  # same way. DC addresses come from help.getConfig — never hardcoded, since test
+  # DC addresses and ports differ from prod and change over time.
+  class FileDownloader
+    CHUNK = 1024 * 1024
+    DC_OPTION_IPV6 = 1 << 0
+    DC_OPTION_CDN = 1 << 3
+
+    # home: a connected, authorized Client whose receiver loop is already running.
+    # dc_options: help.getConfig dc_options (e.g. Client#init_connection! result).
+    # public_key / test_mode: used to handshake fresh connections to other DCs.
+    def initialize(home, dc_options:, public_key:, test_mode: false)
+      @home = home
+      @dc_options = dc_options
+      @public_key = public_key
+      @test_mode = test_mode
+      @subs = {}
+    end
+
+    # location: { id:, access_hash:, file_reference:, thumb_size: }.
+    # dc_id: the DC that stores the file. type: :photo or :document.
+    def download(location, dc_id:, type: :document)
+      client = client_for(dc_id)
+      read_all(client, location, type)
+    rescue RpcError => e
+      migrate = e.error_message.to_s[/\AFILE_MIGRATE_(\d+)\z/, 1]
+      raise unless migrate
+
+      # client_for, not connection_to: a migrate back to the home DC must reuse
+      # @home — exporting authorization to your own DC answers DC_ID_INVALID.
+      read_all(client_for(migrate.to_i), location, type)
+    end
+
+    # Tear down the extra DC connections opened for downloads.
+    def close
+      @subs.each_value(&:disconnect!)
+      @subs.clear
+    end
+
+    private
+
+    def client_for(dc_id)
+      dc_id == @home.dc_number ? @home : connection_to(dc_id)
+    end
+
+    def read_all(client, location, type)
+      data = +''
+      offset = 0
+      loop do
+        req = TL::GetFile.new(location: location, type: type, offset: offset, limit: CHUNK)
+        resp = client.rpc.call(req, TL::RawResponse).wait!(client.timeout)
+        unless resp.constructor_name == 'upload.file'
+          raise UnexpectedConstructorError, resp.raw_bytes[0, 4].unpack1('L<')
+        end
+
+        chunk = upload_file_bytes(resp.raw_bytes)
+        data << chunk
+        break if chunk.bytesize < CHUNK
+
+        offset += chunk.bytesize
+      end
+      data
+    end
+
+    # One authorized connection per foreign DC, reused across calls.
+    def connection_to(dc_id)
+      @subs[dc_id] ||= begin
+        sub = Client.new(
+          api_id: @home.api_id, api_hash: @home.api_hash,
+          host: dc_host(dc_id), port: dc_port(dc_id),
+          public_key: @public_key, dc_number: dc_id, test_mode: @test_mode
+        )
+        sub.connect!
+        sub.exchange_keys!
+        sub.start_receiving!
+        sub.init_connection!
+        exported = @home.api.export_authorization(dc_id: dc_id)
+        sub.api.import_authorization(id: exported.id, bytes: exported.bytes)
+        sub
+      end
+    end
+
+    def dc_option(dc_id)
+      @dc_options.find { |o| o[:id] == dc_id && o[:flags].to_i.nobits?(DC_OPTION_IPV6 | DC_OPTION_CDN) } ||
+        @dc_options.find { |o| o[:id] == dc_id } ||
+        raise(ArgumentError, "no DC option for dc_id=#{dc_id}")
+    end
+
+    def dc_host(dc_id)
+      dc_option(dc_id)[:ip_address]
+    end
+
+    def dc_port(dc_id)
+      dc_option(dc_id)[:port]
+    end
+
+    # upload.file#096a18d5 type:storage.FileType mtime:int bytes:bytes — the type
+    # is a bare constructor, so the bytes string starts at a fixed offset.
+    def upload_file_bytes(raw)
+      offset = 12
+      first = raw.getbyte(offset)
+      if first == 254
+        len = raw.getbyte(offset + 1) | (raw.getbyte(offset + 2) << 8) | (raw.getbyte(offset + 3) << 16)
+        start = offset + 4
+      else
+        len = first
+        start = offset + 1
+      end
+      raw[start, len]
+    end
+  end
+end