Added custom errors, fixes to code generator

The code generator now handles okay the flags using True type
Also, double checking for the flag is now avoided in cases where the
flag was a Vector type

api/settings_example

@@ -1,4 +1,4 @@
 api_id=12345
 api_hash=0123456789abcdef0123456789abcdef
-user_phone=34600000000
+user_phone=+34600000000
 session_name=anonymous

crypto/auth_key.py

@@ -1,6 +1,7 @@
 # This file is based on TLSharp
 # https://github.com/sochix/TLSharp/blob/master/TLSharp.Core/MTProto/Crypto/AuthKey.cs
 import utils
+from errors import *
 from utils import BinaryWriter, BinaryReader
 
 
@@ -11,7 +12,7 @@ class AuthKey:
         elif data:
             self.key = data
         else:
-            raise AssertionError('Either a gab integer or data bytes array must be provided')
+            raise InvalidParameterError('Either a gab integer or data bytes array must be provided')
 
         with BinaryReader(utils.sha1(self.key)) as reader:
             self.aux_hash = reader.read_long(signed=False)

errors.py

@@ -0,0 +1,82 @@
+class InvalidParameterError(Exception):
+    """Occurs when an invalid parameter is given, for example,
+    when either A or B are required but none is given"""
+
+
+class TypeNotFoundError(Exception):
+    """Occurs when a type is not found, for example,
+    when trying to read a TLObject with an invalid constructor code"""
+    def __init__(self, invalid_constructor_id):
+        super().__init__(self, 'Could not find a matching Constructor ID for the TLObject '
+                               'that was supposed to be read with ID {}. Most likely, a TLObject '
+                               'was trying to be read when it should not be read.'
+                               .format(hex(invalid_constructor_id)))
+
+        self.invalid_constructor_id = invalid_constructor_id
+
+
+class InvalidDCError(Exception):
+    def __init__(self, new_dc):
+        super().__init__(self,  'Your phone number is registered to #{} DC. '
+                                'This should have been handled automatically; '
+                                'if it has not, please restart the app.')
+
+        self.new_dc = new_dc
+
+
+class InvalidChecksumError(Exception):
+    def __init__(self, checksum, valid_checksum):
+        super().__init__(self,  'Invalid checksum ({} when {} was expected). This packet should be skipped.'
+                                .format(checksum, valid_checksum))
+
+        self.checksum = checksum
+        self.valid_checksum = valid_checksum
+
+
+class RPCError(Exception):
+    def __init__(self, message):
+        super().__init__(self, message)
+        self.message = message
+
+
+class BadMessageError(Exception):
+    """Occurs when handling a bad_message_notification"""
+    ErrorMessages = {
+        16: 'msg_id too low (most likely, client time is wrong it would be worthwhile to '
+            'synchronize it using msg_id notifications and re-send the original message '
+            'with the “correct” msg_id or wrap it in a container with a new msg_id if the '
+            'original message had waited too long on the client to be transmitted).',
+
+        17: 'msg_id too high (similar to the previous case, the client time has to be '
+            'synchronized, and the message re-sent with the correct msg_id).',
+
+        18: 'Incorrect two lower order msg_id bits (the server expects client message msg_id '
+            'to be divisible by 4).',
+
+        19: 'Container msg_id is the same as msg_id of a previously received message '
+            '(this must never happen).',
+
+        20: 'Message too old, and it cannot be verified whether the server has received a '
+            'message with this msg_id or not.',
+
+        32: 'msg_seqno too low (the server has already received a message with a lower '
+            'msg_id but with either a higher or an equal and odd seqno).',
+
+        33: 'msg_seqno too high (similarly, there is a message with a higher msg_id but with '
+            'either a lower or an equal and odd seqno).',
+
+        34: 'An even msg_seqno expected (irrelevant message), but odd received.',
+
+        35: 'Odd msg_seqno expected (relevant message), but even received.',
+
+        48: 'Incorrect server salt (in this case, the bad_server_salt response is received with '
+            'the correct salt, and the message is to be re-sent with it).',
+
+        64: 'Invalid container.'
+    }
+
+    def __init__(self, code):
+        super().__init__(self, BadMessageError
+                         .ErrorMessages.get(code,'Unknown error code (this should not happen): {}.'.format(code)))
+
+        self.code = code

main.py

@@ -16,6 +16,9 @@ if __name__ == '__main__':
 
         client.connect()
         if not client.is_user_authorized():
