mtproto 0.0.15 → 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.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

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