+            phone_code_hash = None
+            while phone_code_hash is None:
                 phone_code_hash = client.send_code_request(settings['user_phone'])
+
             code = input('Enter the code you just received: ')
             client.make_auth(settings['user_phone'], phone_code_hash, code)

network/mtproto_sender.py

@@ -1,7 +1,8 @@
 # This file is based on TLSharp
 # https://github.com/sochix/TLSharp/blob/master/TLSharp.Core/Network/MtProtoSender.cs
 import re
-import zlib
+import gzip
+from errors import *
 from time import sleep
 
 import utils
@@ -64,27 +65,26 @@ class MtProtoSender:
         """Sends the given packet bytes with the additional information of the original request"""
         request.msg_id = self.session.get_new_msg_id()
 
-        # First calculate the ciphered bit
-        with BinaryWriter() as writer:
-            writer.write_long(self.session.salt, signed=False)
-            writer.write_long(self.session.id, signed=False)
-            writer.write_long(request.msg_id)
-            writer.write_int(self.generate_sequence(request.confirmed))
-            writer.write_int(len(packet))
-            writer.write(packet)
+        # First calculate plain_text to encrypt it
+        with BinaryWriter() as plain_writer:
+            plain_writer.write_long(self.session.salt, signed=False)
+            plain_writer.write_long(self.session.id, signed=False)
+            plain_writer.write_long(request.msg_id)
+            plain_writer.write_int(self.generate_sequence(request.confirmed))
+            plain_writer.write_int(len(packet))
+            plain_writer.write(packet)
 
-            msg_key = utils.calc_msg_key(writer.get_bytes())
+            msg_key = utils.calc_msg_key(plain_writer.get_bytes())
 
             key, iv = utils.calc_key(self.session.auth_key.key, msg_key, True)
-            cipher_text = AES.encrypt_ige(writer.get_bytes(), key, iv)
+            cipher_text = AES.encrypt_ige(plain_writer.get_bytes(), key, iv)
 
-        # And then finally send the packet
-        with BinaryWriter() as writer:
-            writer.write_long(self.session.auth_key.key_id, signed=False)
-            writer.write(msg_key)
-            writer.write(cipher_text)
-
-            self.transport.send(writer.get_bytes())
+        # And then finally send the encrypted packet
+        with BinaryWriter() as cipher_writer:
+            cipher_writer.write_long(self.session.auth_key.key_id, signed=False)
+            cipher_writer.write(msg_key)
+            cipher_writer.write(cipher_text)
+            self.transport.send(cipher_writer.get_bytes())
 
     def decode_msg(self, body):
         """Decodes an received encrypted message body bytes"""
@@ -125,7 +125,7 @@ class MtProtoSender:
             return self.handle_container(msg_id, sequence, reader, request)
         if code == 0x7abe77ec:  # Ping
             return self.handle_ping(msg_id, sequence, reader)
-        if code == 0x347773c5:  # pong
+        if code == 0x347773c5:  # Pong
             return self.handle_pong(msg_id, sequence, reader)
         if code == 0xae500895:  # future_salts
             return self.handle_future_salts(msg_id, sequence, reader)
@@ -174,7 +174,12 @@ class MtProtoSender:
                 if not self.process_msg(inner_msg_id, sequence, reader, request):
                     reader.set_position(begin_position + inner_length)
 
-            except:
+            except Exception as error:
+                if error is InvalidDCError:
+                    print('Re-raise {}'.format(error))
+                    raise error
+                else:
+                    print('Error while handling container {}: {}'.format(type(error), error))
                     reader.set_position(begin_position + inner_length)
 
         return False
@@ -216,42 +221,9 @@ class MtProtoSender:
         code = reader.read_int(signed=False)
         request_id = reader.read_long(signed=False)
         request_sequence = reader.read_int()
+
         error_code = reader.read_int()
-
-        if error_code == 16:
-            raise RuntimeError("msg_id too low (most likely, client time is wrong it would be worthwhile to "
-                               "synchronize it using msg_id notifications and re-send the original message "
-                               "with the “correct” msg_id or wrap it in a container with a new msg_id if the "
-                               "original message had waited too long on the client to be transmitted)")
-        if error_code == 17:
-            raise RuntimeError("msg_id too high (similar to the previous case, the client time has to be "
-                               "synchronized, and the message re-sent with the correct msg_id)")
-        if error_code == 18:
-            raise RuntimeError("Incorrect two lower order msg_id bits (the server expects client message msg_id "
-                               "to be divisible by 4)")
-        if error_code == 19:
-            raise RuntimeError("Container msg_id is the same as msg_id of a previously received message "
-                               "(this must never happen)")
-        if error_code == 20:
-            raise RuntimeError("Message too old, and it cannot be verified whether the server has received a "
-                               "message with this msg_id or not")
-        if error_code == 32:
-            raise RuntimeError("msg_seqno too low (the server has already received a message with a lower "
-                               "msg_id but with either a higher or an equal and odd seqno)")
-        if error_code == 33:
-            raise RuntimeError("msg_seqno too high (similarly, there is a message with a higher msg_id but with "
-                               "either a lower or an equal and odd seqno)")
-        if error_code == 34:
-            raise RuntimeError("An even msg_seqno expected (irrelevant message), but odd received")
-        if error_code == 35:
-            raise RuntimeError("Odd msg_seqno expected (relevant message), but even received")
-        if error_code == 48:
-            raise RuntimeError("Incorrect server salt (in this case, the bad_server_salt response is received with "
-                               "the correct salt, and the message is to be re-sent with it)")
-        if error_code == 64:
-            raise RuntimeError("Invalid container")
-
-        raise NotImplementedError('This should never happen!')
+        raise BadMessageError(error_code)
 
     def hangle_msg_detailed_info(self, msg_id, sequence, reader):
         return False
@@ -262,8 +234,6 @@ class MtProtoSender:
 
         if request_id == mtproto_request.msg_id:
             mtproto_request.confirm_received = True
-        else:
-            print('We did not get the ID we expected. Got {}, but it should have been {}'.format(request_id, mtproto_request.msg_id))
 
         inner_code = reader.read_int(signed=False)
         if inner_code == 0x2144ca19:  # RPC Error
@@ -277,21 +247,14 @@ class MtProtoSender:
 
             elif error_msg.startswith('PHONE_MIGRATE_'):
                 dc_index = int(re.search(r'\d+', error_msg).group(0))
-                raise ConnectionError('Your phone number is registered to {} DC. Please update settings. '
-                                      'See https://github.com/sochix/TLSharp#i-get-an-error-migrate_x '
-                                      'for details.'.format(dc_index))
+                raise InvalidDCError(dc_index)
             else:
-                raise ValueError(error_msg)
+                raise RPCError(error_msg)
 
         elif inner_code == 0x3072cfa1:  # GZip packed
-            try:
-                packed_data = reader.tgread_bytes()
-                unpacked_data = zlib.decompress(packed_data)
-
+            unpacked_data = gzip.decompress(reader.tgread_bytes())
             with BinaryReader(unpacked_data) as compressed_reader:
                 mtproto_request.on_response(compressed_reader)
-            except:
-                pass
 
         else:
             reader.seek(-4)
@@ -300,7 +263,7 @@ class MtProtoSender:
     def handle_gzip_packed(self, msg_id, sequence, reader, mtproto_request):
         code = reader.read_int(signed=False)
         packed_data = reader.tgread_bytes()
-        unpacked_data = zlib.decompress(packed_data)
+        unpacked_data = gzip.decompress(packed_data)
 
         with BinaryReader(unpacked_data) as compressed_reader:
             self.process_msg(msg_id, sequence, compressed_reader, mtproto_request)

network/tcp_client.py

@@ -19,7 +19,7 @@ class TcpClient:
 
     def write(self, data):
         """Writes (sends) the specified bytes to the connected peer"""
-        self.socket.send(data)
+        self.socket.sendall(data)
 
     def read(self, buffer_size):
         """Reads (receives) the specified bytes from the connected peer"""

network/tcp_message.py

@@ -2,6 +2,7 @@
 # https://github.com/sochix/TLSharp/blob/master/TLSharp.Core/Network/TcpMessage.cs
 from utils import BinaryWriter, BinaryReader
 from binascii import crc32
+from errors import *
 
 
 class TcpMessage:
@@ -11,7 +12,7 @@ class TcpMessage:
         :param body: Message body byte array
         """
         if body is None:
-            raise ValueError('body cannot be None')
+            raise InvalidParameterError('body cannot be None')
 
         self.sequence_number = seq_number
         self.body = body
@@ -40,15 +41,15 @@ class TcpMessage:
     def decode(body):
         """Returns a TcpMessage from the given encoded bytes, decoding them previously"""
         if body is None:
-            raise ValueError('body cannot be None')
+            raise InvalidParameterError('body cannot be None')
 
         if len(body) < 12:
-            raise ValueError('Wrong size of input packet')
+            raise InvalidParameterError('Wrong size of input packet')
 
         with BinaryReader(body) as reader:
             packet_len = int.from_bytes(reader.read(4), byteorder='little')
             if packet_len < 12:
-                raise ValueError('Invalid packet length: {}'.format(packet_len))
+                raise InvalidParameterError('Invalid packet length in body: {}'.format(packet_len))
 
             seq = reader.read_int()
             packet = reader.read(packet_len - 12)
@@ -56,6 +57,6 @@ class TcpMessage:
 
             valid_checksum = crc32(body[:packet_len - 4])
             if checksum != valid_checksum:
-                raise ValueError('Invalid checksum, skip')
+                raise InvalidChecksumError(checksum, valid_checksum)
 
             return TcpMessage(seq, packet)

network/tcp_transport.py

@@ -2,6 +2,7 @@
 # https://github.com/sochix/TLSharp/blob/master/TLSharp.Core/Network/TcpTransport.cs
 from network import TcpMessage, TcpClient
 from binascii import crc32
+from errors import *
 
 
 class TcpTransport:
@@ -42,7 +43,7 @@ class TcpTransport:
         valid_checksum = crc32(rv)
 
         if checksum != valid_checksum:
-            raise ValueError('Invalid checksum, skip')
+            raise InvalidChecksumError(checksum, valid_checksum)
 
         # If we passed the tests, we can then return a valid TcpMessage
         return TcpMessage(seq, body)

scheme.tl

@@ -1,9 +1,5 @@
 // Core types (no need to gen)
 
-// We handle some types in a special way
-//boolFalse#bc799737 = Bool;
-//boolTrue#997275b5 = Bool;
-//true#3fedd339 = True;
 //vector#1cb5c415 {t:Type} # [ t ] = Vector t;
 
 ///////////////////////////////
@@ -123,6 +119,13 @@ contest.saveDeveloperInfo#9a5f6e95 vk_id:int name:string phone_number:string age
 
 ---types---
 
+//boolFalse#bc799737 = Bool;
+//boolTrue#997275b5 = Bool;
+
+//true#3fedd339 = True;
+
+//vector#1cb5c415 {t:Type} # [ t ] = Vector t;
+
 error#c4b9f9bb code:int text:string = Error;
 
 null#56730bcc = Null;

tl/telegram_client.py

@@ -6,13 +6,13 @@ import platform
 import utils
 import network.authenticator
 from network import MtProtoSender, TcpTransport
+from errors import *
 
 from tl import Session
 from tl.types import InputPeerUser
 from tl.functions import InvokeWithLayerRequest, InitConnectionRequest
 from tl.functions.help import GetConfigRequest
 from tl.functions.auth import CheckPhoneRequest, SendCodeRequest, SignInRequest
-from tl.functions.contacts import GetContactsRequest
 from tl.functions.messages import SendMessageRequest
 
 
@@ -84,6 +84,7 @@ class TelegramClient:
         return request.result.phone_registered
 
     def send_code_request(self, phone_number):
+        """May return None if an error occured!"""
         request = SendCodeRequest(phone_number, self.api_id, self.api_hash)
         completed = False
         while not completed:
@@ -91,15 +92,15 @@ class TelegramClient:
                 self.sender.send(request)
                 self.sender.receive(request)
                 completed = True
-            except ConnectionError as error:
-                if str(error).startswith('Your phone number is registered to'):
-                    dc = int(re.search(r'\d+', str(error)).group(0))
-                    self.reconnect_to_dc(dc)
-                else:
-                    raise error
+            except InvalidDCError as error:
+                self.reconnect_to_dc(error.new_dc)
 
+        if request.result is None:
+            return None
+        else:
             return request.result.phone_code_hash
 
+
     def make_auth(self, phone_number, phone_code_hash, code):
         request = SignInRequest(phone_number, phone_code_hash, code)
         self.sender.send(request)
@@ -111,12 +112,6 @@ class TelegramClient:
 
         return self.session.user
 
-    def import_contacts(self, phone_code_hash):
-        request = GetContactsRequest(phone_code_hash)
-        self.sender.send(request)
-        self.sender.receive(request)
-        return request.result.contacts, request.result.users
-
     def send_message(self, user, message):
         peer = InputPeerUser(user.id, user.access_hash)
         request = SendMessageRequest(peer, message, utils.generate_random_long())

tl_generator.py

@@ -101,9 +101,10 @@ def generate_tlobjects(scheme_file):
                     builder.writeln('"""')
 
                 builder.writeln('super().__init__()')
-                # Functions have a result object
+                # Functions have a result object and are confirmed by default
                 if tlobject.is_function:
                     builder.writeln('self.result = None')
+                    builder.writeln('self.confirmed = True  # Confirmed by default')
 
                 # Set the arguments
                 if args:
@@ -215,8 +216,12 @@ def write_onsend_code(builder, arg, args, name=None):
     if name is None:
         name = 'self.{}'.format(arg.name)
 
-    # The argument may be a flag, only write if it's not None!
+    # The argument may be a flag, only write if it's not None AND if it's not a True type
+    # True types are not actually sent, but instead only used to determine the flags
     if arg.is_flag:
+        if arg.type == 'true':
+            return  # Exit, since True type is never written
+        else:
             builder.writeln('if {} is not None:'.format(name))
 
     if arg.is_vector:
@@ -262,7 +267,7 @@ def write_onsend_code(builder, arg, args, name=None):
         builder.writeln('writer.tgwrite_bool({})'.format(name))
 
     elif 'true' == arg.type:  # Awkwardly enough, Telegram has both bool and "true", used in flags
-        builder.writeln('writer.write_int(0x3fedd339)  # true')
+        pass  # These are actually NOT written! Only used for flags
 
     elif 'bytes' == arg.type:
         builder.writeln('writer.write({})'.format(name))
@@ -297,8 +302,12 @@ def write_onresponse_code(builder, arg, args, name=None):
         name = 'self.{}'.format(arg.name)
 
     # The argument may be a flag, only write that flag was given!
+    was_flag = False
     if arg.is_flag:
+        was_flag = True
         builder.writeln('if (flags & (1 << {})) != 0:'.format(arg.flag_index))
+        # Temporary disable .is_flag not to enter this if again when calling the method recursively
+        arg.is_flag = False
 
     if arg.is_vector:
         builder.writeln("reader.read_int()  # Vector's constructor ID")
@@ -338,21 +347,23 @@ def write_onresponse_code(builder, arg, args, name=None):
         builder.writeln('{} = reader.tgread_bool()'.format(name))
 
     elif 'true' == arg.type:  # Awkwardly enough, Telegram has both bool and "true", used in flags
-        builder.writeln('{} = reader.read_int() == 0x3fedd339  # true'.format(name))
+        builder.writeln('{} = True  # Arbitrary not-None value, no need to read since it is a flag'.format(name))
 
     elif 'bytes' == arg.type:
         builder.writeln('{} = reader.read()'.format(name))
 
     else:
         # Else it may be a custom type
-        builder.writeln('{} = reader.tgread_object(reader)'.format(name))
+        builder.writeln('{} = reader.tgread_object()'.format(name))
 
     # End vector and flag blocks if required (if we opened them before)
     if arg.is_vector:
         builder.end_block()
 
-    if arg.is_flag:
+    if was_flag:
         builder.end_block()
+        # Restore .is_flag
+        arg.is_flag = True
 
 if __name__ == '__main__':
     if tlobjects_exist():

utils/binary_reader.py

@@ -1,6 +1,7 @@
 from io import BytesIO, BufferedReader
 from tl import tlobjects
 from struct import unpack
+from errors import *
 import inspect
 import os
 
@@ -16,7 +17,7 @@ class BinaryReader:
         elif stream:
             self.stream = stream
         else:
-            raise ValueError("Either bytes or a stream must be provided")
+            raise InvalidParameterError("Either bytes or a stream must be provided")
 
         self.reader = BufferedReader(self.stream)
 
@@ -96,11 +97,10 @@ class BinaryReader:
 
     def tgread_object(self):
         """Reads a Telegram object"""
-        constructor_id = self.read_int()
+        constructor_id = self.read_int(signed=False)
         clazz = tlobjects.get(constructor_id, None)
         if clazz is None:
-            raise ImportError('Could not find a matching ID for the TLObject that was supposed to be read. '
-                              'Found ID: {}'.format(hex(constructor_id)))
+            raise TypeNotFoundError(constructor_id)
 
         # Now we need to determine the number of parameters of the class, so we can
         # instantiate it with all of them set to None, and still, no need to write