Merge lp:~libqtelegram-team/telegram-app/dev-lib-file-management-refactor into lp:telegram-app/dev

[Roberto Mier Escandon]

CHANGES:
- Created FileHandler class to hold all the file upload and download operations
- Moved to FileHandler all the Telegram class existent operations, taking care of not missing signal-slot connections
- Improved upload/download progress bar steps
- file management related raw pointers to QSharedPointer
- Created those QSharedPointer by defining a new type into the pointed class
- QLogging categories to have this name TG_<folder>_<class>
- m_foo to mFoo

TESTED
Send photo:
- regular chat, gallery
- regular chat, camera
- secret chat, gallery
- secret chat, camera

Send video:
- regular chat, gallery
- regular chat, camera
- secret chat, gallery
- secret chat, camera

Receive photo:
- regular chat, gallery
- secret chat, gallery

Receive video:
- regular chat, gallery
- secret chat, gallery

Sent a photo while a video is been downloaded:
Note: the progress bar does not update unless you exit and enter again in chat, but the download procress does not stop

Removed .cache/com.ubuntu.telegram/<phone> folder and checked that when app is started up, you can download by hand any photo or video that is not currently in disk

Pressed cancel in a downloading file and check the file download is cancelled

NOTES: not all pointer have been moved to QSharedPointer. Only those related with file handler.
This hardening should be completed by creating in a later step a SecretHandler to manage all secret chats operations

[Michał Karnicki (karni)]

It's a huge MP with a lot of noise from changed log tags, so I wouldn't be surprised if I missed something, but it looks good. I tested, and works great. Two thoughts left in-line.

review: Approve

=== modified file 'lib/CMakeLists.txt'
--- lib/CMakeLists.txt	2015-02-06 10:19:34 +0000
+++ lib/CMakeLists.txt	2015-02-24 14:12:31 +0000
@@ -6,10 +6,9 @@
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 add_definitions(-DLIBQTELEGRAM_LIBRARY)
 add_library(${LIB_NAME} SHARED
+    telegram.cpp
     core/connection.cpp
-    core/cryptoutils.cpp
     core/settings.cpp
-    core/utils.cpp
     core/inboundpkt.cpp
     core/outboundpkt.cpp
     core/dcprovider.cpp
@@ -17,29 +16,30 @@
     core/api.cpp
     core/query.cpp
     core/eventtimer.cpp
-    logic/downloadfile.cpp
-    logic/file.h
-    logic/uploadfile.cpp
-    telegram.cpp
     core/abstractapi.cpp
     core/session.cpp
     core/dcauth.cpp
     core/sessionmanager.cpp
-    core/asserter.cpp
+    util/asserter.cpp
+    util/cryptoutils.cpp
+    util/utils.cpp
     secret/decrypter.cpp
     secret/encrypter.cpp
     secret/secretstate.cpp
     secret/secretchat.cpp
-    secret/decryptedmessagebuilder.cpp)
+    secret/decryptedmessagebuilder.cpp
+    file/filehandler.cpp
+    file/downloadfile.cpp
+    file/uploadfile.cpp
+    file/fileoperation.h
+    file/file.h)
 set_property(TARGET ${LIB_NAME} PROPERTY COMPILE_FLAGS "${COMPILE_FLAGS} -fpermissive")
 set_target_properties(${LIB_NAME} PROPERTIES VERSION ${VERSION} SOVERSION 1)
 qt5_use_modules(${LIB_NAME} Network Multimedia)
 target_link_libraries(${LIB_NAME} ${OPENSSL_LDFLAGS})
 
-if (IS_DIRECTORY ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR})
 INSTALL(TARGETS ${LIB_NAME}
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
-endif()
 
 set(HEADERS
     telegram.h
@@ -64,8 +64,9 @@
 
 add_subdirectory(types)
 add_subdirectory(core)
-add_subdirectory(logic)
+add_subdirectory(file)
 add_subdirectory(secret)
+add_subdirectory(util)
 
 # make the .h files visible on qtcreator
 file(GLOB H_FILES *.h **/*.h)

=== modified file 'lib/core/CMakeLists.txt'
--- lib/core/CMakeLists.txt	2014-12-09 17:28:59 +0000
+++ lib/core/CMakeLists.txt	2015-02-24 14:12:31 +0000
@@ -1,25 +1,24 @@
 set (CORE_HEADERS
+    abstractapi.h
+    api.h
+    asserter.h
     connection.h
+    constants.h
     cryptoutils.h
-    settings.h
-    utils.h
-    constants.h
+    dc.h
+    dcauth.h
+    dcprovider.h
+    endpoint.h
+    eventtimer.h
     inboundpkt.h
     outboundpkt.h
-    dcprovider.h
-    eventtimer.h
-    dc.h
-    api.h
-    tlvalues.h
     query.h
     querymethods.h
-    abstractapi.h
     session.h
-    dcauth.h
-    endpoint.h
     sessionmanager.h
-    asserter.h
-    eventtimer.h)
+    settings.h
+    tlvalues.h
+    utils.h)
 
 if(NOT CLICK_MODE)
 INSTALL(FILES ${CORE_HEADERS}

=== modified file 'lib/core/api.cpp'
--- lib/core/api.cpp	2015-02-22 20:57:58 +0000
+++ lib/core/api.cpp	2015-02-24 14:12:31 +0000
@@ -21,9 +21,8 @@
 
 #include "api.h"
 
-#include "tlvalues.h"
+#include "util/tlvalues.h"
 #include "dcprovider.h"
-
 #include "secret/encrypter.h"
 
 Api::Api(Session *session, QObject *parent) :

=== removed file 'lib/core/asserter.cpp'
--- lib/core/asserter.cpp	2014-11-03 13:58:03 +0000
+++ lib/core/asserter.cpp	1970-01-01 00:00:00 +0000
@@ -1,28 +0,0 @@
-/*
- * Copyright 2014 Canonical Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors:
- *      Roberto Mier
- *      Tiago Herrmann
- */
-#include "asserter.h"
-
-Asserter::Asserter(QObject *parent) :
-    QObject(parent) {
-}
-
-void Asserter::check(bool condition) {
-    if (!condition) Q_EMIT fatalError();
-}

=== removed file 'lib/core/asserter.h'
--- lib/core/asserter.h	2014-11-03 13:58:03 +0000
+++ lib/core/asserter.h	1970-01-01 00:00:00 +0000
@@ -1,37 +0,0 @@
-/*
- * Copyright 2014 Canonical Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors:
- *      Roberto Mier
- *      Tiago Herrmann
- */
-#ifndef ASSERTER_H
-#define ASSERTER_H
-
-#include <QObject>
-
-class Asserter : public QObject
-{
-    Q_OBJECT
-public:
-    explicit Asserter(QObject *parent = 0);
-
-    void check(bool condition);
-
-Q_SIGNALS:
-    void fatalError();
-};
-
-#endif // ASSERTER_H

=== modified file 'lib/core/connection.cpp'
--- lib/core/connection.cpp	2014-09-29 12:33:11 +0000
+++ lib/core/connection.cpp	2015-02-24 14:12:31 +0000
@@ -20,13 +20,12 @@
  */
 
 #include "connection.h"
-#include "constants.h"
+#include "util/constants.h"
 #include <sys/socket.h>
 #include <netinet/tcp.h>
 #include <netinet/in.h>
 
-Q_LOGGING_CATEGORY(TG_NET_SOCKET, "tg.net.socket")
-
+Q_LOGGING_CATEGORY(TG_CORE_CONNECTION, "tg.core.connection")
 
 Connection::Connection(const QString &host, qint32 port, QObject *parent) :
     QTcpSocket(parent),
@@ -118,7 +117,7 @@
 QAbstractSocket::UnknownSocketError                 -1	An unidentified error occurred.
 */
 void Connection::onError(QAbstractSocket::SocketError error) {
-    qCWarning(TG_NET_SOCKET) << "SocketError:" << QString::number(error) << ",Description:" << errorString();
+    qCWarning(TG_CORE_CONNECTION) << "SocketError:" << QString::number(error) << ",Description:" << errorString();
 
     if (!mReconnectTimerId) {
         mReconnectTimerId = startTimer(RECONNECT_TIMEOUT);
@@ -127,7 +126,7 @@
 
 void Connection::timerEvent(QTimerEvent *) {
     if (state() != QAbstractSocket::ConnectingState && state() != QAbstractSocket::ConnectedState) {
-        qCWarning(TG_NET_SOCKET) << "Trying to reconect to host";
+        qCWarning(TG_CORE_CONNECTION) << "Trying to reconect to host";
         connectToServer();
     } else {
         stopReconnecting();

=== modified file 'lib/core/connection.h'
--- lib/core/connection.h	2014-09-29 12:33:11 +0000
+++ lib/core/connection.h	2015-02-24 14:12:31 +0000
@@ -28,10 +28,10 @@
 #include <QtNetwork/QTcpSocket>
 #include "endpoint.h"
 #include <QLoggingCategory>
-#include "constants.h"
-#include "asserter.h"
+#include "util/constants.h"
+#include "util/asserter.h"
 
-Q_DECLARE_LOGGING_CATEGORY(TG_NET_SOCKET)
+Q_DECLARE_LOGGING_CATEGORY(TG_CORE_CONNECTION)
 
 class Connection : public QTcpSocket, public Endpoint
 {

=== removed file 'lib/core/constants.h'
--- lib/core/constants.h	2015-01-28 08:01:23 +0000
+++ lib/core/constants.h	1970-01-01 00:00:00 +0000
@@ -1,79 +0,0 @@
-/*
- * Copyright 2014 Canonical Ltd.
- * Authors:
- *      Roberto Mier
- *      Tiago Herrmann
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef CONSTANTS_H
-#define CONSTANTS_H
-
-// macro to assert conditions as in debug as in release mode
-#define ASSERT(cond) ((!(cond)) ? qt_assert(#cond,__FILE__,__LINE__) : qt_noop())
-
-#define PACKET_BUFFER_SIZE (16384 * 100 + 16)
-#define ENCRYPT_BUFFER_INTS 16384
-#define DECRYPT_BUFFER_INTS 16384
-
-// These are the the original
-#define LIBQTELEGRAM_APP_HASH "c68fd5e560aa84dd4b6ad6f489164790"
-#define LIBQTELEGRAM_APP_ID 12433
-// These are the telegram-cli credentials
-//#define LIBQTELEGRAM_APP_HASH "36722c72256a24c1225de00eb6a1ca74"
-//#define LIBQTELEGRAM_APP_ID 2899
-// These are my second phone ones
-//#define LIBQTELEGRAM_APP_HASH "4b7f87d44de5e0a22248597939c848ae"
-//#define LIBQTELEGRAM_APP_ID 11986
-
-#define PRODUCTION_DEFAULT_DC_ID 4
-#define PRODUCTION_DEFAULT_DC_HOST "149.154.167.91"
-#define PRODUCTION_DEFAULT_DC_PORT 443
-#define TEST_DEFAULT_DC_ID 1
-#define TEST_DEFAULT_DC_HOST "173.240.5.253"
-#define TEST_DEFAULT_DC_PORT 80
-
-#define LIBQTELEGRAM_BUILD "001"
-#define LIBQTELEGRAM_VERSION "1.0.0-SNAPSHOT"
-
-#define MAX_RESPONSE_SIZE (1L << 24)
-
-#define MAX_MESSAGE_INTS 1048576
-
-#define MAX_PENDING_ACKS 16
-
-#define MAX_PACKED_SIZE (1 << 24)
-
-#define ACK_TIMEOUT 120000 //120 secs
-#define QUERY_TIMEOUT 60000 // 60 secs
-
-#define MAX_QUERY_RESENDS 10
-
-#define LANG_CODE "en"
-
-// divide file bytes into parts >= 128 kbytes. This is the minimum block size to ensurance receiving complete the users
-// profile and chat "photoBig" files.
-#define BLOCK (512 * 1024)
-
-#define RECONNECT_TIMEOUT 5000 // in case session hasn't connection, try to reconnect every 5 seconds
-
-#define UBUNTU_PHONE_TOKEN_TYPE 5 // used as token type when register and unregister device in telegram servers for push notifications
-
-#define DH_CONFIG_SERVER_RANDOM_LENGTH 256 // length we want to be a server generated random number
-#define SHARED_KEY_LENGTH 256 // length for the secret chat generated shared keys
-
-#define LAYER 17 // this value must be consistent with the TL_InvokeWithLayerX header in OutboundPkt.initConnection().
-
-#endif // CONSTANTS_H

=== removed file 'lib/core/cryptoutils.cpp'
--- lib/core/cryptoutils.cpp	2015-01-27 09:39:53 +0000
+++ lib/core/cryptoutils.cpp	1970-01-01 00:00:00 +0000
@@ -1,334 +0,0 @@
-/*
- * Copyright 2013 Vitaly Valtman
- * Copyright 2014 Canonical Ltd.
- * Authors:
- *      Roberto Mier
- *      Tiago Herrmann
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include "cryptoutils.h"
-
-#include "settings.h"
-#include "utils.h"
-#include <openssl/rand.h>
-#include <openssl/sha.h>
-#include <openssl/md5.h>
-
-CryptoUtils::CryptoUtils() {
-    BN_ctx = BN_CTX_new ();
-    Utils::ensurePtr(BN_ctx);
-}
-
-CryptoUtils::~CryptoUtils() {
-    if (BN_ctx) free(BN_ctx); //do this with a tfree method from Utils
-}
-
-CryptoUtils* CryptoUtils::getInstance() {
-    static CryptoUtils *instance = new CryptoUtils;
-    return instance;
-}
-
-qint32 CryptoUtils::encryptPacketBuffer(OutboundPkt &p, void *encryptBuffer) {
-    RSA *pubKey = Settings::getInstance()->pubKey();
-    return padRsaEncrypt((char *) p.buffer(), p.length() * 4, (char *) encryptBuffer, ENCRYPT_BUFFER_INTS * 4, pubKey->n, pubKey->e);
-}
-
-qint32 CryptoUtils::encryptPacketBufferAESUnAuth(const char serverNonce[16], const char hiddenClientNonce[32], OutboundPkt &p, void *encryptBuffer) {
-  initAESUnAuth (serverNonce, hiddenClientNonce, AES_ENCRYPT);
-  return padAESEncrypt ((char *) p.buffer(), p.length() * 4, (char *) encryptBuffer, ENCRYPT_BUFFER_INTS * 4);
-}
-
-qint32 CryptoUtils::padRsaEncrypt (char *from, qint32 from_len, char *to, qint32 size, BIGNUM *N, BIGNUM *E) {
-    qint32 pad = (255000 - from_len - 32) % 255 + 32;
-    qint32 chunks = (from_len + pad) / 255;
-    qint32 bits = BN_num_bits (N);
-    qint32 isSupported = RAND_pseudo_bytes ((uchar *) from + from_len, pad); // returns -1 if not supported
-    Q_UNUSED(bits);
-    Q_ASSERT(bits >= 2041 && bits <= 2048);
-    Q_ASSERT(from_len > 0 && from_len <= 2550);
-    Q_UNUSED(size);
-    Q_ASSERT(size >= chunks * 256);
-    Q_UNUSED(isSupported);
-    Q_ASSERT(isSupported >= 0);
-    qint32 i;
-    BIGNUM x, y;
-    BN_init (&x);
-    BN_init (&y);
-    for (i = 0; i < chunks; i++) {
-        BN_bin2bn ((uchar *) from, 255, &x);
-        qint32 success = BN_mod_exp (&y, &x, E, N, BN_ctx);
-        Q_UNUSED(success);
-        Q_ASSERT(success == 1);
-        unsigned l = 256 - BN_num_bytes (&y);
-        Q_ASSERT(l <= 256);
-        memset (to, 0, l);
-        BN_bn2bin (&y, (uchar *) to + l);
-        to += 256;
-    }
-    BN_free (&x);
-    BN_free (&y);
-    return chunks * 256;
-}
-
-void CryptoUtils::initAESUnAuth (const char serverNonce[16], const char hiddenClientNonce[32], qint32 encrypt) {
-    static uchar buffer[64], hash[20];
-    memcpy (buffer, hiddenClientNonce, 32);
-    memcpy (buffer + 32, serverNonce, 16);
-    SHA1 (buffer, 48, aes_key_raw);
-    memcpy (buffer + 32, hiddenClientNonce, 32);
-    SHA1 (buffer, 64, aes_iv + 8);
-    memcpy (buffer, serverNonce, 16);
-    memcpy (buffer + 16, hiddenClientNonce, 32);
-    SHA1 (buffer, 48, hash);
-    memcpy (aes_key_raw + 20, hash, 12);
-    memcpy (aes_iv, hash + 12, 8);
-    memcpy (aes_iv + 28, hiddenClientNonce, 4);
-    if (encrypt == AES_ENCRYPT) {
-        AES_set_encrypt_key (aes_key_raw, 32*8, &aes_key);
-    } else {
-        AES_set_decrypt_key (aes_key_raw, 32*8, &aes_key);
-    }
-    memset (aes_key_raw, 0, sizeof (aes_key_raw));
-}
-
-void CryptoUtils::initAESAuth (char authKey[192], char msgKey[16], qint32 encrypt) {
-    static uchar buffer[48], hash[20];
-    /*
-    Steps:
-    1) sha1_a = SHA1 (msg_key + substr (auth_key, 0, 32));
-    2) sha1_b = SHA1 (substr (auth_key, 32, 16) + msg_key + substr (auth_key, 48, 16));
-    3) sha1_с = SHA1 (substr (auth_key, 64, 32) + msg_key);
-    4) sha1_d = SHA1 (msg_key + substr (auth_key, 96, 32));
-    5) aes_key = substr (sha1_a, 0, 8) + substr (sha1_b, 8, 12) + substr (sha1_c, 4, 12);
-    6) aes_iv = substr (sha1_a, 8, 12) + substr (sha1_b, 0, 8) + substr (sha1_c, 16, 4) + substr (sha1_d, 0, 8);
-    */
-    memcpy (buffer, msgKey, 16);
-    memcpy (buffer + 16, authKey, 32);
-    SHA1 (buffer, 48, hash);
-    memcpy (aes_key_raw, hash, 8);
-    memcpy (aes_iv, hash + 8, 12);
-
-    memcpy (buffer, authKey + 32, 16);
-    memcpy (buffer + 16, msgKey, 16);
-    memcpy (buffer + 32, authKey + 48, 16);
-    SHA1 (buffer, 48, hash);
-    memcpy (aes_key_raw + 8, hash + 8, 12);
-    memcpy (aes_iv + 12, hash, 8);
-
-    memcpy (buffer, authKey + 64, 32);
-    memcpy (buffer + 32, msgKey, 16);
-    SHA1 (buffer, 48, hash);
-    memcpy (aes_key_raw + 20, hash + 4, 12);
-    memcpy (aes_iv + 20, hash + 16, 4);
-
-    memcpy (buffer, msgKey, 16);
-    memcpy (buffer + 16, authKey + 96, 32);
-    SHA1 (buffer, 48, hash);
-    memcpy (aes_iv + 24, hash, 8);
-
-    if (encrypt == AES_ENCRYPT) {
-        AES_set_encrypt_key (aes_key_raw, 32*8, &aes_key);
-    } else {
-        AES_set_decrypt_key (aes_key_raw, 32*8, &aes_key);
-    }
-    memset (aes_key_raw, 0, sizeof (aes_key_raw));
-}
-
-qint32 CryptoUtils::padAESEncrypt (const char *from, qint32 fromLen, char *to, qint32 size) {
-    qint32 paddedSize = (fromLen + 15) & -16;
-    Q_UNUSED(size);
-    Q_ASSERT(fromLen > 0 && paddedSize <= size);
-    if (fromLen < paddedSize) {
-        qint32 isRandSupported = RAND_pseudo_bytes ((uchar *) from + fromLen, paddedSize - fromLen);
-        Q_UNUSED(isRandSupported);
-        Q_ASSERT(isRandSupported >= 0);
-    }
-    AES_ige_encrypt ((uchar *) from, (uchar *) to, paddedSize, &aes_key, aes_iv, AES_ENCRYPT);
-    return paddedSize;
-}
-
-qint32 CryptoUtils::padAESDecrypt (const char *from, qint32 fromLen, char *to, qint32 size) {
-    if (fromLen <= 0 || fromLen > size || (fromLen & 15)) {
-        return -1;
-    }
-    AES_ige_encrypt ((const uchar *) from, (uchar *) to, fromLen, &aes_key, aes_iv, AES_DECRYPT);
-    return fromLen;
-}
-
-qint32 CryptoUtils::checkPrime (BIGNUM *p) {
-    qint32 r = BN_is_prime (p, BN_prime_checks, 0, BN_ctx, 0);
-    Utils::ensure (r >= 0);
-    return r;
-}
-
-qint32 CryptoUtils::checkDHParams (BIGNUM *p, qint32 g) {
-    if (g < 2 || g > 7) { return -1; }
-    BIGNUM t;
-    BN_init (&t);
-
-    BIGNUM dh_g;
-    BN_init (&dh_g);
-    Utils::ensure (BN_set_word (&dh_g, 4 * g));
-
-    Utils::ensure (BN_mod (&t, p, &dh_g, BN_ctx));
-    qint32 x = BN_get_word (&t);
-    Q_ASSERT(x >= 0 && x < 4 * g);
-
-    BN_free (&dh_g);
-
-    switch (g) {
-    case 2:
-        if (x != 7) { return -1; }
-        break;
-    case 3:
-        if (x % 3 != 2 ) { return -1; }
-        break;
-    case 4:
-        break;
-    case 5:
-        if (x % 5 != 1 && x % 5 != 4) { return -1; }
-        break;
-    case 6:
-        if (x != 19 && x != 23) { return -1; }
-        break;
-    case 7:
-        if (x % 7 != 3 && x % 7 != 5 && x % 7 != 6) { return -1; }
-        break;
-    }
-
-    if (!checkPrime (p)) { return -1; }
-
-    BIGNUM b;
-    BN_init (&b);
-    Utils::ensure (BN_set_word (&b, 2));
-    Utils::ensure (BN_div (&t, 0, p, &b, BN_ctx));
-    if (!checkPrime (&t)) { return -1; }
-    BN_free (&b);
-    BN_free (&t);
-    return 0;
-}
-
-/**
-  https://core.telegram.org/api/end-to-end says:
-  "Both clients in a secret chat creation are to check that g, g_a and g_b are greater than one and smaller than p-1.
-  Recommented checking that g_a and g_b are between 2^{2048-64} and p - 2^{2048-64} as well."
-*/
-qint32 CryptoUtils::checkCalculatedParams(const BIGNUM *gAOrB, const BIGNUM *g, const BIGNUM *p) {
-    ASSERT(gAOrB);
-    ASSERT(g);
-    ASSERT(p);
-
-    // 1) gAOrB and g greater than one and smaller than p-1
-    BIGNUM one;
-    BN_init(&one);
-    Utils::ensure(BN_one(&one));
-
-    BIGNUM *pMinusOne = BN_dup(p);
-    Utils::ensure(BN_sub_word(pMinusOne, 1));
-
-    // check params greater than one
-    if (BN_cmp(gAOrB, &one) <= 0) return -1;
-    if (BN_cmp(g, &one) <= 0) return -1;
-
-    // check params <= p-1
-    if (BN_cmp(gAOrB, pMinusOne) >= 0) return -1;
-    if (BN_cmp(g, pMinusOne) >= 0) return -1;
-
-    // 2) gAOrB between 2^{2048-64} and p - 2^{2048-64}
-    quint64 expWord = 2048 - 64;
-    BIGNUM exp;
-    BN_init(&exp);
-    Utils::ensure(BN_set_word(&exp, expWord));
-
-    BIGNUM base;
-    BN_init(&base);
-    Utils::ensure(BN_set_word(&base, 2));
-
-    // lowLimit = base ^ exp
-    BIGNUM lowLimit;
-    BN_init(&lowLimit);
-    Utils::ensure(BN_exp(&lowLimit, &base, &exp, BN_ctx));
-
-    // highLimit = p - lowLimit
-    BIGNUM highLimit;
-    BN_init(&highLimit);
-    BN_sub(&highLimit, p, &lowLimit);
-
-    if (BN_cmp(gAOrB, &lowLimit) < 0) return -1;
-    if (BN_cmp(gAOrB, &highLimit) > 0) return -1;
-
-    BN_free(&one);
-    BN_free(pMinusOne);
-    BN_free(&exp);
-    BN_free(&lowLimit);
-    BN_free(&highLimit);
-
-    return 0;
-}
-
-qint32 CryptoUtils::BNModExp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m) {
-    return BN_mod_exp (r, a, p, m, BN_ctx);
-}
-
-QByteArray CryptoUtils::encryptFilePart(const QByteArray &partBytes, uchar *key, uchar *iv) {
-    qint32 length = partBytes.length();
-    uchar *buffer = (uchar *)partBytes.constData();
-    // Use an output buffer for not to modify original one.
-    // Max size of the output buffer, included padding, will be length + 15
-    uchar out[length + 15];
-    memcpy(out, buffer, length);
-
-    // in case this part length % 0xF != 0, it means is the last part and we must pad the size to match AES block size (16)
-    qint32 paddedSize = length;
-    if (length & 15) {
-        paddedSize = (length + 15) & -16;
-        if (length < paddedSize) {
-            RAND_pseudo_bytes(out + length, paddedSize - length);
-        }
-    }
-
-    AES_KEY aesKey;
-    AES_set_encrypt_key(key, 256, &aesKey);
-    AES_ige_encrypt(out, out, paddedSize, &aesKey, iv, AES_ENCRYPT);
-    memset(&aesKey, 0, sizeof(aesKey));
-
-    return QByteArray((char *)out, paddedSize);
-}
-
-QByteArray CryptoUtils::decryptFilePart(const QByteArray &partBytes, uchar *key, uchar *iv) {
-    qint32 length = partBytes.length();
-    uchar *buffer = (uchar *)partBytes.constData();
-
-    ASSERT(!(length & 15));
-    AES_KEY aesKey;
-    AES_set_decrypt_key(key, 256, &aesKey);
-    AES_ige_encrypt(buffer, buffer, length, &aesKey, iv, AES_DECRYPT);
-    memset(&aesKey, 0, sizeof(aesKey));
-
-    return QByteArray::fromRawData((char *)buffer, length);
-}
-
-qint32 CryptoUtils::computeKeyFingerprint(const QByteArray &keyBytes, const QByteArray &ivBytes) {
-    uchar *key = (uchar *)keyBytes.data();
-    uchar *iv = (uchar *)ivBytes.data();
-    uchar md5[16];
-    uchar str[64];
-    memcpy(str, key, 32);
-    memcpy(str + 32, iv, 32);
-    MD5(str, 64, md5);
-    qint32 keyFingerprint = (*(int *)md5) ^ (*(int *)(md5 + 4));
-    return keyFingerprint;
-}

=== removed file 'lib/core/cryptoutils.h'
--- lib/core/cryptoutils.h	2014-11-28 18:46:13 +0000
+++ lib/core/cryptoutils.h	1970-01-01 00:00:00 +0000
@@ -1,69 +0,0 @@
-/*
- * Copyright 2013 Vitaly Valtman
- * Copyright 2014 Canonical Ltd.
- * Authors:
- *      Roberto Mier
- *      Tiago Herrmann
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef CRYPTOUTILS_H
-#define CRYPTOUTILS_H
-
-#include <QObject>
-#include "outboundpkt.h"
-
-#include <openssl/bn.h>
-#include <openssl/aes.h>
-
-class CryptoUtils : public QObject
-{
-    Q_OBJECT
-public:
-    static CryptoUtils *getInstance();
-
-    qint32 encryptPacketBuffer(OutboundPkt &p, void *encryptBuffer);
-    qint32 encryptPacketBufferAESUnAuth(const char serverNonce[16], const char hiddenClientNonce[32], OutboundPkt &p, void *encryptBuffer);
-    qint32 padRsaEncrypt(char *from, qint32 from_len, char *to, qint32 size, BIGNUM *N, BIGNUM *E);
-
-    void initAESAuth (char authKey[192], char msgKey[16], qint32 encrypt);
-    void initAESUnAuth(const char serverNonce[16], const char hiddenClientNonce[32], qint32 encrypt);
-    qint32 padAESDecrypt(const char *from, qint32 fromLen, char *to, qint32 size);
-    qint32 padAESEncrypt(const char *from, qint32 fromLen, char *to, qint32 size);
-
-    qint32 checkPrime(BIGNUM *p);
-    qint32 checkDHParams(BIGNUM *p, qint32 g);
-    qint32 checkCalculatedParams(const BIGNUM *gAOrB, const BIGNUM *g, const BIGNUM *p);
-
-    qint32 BNModExp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m);
-
-    QByteArray encryptFilePart(const QByteArray &partBytes, uchar *key, uchar *iv);
-    QByteArray decryptFilePart(const QByteArray &partBytes, uchar *key, uchar *iv);
-    qint32 computeKeyFingerprint(const QByteArray &key, const QByteArray &iv);
-
-private:
-    CryptoUtils();
-    ~CryptoUtils();
-    CryptoUtils(const CryptoUtils &);
-    CryptoUtils &operator=(const CryptoUtils &);
-
-    static CryptoUtils *m_instance;
-
-    BN_CTX *BN_ctx;
-    uchar aes_key_raw[32], aes_iv[32];
-    AES_KEY aes_key;
-};
-
-#endif // CRYPTOUTILS_H

=== modified file 'lib/core/dc.h'
--- lib/core/dc.h	2014-12-02 13:01:22 +0000
+++ lib/core/dc.h	2015-02-24 14:12:31 +0000
@@ -27,7 +27,7 @@
 #include "inboundpkt.h"
 #include "connection.h"
 #include "settings.h"
-#include "cryptoutils.h"
+#include "util/cryptoutils.h"
 
 class DC : public Endpoint
 {

=== modified file 'lib/core/dcauth.cpp'
--- lib/core/dcauth.cpp	2014-12-22 22:01:28 +0000
+++ lib/core/dcauth.cpp	2015-02-24 14:12:31 +0000
@@ -22,12 +22,12 @@
 #include "dcauth.h"
 
 #include "openssl/sha.h"
-#include "utils.h"
-#include "tlvalues.h"
-#include "asserter.h"
+#include "util/utils.h"
+#include "util/tlvalues.h"
+#include "util/asserter.h"
 #include <QDateTime>
 
-Q_LOGGING_CATEGORY(TG_AUTH_DCAUTH, "tg.auth.dcauth")
+Q_LOGGING_CATEGORY(TG_CORE_DCAUTH, "tg.core.dcauth")
 
 DCAuth::DCAuth(DC *dc, QObject *parent) : Connection(dc->host(), dc->port(), parent) , m_dc(dc) {
 }
@@ -48,7 +48,7 @@
             Q_EMIT dcReady(m_dc);
         }
     } else {
-        qCWarning(TG_AUTH_DCAUTH) << "Error! provided DC for creating auth key is null";
+        qCWarning(TG_CORE_DCAUTH) << "Error! provided DC for creating auth key is null";
     }
 }
 
@@ -63,13 +63,13 @@
         Q_EMIT dcReady(m_dc);
         break;
     default:
-        qCCritical(TG_AUTH_DCAUTH) << "Invalid state:" << m_dc->state();
+        qCCritical(TG_CORE_DCAUTH) << "Invalid state:" << m_dc->state();
         Q_EMIT fatalError();
     }
 }
 
 void DCAuth::sendReqPQPacket() {
-    qCDebug(TG_AUTH_DCAUTH) << "sendReqPQPacket()";
+    qCDebug(TG_CORE_DCAUTH) << "sendReqPQPacket()";
     mAsserter.check(m_dc->state() == DC::init);
     Utils::randomBytes(m_nonce, 16);
     OutboundPkt outboundPkt;
@@ -77,7 +77,7 @@
     outboundPkt.appendInts((qint32 *)m_nonce, 4);
     rpcSendPacket(outboundPkt);
     m_dc->setState(DC::reqPQSent);
-    qCDebug(TG_AUTH_DCAUTH) << "changed state to reqPQSent";
+    qCDebug(TG_CORE_DCAUTH) << "changed state to reqPQSent";
 }
 
 void DCAuth::processResPQAnswer(const InboundPkt &inboundPkt) {
@@ -86,7 +86,7 @@
     const char* buffer = inboundPkt.buffer();
     qint32 i;
 
-    qCDebug(TG_AUTH_DCAUTH) << "processResPQAnswer(), len=" << len;
+    qCDebug(TG_CORE_DCAUTH) << "processResPQAnswer(), len=" << len;
 
     mAsserter.check(len >= 76);
     mAsserter.check(!*(qint64 *) buffer);
@@ -107,7 +107,7 @@
 
     uint p1 = 0, p2 = 0;
 
-    qCDebug(TG_AUTH_DCAUTH) << "received pq =" << what;
+    qCDebug(TG_CORE_DCAUTH) << "received pq =" << what;
 
     qint64 g = Utils::findDivider(what);
     mAsserter.check(g > 1 && g < what);
@@ -117,7 +117,7 @@
         uint t = p1; p1 = p2; p2 = t;
     }
 
-    qCDebug(TG_AUTH_DCAUTH) << "p1 =" << p1 << ", p2 =" << p2;
+    qCDebug(TG_CORE_DCAUTH) << "p1 =" << p1 << ", p2 =" << p2;
 
     mAsserter.check(*(qint32 *) (from) == TL_Vector);
     qint32 fingerprints_num = *(qint32 *)(from + 4);
@@ -125,13 +125,13 @@
     qint64 *fingerprints = (qint64 *) (from + 8);
     for (i = 0; i < fingerprints_num; i++) {
         if (fingerprints[i] == Settings::getInstance()->pkFingerprint()) {
-            qCDebug(TG_AUTH_DCAUTH) << "found our public key at position" << i;
+            qCDebug(TG_CORE_DCAUTH) << "found our public key at position" << i;
             break;
         }
     }
     if (i == fingerprints_num) {
-        qCWarning(TG_AUTH_DCAUTH) << "fatal: don't have any matching keys (" << QString::number(Settings::getInstance()->pkFingerprint(), 16) << "expected)";
-        exit (2);
+        qCWarning(TG_CORE_DCAUTH) << "fatal: don't have any matching keys (" << QString::number(Settings::getInstance()->pkFingerprint(), 16) << "expected)";
+        Q_EMIT fatalError();
     }
 
     // create inner part (P_Q_inner_data)
@@ -173,7 +173,7 @@
 void DCAuth::processDHAnswer(InboundPkt &inboundPkt) {
     const char *buffer = inboundPkt.buffer();
     qint32 len = inboundPkt.length();
-    qCDebug(TG_AUTH_DCAUTH) << "processDHAnswer(), len=" <<  len;
+    qCDebug(TG_CORE_DCAUTH) << "processDHAnswer(), len=" <<  len;
 
     mAsserter.check(len >= 116);
     mAsserter.check(!*(qint64 *) buffer);
@@ -277,7 +277,7 @@
 void DCAuth::processAuthComplete(InboundPkt &inboundPkt) {
     const char *buffer = inboundPkt.buffer();
     qint32 len = inboundPkt.length();
-    qCDebug(TG_AUTH_DCAUTH) << "processAuthComplete(), len=" <<  len;
+    qCDebug(TG_CORE_DCAUTH) << "processAuthComplete(), len=" <<  len;
 
     mAsserter.check(len == 72);
     mAsserter.check(!*(qint64 *) buffer);
@@ -300,8 +300,8 @@
     m_dc->setServerSalt(*(qint64 *)m_serverNonce ^ *(qint64 *)m_newNonce);
     m_dc->setState(DC::authKeyCreated);
 
-    qCDebug(TG_AUTH_DCAUTH) << "created auth shared key for DC" << m_dc->id();
-    qCDebug(TG_AUTH_DCAUTH) << "auth_key_id =" << m_dc->authKeyId();
+    qCDebug(TG_CORE_DCAUTH) << "created auth shared key for DC" << m_dc->id();
+    qCDebug(TG_CORE_DCAUTH) << "auth_key_id =" << m_dc->authKeyId();
 
     Q_EMIT dcReady(m_dc);
 }
@@ -312,7 +312,7 @@
     peekIn(&op, 4);
     qint32 len = response.length();
 
-    qCDebug(TG_AUTH_DCAUTH) << "connection #" << socketDescriptor() << "received rpc answer" << op << "with" << len << "content bytes";
+    qCDebug(TG_CORE_DCAUTH) << "connection #" << socketDescriptor() << "received rpc answer" << op << "with" << len << "content bytes";
 
     InboundPkt p(response.data(), len);
 
@@ -330,8 +330,8 @@
     case DC::userSignedIn:
         break;
     default:
-        qCWarning(TG_AUTH_DCAUTH) << "fatal: cannot receive answer in state" << m_dc->state();
-        exit (2);
+        qCWarning(TG_CORE_DCAUTH) << "fatal: cannot receive answer in state" << m_dc->state();
+        Q_EMIT fatalError();
     }
 }
 
@@ -362,5 +362,5 @@
     }
     writeOut(&unencMsgHeader, 20);
     writeOut(packet.buffer(), len);
-    qCDebug(TG_AUTH_DCAUTH) << "packet sent";
+    qCDebug(TG_CORE_DCAUTH) << "packet sent";
 }

=== modified file 'lib/core/dcauth.h'
--- lib/core/dcauth.h	2014-09-29 12:33:11 +0000
+++ lib/core/dcauth.h	2015-02-24 14:12:31 +0000
@@ -24,10 +24,10 @@
 
 #include "dc.h"
 #include "connection.h"
-#include "asserter.h"
+#include "util/asserter.h"
 #include <QLoggingCategory>
 
-Q_DECLARE_LOGGING_CATEGORY(TG_AUTH_DCAUTH)
+Q_DECLARE_LOGGING_CATEGORY(TG_CORE_DCAUTH)
 
 class DCAuth : public Connection
 {

=== modified file 'lib/core/dcprovider.cpp'
--- lib/core/dcprovider.cpp	2014-12-22 22:01:28 +0000
+++ lib/core/dcprovider.cpp	2015-02-24 14:12:31 +0000
@@ -16,10 +16,10 @@
  */
 
 #include "dcprovider.h"
-#include "constants.h"
+#include "util/constants.h"
 #include "session.h"
 
-Q_LOGGING_CATEGORY(TG_INIT_DCPROVIDER, "tg.init.dcprovider")
+Q_LOGGING_CATEGORY(TG_CORE_DCPROVIDER, "tg.core.dcprovider")
 
 DcProvider::DcProvider() : mApi(0), mPendingDcs(0), mPendingTransferSessions(0), mWorkingDcSession(0) {
 }
@@ -137,7 +137,7 @@
 }
 
 void DcProvider::onDcReady(DC *dc) {
-    qCDebug(TG_INIT_DCPROVIDER) << "DC" << dc->id() << "ready";
+    qCDebug(TG_CORE_DCPROVIDER) << "DC" << dc->id() << "ready";
     // disconnect dcAuth to avoid consuming bandwidth with unnecessary connections
     DCAuth *dcAuth = mDcAuths.value(dc->id());
     if (dcAuth) {
@@ -172,7 +172,7 @@
         Settings::getInstance()->setDcsList(mDcs.values());
         Settings::getInstance()->writeAuthFile();
 
-        qCDebug(TG_INIT_DCPROVIDER) << "DcProvider ready";
+        qCDebug(TG_CORE_DCPROVIDER) << "DcProvider ready";
         Q_EMIT dcProviderReady();
 
         // if current dc is in "authKeyCreated" state, authNeeded signal must be emitted for user to sign in.
@@ -196,7 +196,7 @@
 void DcProvider::onApiError() {
 
     Session *session = qobject_cast<Session *>(sender());
-    qCWarning(TG_INIT_DCPROVIDER) << "Api init error when connecting session to server:" << session->errorString();
+    qCWarning(TG_CORE_DCPROVIDER) << "Api init error when connecting session to server:" << session->errorString();
 
     // after emitting these startup offline signals, we don't want to do it again when session gets connected, so disconnect signal-slot
     disconnect(session, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(onApiError()));
@@ -230,7 +230,7 @@
 
 void DcProvider::onApiReady(DC*) {
     Session *session = qobject_cast<Session *>(sender());
-    qCDebug(TG_INIT_DCPROVIDER) << "Api connected to server and ready";
+    qCDebug(TG_CORE_DCPROVIDER) << "Api connected to server and ready";
 
     // after emitting the api startup signals, we don't want to do it again when session gets connected, so disconnect signal-slot
     disconnect(session, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(onApiError()));
@@ -244,15 +244,15 @@
 
 void DcProvider::onConfigReceived(qint64 msgId, qint32 date, bool testMode, qint32 thisDc, const QList<DcOption> &dcOptions, qint32 chatMaxSize, qint32 broadcastMaxSize) {
 
-    qCDebug(TG_INIT_DCPROVIDER) << "onConfigReceived(), msgId =" << QString::number(msgId, 16);
-    qCDebug(TG_INIT_DCPROVIDER) << "date =" << date;
-    qCDebug(TG_INIT_DCPROVIDER) << "testMode =" << testMode;
-    qCDebug(TG_INIT_DCPROVIDER) << "thisDc =" << thisDc;
+    qCDebug(TG_CORE_DCPROVIDER) << "onConfigReceived(), msgId =" << QString::number(msgId, 16);
+    qCDebug(TG_CORE_DCPROVIDER) << "date =" << date;
+    qCDebug(TG_CORE_DCPROVIDER) << "testMode =" << testMode;
+    qCDebug(TG_CORE_DCPROVIDER) << "thisDc =" << thisDc;
 
     mPendingDcs = dcOptions.length() -1; //all the received options but the default one, yet used
 
     Q_FOREACH (DcOption dcOption, dcOptions) {
-        qCDebug(TG_INIT_DCPROVIDER) << "dcOption | id =" << dcOption.id() << ", ipAddress =" << dcOption.ipAddress() <<
+        qCDebug(TG_CORE_DCPROVIDER) << "dcOption | id =" << dcOption.id() << ", ipAddress =" << dcOption.ipAddress() <<
                     ", port =" << dcOption.port() << ", hostname =" << dcOption.hostname();
 
         // for every new DC or not authenticated DC, insert into m_dcs and authenticate
@@ -283,8 +283,8 @@
         }
     }
 
-    qCDebug(TG_INIT_DCPROVIDER) << "chatMaxSize =" << chatMaxSize;
-    qCDebug(TG_INIT_DCPROVIDER) << "broadcastMaxSize =" << broadcastMaxSize;
+    qCDebug(TG_CORE_DCPROVIDER) << "chatMaxSize =" << chatMaxSize;
+    qCDebug(TG_CORE_DCPROVIDER) << "broadcastMaxSize =" << broadcastMaxSize;
 }
 
 Api *DcProvider::getApi() const {

=== modified file 'lib/core/dcprovider.h'
--- lib/core/dcprovider.h	2014-09-29 16:27:49 +0000
+++ lib/core/dcprovider.h	2015-02-24 14:12:31 +0000
@@ -27,7 +27,7 @@
 #include "dcauth.h"
 #include "api.h"
 
-Q_DECLARE_LOGGING_CATEGORY(TG_INIT_DCPROVIDER)
+Q_DECLARE_LOGGING_CATEGORY(TG_CORE_DCPROVIDER)
 
 class DcProvider : public QObject
 {

=== modified file 'lib/core/inboundpkt.cpp'
--- lib/core/inboundpkt.cpp	2015-01-28 17:06:39 +0000
+++ lib/core/inboundpkt.cpp	2015-02-24 14:12:31 +0000
@@ -22,11 +22,11 @@
 #include "inboundpkt.h"
 
 #include <QDebug>
-#include "utils.h"
-#include "tlvalues.h"
+#include "util/utils.h"
+#include "util/tlvalues.h"
 #include "telegram.h"
 
-Q_LOGGING_CATEGORY(TG_NET_FETCH, "tg.net.fetch")
+Q_LOGGING_CATEGORY(TG_CORE_INBOUNDPKT, "tg.core.inboundpkt")
 
 InboundPkt::InboundPkt(char *buffer, qint32 length) :
     m_buffer(buffer),
@@ -86,21 +86,21 @@
 
 qint32 InboundPkt::fetchInt() {
     Q_ASSERT(m_inPtr + 1 <= m_inEnd);
-    qCDebug(TG_NET_FETCH) << "fetchInt()" << *m_inPtr << " (" << Utils::toHex(*m_inPtr) << ")";
+    qCDebug(TG_CORE_INBOUNDPKT) << "fetchInt()" << *m_inPtr << " (" << Utils::toHex(*m_inPtr) << ")";
     return *(m_inPtr ++);
 }
 
 bool InboundPkt::fetchBool() {
     Q_ASSERT(m_inPtr + 1 <= m_inEnd);
     ASSERT(*(m_inPtr) == (qint32)TL_BoolTrue || *(m_inPtr) == (qint32)TL_BoolFalse);
-    qCDebug(TG_NET_FETCH) << "fetchBool()" << (*(m_inPtr) == (qint32)TL_BoolTrue) << " (" << Utils::toHex(*m_inPtr) << ")";
+    qCDebug(TG_CORE_INBOUNDPKT) << "fetchBool()" << (*(m_inPtr) == (qint32)TL_BoolTrue) << " (" << Utils::toHex(*m_inPtr) << ")";
     return *(m_inPtr++) == (qint32)TL_BoolTrue;
 }
 
 qint64 InboundPkt::fetchLong() {
     Q_ASSERT(m_inPtr + 2 <= m_inEnd);
     qint64 r = *(qint64 *)m_inPtr;
-    qCDebug(TG_NET_FETCH) << "fetchLong()" <<  r ;
+    qCDebug(TG_CORE_INBOUNDPKT) << "fetchLong()" <<  r ;
     m_inPtr += 2;
     return r;
 }
@@ -122,7 +122,7 @@
 
 char *InboundPkt::fetchStr(qint32 len) {
     Q_ASSERT(len >= 0);
-    qCDebug(TG_NET_FETCH) << "fetchStr(), len =" << len;
+    qCDebug(TG_CORE_INBOUNDPKT) << "fetchStr(), len =" << len;
     char *str;
     if (len < 254) {
         str = (char *)m_inPtr + 1;

=== modified file 'lib/core/inboundpkt.h'
--- lib/core/inboundpkt.h	2015-01-28 17:06:39 +0000
+++ lib/core/inboundpkt.h	2015-02-24 14:12:31 +0000
@@ -62,7 +62,7 @@
 
 #include "secret/secretchat.h"
 
-Q_DECLARE_LOGGING_CATEGORY(TG_NET_FETCH)
+Q_DECLARE_LOGGING_CATEGORY(TG_CORE_INBOUNDPKT)
 
 class InboundPkt
 {

=== modified file 'lib/core/outboundpkt.cpp'
--- lib/core/outboundpkt.cpp	2015-01-28 17:06:39 +0000
+++ lib/core/outboundpkt.cpp	2015-02-24 14:12:31 +0000
@@ -23,10 +23,10 @@
 
 #include <sys/utsname.h>
 
-#include "utils.h"
-#include "tlvalues.h"
+#include "util/utils.h"
+#include "util/tlvalues.h"
 
-Q_LOGGING_CATEGORY(TG_NET_APPEND, "tg.net.append")
+Q_LOGGING_CATEGORY(TG_CORE_OUTBOUNDPKT, "tg.core.outboundpkt")
 
 template <typename T_>
 void do_delete(T_ buf[]) {
@@ -67,7 +67,7 @@
 
 void OutboundPkt::appendLong(qint64 x) {
     Q_ASSERT(m_packetPtr + 2 <= m_packetBuffer + PACKET_BUFFER_SIZE);
-    qCDebug(TG_NET_APPEND) << "appendLong()" << QString::number(x) << " (" << "0x" + QString::number(x,16) << ")";;
+    qCDebug(TG_CORE_OUTBOUNDPKT) << "appendLong()" << QString::number(x) << " (" << "0x" + QString::number(x,16) << ")";;
     *(qint64 *)m_packetPtr = x;
     m_packetPtr += 2;
 }
@@ -91,13 +91,13 @@
 
 void OutboundPkt::appendInt (qint32 x) {
     Q_ASSERT(m_packetPtr + 1 <= m_packetBuffer + PACKET_BUFFER_SIZE);
-    qCDebug(TG_NET_APPEND) << "appendInt()" << QString::number(x) << " (" << "0x" + QString::number(x,16) << ")";;
+    qCDebug(TG_CORE_OUTBOUNDPKT) << "appendInt()" << QString::number(x) << " (" << "0x" + QString::number(x,16) << ")";;
     *m_packetPtr++ = x;
 }
 
 void OutboundPkt::appendDouble(double d) {
     Q_ASSERT(m_packetPtr + 2 <= m_packetBuffer + PACKET_BUFFER_SIZE);
-    qCDebug(TG_NET_APPEND) << "appendInt()" << QString::number(d);
+    qCDebug(TG_CORE_OUTBOUNDPKT) << "appendInt()" << QString::number(d);
     *(double *)m_packetPtr = d;
     m_packetPtr += 2;
 }
@@ -125,7 +125,7 @@
 }
 
 void OutboundPkt::appendQString (const QString &string) {
-//    qCDebug(TG_NET_APPEND) << "appendQString()" << string;
+//    qCDebug(TG_CORE_OUTBOUNDPKT) << "appendQString()" << string;
     QByteArray bytes = string.toUtf8();
     appendCString(bytes.data(), bytes.length());
 }
@@ -138,7 +138,7 @@
 }
 
 void OutboundPkt::appendBool(bool b) {
-    qCDebug(TG_NET_APPEND) << "appendBool()" << b;
+    qCDebug(TG_CORE_OUTBOUNDPKT) << "appendBool()" << b;
     b ? appendInt(TL_BoolTrue) : appendInt(TL_BoolFalse);
 }
 

=== modified file 'lib/core/outboundpkt.h'
--- lib/core/outboundpkt.h	2015-01-28 17:06:39 +0000
+++ lib/core/outboundpkt.h	2015-02-24 14:12:31 +0000
@@ -26,7 +26,7 @@
 #include <QByteArray>
 #include <QLoggingCategory>
 #include <openssl/bn.h>
-#include "constants.h"
+#include "util/constants.h"
 #include "settings.h"
 #include "types/inputpeer.h"
 #include "types/inputuser.h"
@@ -50,7 +50,7 @@
 
 #include <QSharedPointer>
 
-Q_DECLARE_LOGGING_CATEGORY(TG_NET_APPEND)
+Q_DECLARE_LOGGING_CATEGORY(TG_CORE_OUTBOUNDPKT)
 
 class OutboundPkt
 {

=== modified file 'lib/core/query.h'
--- lib/core/query.h	2014-09-12 22:00:16 +0000
+++ lib/core/query.h	2015-02-24 14:12:31 +0000
@@ -22,7 +22,7 @@
 #ifndef QUERY_H
 #define QUERY_H
 
-#include "utils.h"
+#include "util/utils.h"
 #include "inboundpkt.h"
 #include "querymethods.h"
 #include "dc.h"

=== modified file 'lib/core/session.cpp'
--- lib/core/session.cpp	2014-12-09 18:01:27 +0000
+++ lib/core/session.cpp	2015-02-24 14:12:31 +0000
@@ -23,9 +23,9 @@
 #include "openssl/rand.h"
 #include "openssl/sha.h"
 #include <QDateTime>
-#include "tlvalues.h"
+#include "util/tlvalues.h"
 
-Q_LOGGING_CATEGORY(TG_NET_SESSION, "tg.net.session")
+Q_LOGGING_CATEGORY(TG_CORE_SESSION, "tg.core.session")
 
 qint64 Session::m_clientLastMsgId = 0;
 
@@ -45,11 +45,11 @@
     m_serverSalt = m_dc->serverSalt();
     // create session id
     RAND_pseudo_bytes((uchar *) &m_sessionId, 8);
-    qCDebug(TG_NET_SESSION) << "created session with id" << QString::number(m_sessionId, 16);
+    qCDebug(TG_CORE_SESSION) << "created session with id" << QString::number(m_sessionId, 16);
 }
 
 Session::~Session() {
-    qCDebug(TG_NET_SESSION) << "destroyed session with id" << QString::number(m_sessionId, 16);
+    qCDebug(TG_CORE_SESSION) << "destroyed session with id" << QString::number(m_sessionId, 16);
 }
 
 void Session::close() {
@@ -93,12 +93,12 @@
     peekIn(&op, 4);
     qint32 len = response.length();
 
-    qCDebug(TG_NET_SESSION) << "connection #" << socketDescriptor() << "received rpc answer" << op << "with" << len << "content bytes by session" << QString::number(m_sessionId, 16);
+    qCDebug(TG_CORE_SESSION) << "connection #" << socketDescriptor() << "received rpc answer" << op << "with" << len << "content bytes by session" << QString::number(m_sessionId, 16);
 
     InboundPkt p(response.data(), len);
 
     if (op < 0 && op >= -999) {
-        qCDebug(TG_NET_SESSION) << "server error" << op;
+        qCDebug(TG_CORE_SESSION) << "server error" << op;
     } else {
         processRpcMessage(p);
     }
@@ -111,7 +111,7 @@
 
     const qint32 MINSZ = offsetof (EncryptedMsg, message);
     const qint32 UNENCSZ = offsetof (EncryptedMsg, serverSalt);
-    qCDebug(TG_NET_SESSION) << "processRpcMessage(), len=" << len;
+    qCDebug(TG_CORE_SESSION) << "processRpcMessage(), len=" << len;
 
     Q_ASSERT(len >= MINSZ && (len & 15) == (UNENCSZ & 15));
     Q_ASSERT(m_dc->authKeyId());
@@ -136,20 +136,20 @@
     qint32 serverTime = enc->msgId >> 32LL;
     qint32 clientTime = QDateTime::currentDateTime().toTime_t() - mTimeDifference;
     if (clientTime <= serverTime - 30 || clientTime >= serverTime + 300) {
-        qCDebug(TG_NET_SESSION) << "salt =" << enc->serverSalt << ", sessionId =" << QString::number(enc->sessionId, 16) << ", msgId =" << QString::number(enc->msgId, 16) << ", seqNo =" << enc->seqNo << ", serverTime =" << serverTime << ", clientTime =" << clientTime;
+        qCDebug(TG_CORE_SESSION) << "salt =" << enc->serverSalt << ", sessionId =" << QString::number(enc->sessionId, 16) << ", msgId =" << QString::number(enc->msgId, 16) << ", seqNo =" << enc->seqNo << ", serverTime =" << serverTime << ", clientTime =" << clientTime;
         QString alert("Received message has too large difference between client and server dates - ");
         if (clientTime <= serverTime -30) {
             alert.append("the message has a date at least 30 seconds later in time than current date");
         } else {
             alert.append("the message was sent at least 300 seconds ago");
         }
-        qCWarning(TG_NET_SESSION) << alert;
+        qCWarning(TG_CORE_SESSION) << alert;
     }
 
     inboundPkt.setInPtr(enc->message);
     inboundPkt.setInEnd(inboundPkt.inPtr() + (enc->msgLen / 4));
 
-    qCDebug(TG_NET_SESSION) << "received message id" << QString::number(enc->msgId, 16);
+    qCDebug(TG_CORE_SESSION) << "received message id" << QString::number(enc->msgId, 16);
 
     Q_ASSERT(l >= (MINSZ - UNENCSZ) + 8);
 
@@ -164,7 +164,7 @@
 
 void Session::rpcExecuteAnswer(InboundPkt &inboundPkt, qint64 msgId) {
     qint32 op = inboundPkt.prefetchInt();
-    qCDebug(TG_NET_SESSION) << "rpcExecuteAnswer(), op =" << QString::number(op, 16);
+    qCDebug(TG_CORE_SESSION) << "rpcExecuteAnswer(), op =" << QString::number(op, 16);
     switch (op) {
     case TL_MsgContainer:
         workContainer(inboundPkt, msgId);
@@ -214,12 +214,12 @@
         workBadMsgNotification(inboundPkt, msgId);
         return;
     }
-    qCWarning(TG_NET_SESSION) << "Unknown rpc response message";
+    qCWarning(TG_CORE_SESSION) << "Unknown rpc response message";
     inboundPkt.setInPtr(inboundPkt.inEnd());
 }
 
 void Session::workContainer (InboundPkt &inboundPkt, qint64 msgId) {
-    qCDebug(TG_NET_SESSION) << "workContainer: msgId =" << QString::number(msgId, 16);
+    qCDebug(TG_CORE_SESSION) << "workContainer: msgId =" << QString::number(msgId, 16);
     mAsserter.check(inboundPkt.fetchInt() == TL_MsgContainer);
     qint32 n = inboundPkt.fetchInt();
     for (qint32 i = 0; i < n; i++) { // message
@@ -238,7 +238,7 @@
 }
 
 void Session::workNewSessionCreated(InboundPkt &inboundPkt, qint64 msgId) {
-    qCDebug(TG_NET_SESSION) << "workNewSessionCreated: msgId =" << QString::number(msgId, 16);
+    qCDebug(TG_CORE_SESSION) << "workNewSessionCreated: msgId =" << QString::number(msgId, 16);
     mAsserter.check(inboundPkt.fetchInt() == (qint32)TL_NewSessionCreated);
     inboundPkt.fetchLong(); // first_msg_id; //XXX set is as m_clientLastMsgId??
     inboundPkt.fetchLong (); // unique_id
@@ -246,7 +246,7 @@
 }
 
 void Session::workMsgsAck(InboundPkt &inboundPkt, qint64 msgId) {
-    qCDebug(TG_NET_SESSION) << "workMsgsAck: msgId =" << QString::number(msgId, 16);
+    qCDebug(TG_CORE_SESSION) << "workMsgsAck: msgId =" << QString::number(msgId, 16);
     mAsserter.check(inboundPkt.fetchInt() == (qint32)TL_MsgsAck);
     mAsserter.check(inboundPkt.fetchInt () == (qint32)TL_Vector);
     qint32 n = inboundPkt.fetchInt();
@@ -259,7 +259,7 @@
 }
 
 void Session::workRpcResult(InboundPkt &inboundPkt, qint64 msgId) {
-    qCDebug(TG_NET_SESSION) << "workRpcResult: msgId =" << QString::number(msgId, 16);
+    qCDebug(TG_CORE_SESSION) << "workRpcResult: msgId =" << QString::number(msgId, 16);
     mAsserter.check(inboundPkt.fetchInt() == (qint32)TL_RpcResult);
     qint64 id = inboundPkt.fetchLong();
     qint32 op = inboundPkt.prefetchInt();
@@ -271,7 +271,7 @@
 }
 
 void Session::workUpdateShort(InboundPkt &inboundPkt, qint64 msgId) {
-    qCDebug(TG_NET_SESSION) << "workUpdateShort: msgId =" << QString::number(msgId, 16);
+    qCDebug(TG_CORE_SESSION) << "workUpdateShort: msgId =" << QString::number(msgId, 16);
     mAsserter.check(inboundPkt.fetchInt() == (qint32)TL_UpdateShort);
     Update update = inboundPkt.fetchUpdate();
     qint32 date = inboundPkt.fetchInt();
@@ -279,7 +279,7 @@
 }
 
 void Session::workUpdatesCombined(InboundPkt &inboundPkt, qint64 msgId) {
-    qCDebug(TG_NET_SESSION) << "workUpdatesCombined: msgId =" << QString::number(msgId, 16);
+    qCDebug(TG_CORE_SESSION) << "workUpdatesCombined: msgId =" << QString::number(msgId, 16);
     mAsserter.check(inboundPkt.fetchInt() == (qint32)TL_UpdatesCombined);
     //updates
     mAsserter.check(inboundPkt.fetchInt() == (qint32)TL_Vector);
@@ -309,7 +309,7 @@
 }
 
 void Session::workUpdates(InboundPkt &inboundPkt, qint64 msgId) {
-    qCDebug(TG_NET_SESSION) << "workUpdates: msgId =" << QString::number(msgId, 16);
+    qCDebug(TG_CORE_SESSION) << "workUpdates: msgId =" << QString::number(msgId, 16);
     mAsserter.check(inboundPkt.fetchInt() == (qint32)TL_Updates);
     //updates
     mAsserter.check(inboundPkt.fetchInt() == (qint32)TL_Vector);
@@ -338,7 +338,7 @@
 }
 
 void Session::workUpdateShortMessage(InboundPkt &inboundPkt, qint64 msgId) {
-    qCDebug(TG_NET_SESSION) << "workUpdateShortMessage: msgId =" << QString::number(msgId, 16);
+    qCDebug(TG_CORE_SESSION) << "workUpdateShortMessage: msgId =" << QString::number(msgId, 16);
     mAsserter.check(inboundPkt.fetchInt() == (qint32)TL_UpdateShortMessage);
     qint32 id = inboundPkt.fetchInt();
     qint32 fromId = inboundPkt.fetchInt();
@@ -350,7 +350,7 @@
 }
 
 void Session::workUpdateShortChatMessage(InboundPkt &inboundPkt, qint64 msgId) {
-    qCDebug(TG_NET_SESSION) << "workUpdateShortChatMessage: msgId =" << QString::number(msgId, 16);
+    qCDebug(TG_CORE_SESSION) << "workUpdateShortChatMessage: msgId =" << QString::number(msgId, 16);
     mAsserter.check(inboundPkt.fetchInt() == (qint32)TL_UpdateShortChatMessage);
     qint32 id = inboundPkt.fetchInt();
     qint32 fromId = inboundPkt.fetchInt();
@@ -363,7 +363,7 @@
 }
 
 void Session::workPacked(InboundPkt &inboundPkt, qint64 msgId) {
-    qCDebug(TG_NET_SESSION) << "workPacked: msgId =" << QString::number(msgId, 16);
+    qCDebug(TG_CORE_SESSION) << "workPacked: msgId =" << QString::number(msgId, 16);
     mAsserter.check(inboundPkt.fetchInt() == (qint32)TL_GZipPacked);
     static qint32 buf[MAX_PACKED_SIZE >> 2];
     qint32 l = inboundPkt.prefetchStrlen();
@@ -374,14 +374,14 @@
     qint32 *inEnd = inboundPkt.inEnd();
     inboundPkt.setInPtr(buf);
     inboundPkt.setInEnd(inboundPkt.inPtr() + totalOut / 4);
-    qCDebug(TG_NET_SESSION) << "Unzipped data";
+    qCDebug(TG_CORE_SESSION) << "Unzipped data";
     rpcExecuteAnswer(inboundPkt, msgId);
     inboundPkt.setInPtr(inPtr); //TODO Not sure about this operations of setting inPtr and inEnd after execute answer completion
     inboundPkt.setInEnd(inEnd);
 }
 
 void Session::workBadServerSalt(InboundPkt &inboundPkt, qint64 msgId) {
-    qCDebug(TG_NET_SESSION) << "workBadServerSalt: msgId =" << QString::number(msgId, 16);
+    qCDebug(TG_CORE_SESSION) << "workBadServerSalt: msgId =" << QString::number(msgId, 16);
     mAsserter.check(inboundPkt.fetchInt() == (qint32)TL_BadServerSalt);
     qint64 badMsgId = inboundPkt.fetchLong();
     inboundPkt.fetchInt(); // badMsgSeqNo
@@ -393,14 +393,14 @@
 }
 
 void Session::workPong(InboundPkt &inboundPkt, qint64 msgId) {
-    qCDebug(TG_NET_SESSION) << "workPong: msgId =" << QString::number(msgId, 16);
+    qCDebug(TG_CORE_SESSION) << "workPong: msgId =" << QString::number(msgId, 16);
     mAsserter.check (inboundPkt.fetchInt() == (qint32)TL_Pong);
     inboundPkt.fetchLong(); // msg_id
     inboundPkt.fetchLong(); // ping_id
 }
 
 void Session::workDetailedInfo(InboundPkt &inboundPkt, qint64 msgId) {
-    qCDebug(TG_NET_SESSION) << "workDetailedInfo: msgId =" << QString::number(msgId, 16);
+    qCDebug(TG_CORE_SESSION) << "workDetailedInfo: msgId =" << QString::number(msgId, 16);
     mAsserter.check(inboundPkt.fetchInt() == (qint32)TL_MsgDetailedInfo);
     inboundPkt.fetchLong(); // msg_id
     inboundPkt.fetchLong(); // answer_msg_id
@@ -409,7 +409,7 @@
 }
 
 void Session::workNewDetailedInfo(InboundPkt &inboundPkt, qint64 msgId) {
-    qCDebug(TG_NET_SESSION) << "workNewDetailedInfo: msgId =" << QString::number(msgId, 16);
+    qCDebug(TG_CORE_SESSION) << "workNewDetailedInfo: msgId =" << QString::number(msgId, 16);
     mAsserter.check(inboundPkt.fetchInt() == (qint32)TL_MsgNewDetailedInfo);
     inboundPkt.fetchLong(); // answer_msg_id
     inboundPkt.fetchInt(); // bytes
@@ -417,7 +417,7 @@
 }
 
 void Session::workUpdatesTooLong(InboundPkt &inboundPkt, qint64 msgId) {
-    qCDebug(TG_NET_SESSION) << "workUpdatesTooLong: msgId =" << QString::number(msgId, 16);
+    qCDebug(TG_CORE_SESSION) << "workUpdatesTooLong: msgId =" << QString::number(msgId, 16);
     mAsserter.check(inboundPkt.fetchInt() == (qint32)TL_UpdatesTooLong);
     Q_EMIT updatesTooLong();
 }
@@ -427,7 +427,7 @@
     qint64 badMsgId = inboundPkt.fetchLong();
     qint32 badMsgSeqNo = inboundPkt.fetchInt();
     qint32 errorCode = inboundPkt.fetchInt();
-    qCWarning(TG_NET_SESSION) << "workBadMsgNotification: msgId =" << badMsgId <<
+    qCWarning(TG_CORE_SESSION) << "workBadMsgNotification: msgId =" << badMsgId <<
                   ", seqNo =" << badMsgSeqNo << ", errorCode =" << errorCode;
     switch (errorCode) {
     case 16:
@@ -467,7 +467,7 @@
     qint32 encLen = (MINSZ - UNENCSZ) + encMsg->msgLen;
     Q_ASSERT (encMsg->msgLen >= 0 && encMsg->msgLen <= MAX_MESSAGE_INTS * 4 - 16 && !(encMsg->msgLen & 3));
     SHA1 ((uchar *) &encMsg->serverSalt, encLen, sha1Buffer);
-    qCDebug(TG_NET_SESSION) << "sending message with sha1" << QString::number(*(qint32 *)sha1Buffer, 8);
+    qCDebug(TG_CORE_SESSION) << "sending message with sha1" << QString::number(*(qint32 *)sha1Buffer, 8);
 
     memcpy (encMsg->msgKey, sha1Buffer + 4, 16);
     CryptoUtils::getInstance()->initAESAuth(m_dc->authKey(), encMsg->msgKey, AES_ENCRYPT);
@@ -524,13 +524,13 @@
     qint32 *data = outboundPkt.buffer();
     qint32 ints = outboundPkt.length();
 
-    qCDebug(TG_NET_SESSION) << "Sending query of size" << 4 * ints << "to DC" << m_dc->id() << "at" << peerName() << ":" << peerPort() << "by session" << QString::number(m_sessionId, 16);
+    qCDebug(TG_CORE_SESSION) << "Sending query of size" << 4 * ints << "to DC" << m_dc->id() << "at" << peerName() << ":" << peerPort() << "by session" << QString::number(m_sessionId, 16);
 
     Query *q = new Query(this);
     q->setData(data, ints);
     q->setMsgId(encryptSendMessage(data, ints, 1));
     q->setSeqNo(m_seqNo - 1);
-    qCDebug(TG_NET_SESSION) << "msgId is" << QString::number(q->msgId(), 16);
+    qCDebug(TG_CORE_SESSION) << "msgId is" << QString::number(q->msgId(), 16);
     q->setMethods(methods);
     q->setAcked(false);
     q->setExtra(extra);
@@ -547,10 +547,10 @@
 
 void Session::recomposeAndSendQuery(Query *q) {
     Q_ASSERT(q);
-    qCDebug(TG_NET_SESSION) << "Resending query with previous msgId" << QString::number(q->msgId(), 16);
+    qCDebug(TG_CORE_SESSION) << "Resending query with previous msgId" << QString::number(q->msgId(), 16);
     q->setMsgId(encryptSendMessage((qint32 *)q->data(), q->dataLength(), 1));
     q->setSeqNo(m_seqNo - 1);
-    qCDebug(TG_NET_SESSION) << "new msgId is" << QString::number(q->msgId(), 16);
+    qCDebug(TG_CORE_SESSION) << "new msgId is" << QString::number(q->msgId(), 16);
     q->setAcked(false);
     m_pendingQueries.insert(q->msgId(), q);
 }
@@ -559,11 +559,11 @@
     Q_ASSERT(q);
     //avoid resending if resend numbers is less than zero
     if (q->decreaseResends() < 0) {
-        qCDebug(TG_NET_SESSION) << "Max resend numbers reached for query with msgId" << QString::number(q->msgId(), 16) << ",query discarded";
+        qCDebug(TG_CORE_SESSION) << "Max resend numbers reached for query with msgId" << QString::number(q->msgId(), 16) << ",query discarded";
         m_pendingQueries.remove(q->msgId());
         delete q;
     } else {
-        qCDebug(TG_NET_SESSION) << "Resending query with msgId" << QString::number(q->msgId(), 16);
+        qCDebug(TG_CORE_SESSION) << "Resending query with msgId" << QString::number(q->msgId(), 16);
         OutboundPkt p;
         p.appendInt(TL_MsgContainer);
         p.appendInt(1);
@@ -576,7 +576,7 @@
 }
 
 void Session::queryOnResult(InboundPkt &inboundPkt, qint64 msgId) {
-    qCDebug(TG_NET_SESSION) << "result for query" << QString::number(msgId, 16);
+    qCDebug(TG_CORE_SESSION) << "result for query" << QString::number(msgId, 16);
     qint32 op = inboundPkt.prefetchInt();
     qint32 *inPtr = 0;
     qint32 *inEnd = 0;
@@ -590,15 +590,15 @@
         inEnd = inboundPkt.inEnd();
         inboundPkt.setInPtr(packedBuffer);
         inboundPkt.setInEnd(inboundPkt.inPtr() + totalOut / 4);
-        qCDebug(TG_NET_SESSION) << "unzipped data";
+        qCDebug(TG_CORE_SESSION) << "unzipped data";
     }
 
     Query *q = m_pendingQueries.take(msgId);
     if (!q) {
-        qCWarning(TG_NET_SESSION) << "No such query";
+        qCWarning(TG_CORE_SESSION) << "No such query";
         inboundPkt.setInPtr(inboundPkt.inEnd());
     } else {
-        qCDebug(TG_NET_SESSION) << "acked query with msgId" << QString::number(msgId, 16) << ",pendingQueries:" << m_pendingQueries.size();
+        qCDebug(TG_CORE_SESSION) << "acked query with msgId" << QString::number(msgId, 16) << ",pendingQueries:" << m_pendingQueries.size();
         q->setAcked(true);
         Q_EMIT resultReceived(q, inboundPkt);
     }
@@ -613,11 +613,11 @@
     mAsserter.check(inboundPkt.fetchInt() == TL_RpcError);
     qint32 errorCode = inboundPkt.fetchInt();
     QString errorText = inboundPkt.fetchQString();
-    qCDebug(TG_NET_SESSION) << "error for query" << QString::number(msgId, 16) << " :" << errorCode << " :" << errorText;
+    qCDebug(TG_CORE_SESSION) << "error for query" << QString::number(msgId, 16) << " :" << errorCode << " :" << errorText;
 
     Query *q = m_pendingQueries.take(msgId);
     if (!q) {
-        qCWarning(TG_NET_SESSION) << "No such query";
+        qCWarning(TG_CORE_SESSION) << "No such query";
     } else {
         q->setAcked(true);
         Q_EMIT errorReceived(q, errorCode, errorText);
@@ -653,7 +653,7 @@
     p.appendInt(n);
     Q_FOREACH (qint64 msgId, msgIds) {
         p.appendLong(msgId);
-        qCDebug(TG_NET_SESSION) << "Ack for msgId" << msgId;
+        qCDebug(TG_CORE_SESSION) << "Ack for msgId" << msgId;
         EventTimer* t = m_pendingAcks.take(msgId);
         if (t) {
             t->stop();
@@ -661,5 +661,5 @@
         }
     }
     qint64 sentAcksId = encryptSendMessage(p.buffer(), p.length(), 0);
-    qCDebug(TG_NET_SESSION) << "Sent Acks with id:" << QString::number(sentAcksId, 16);
+    qCDebug(TG_CORE_SESSION) << "Sent Acks with id:" << QString::number(sentAcksId, 16);
 }

=== modified file 'lib/core/session.h'
--- lib/core/session.h	2014-12-09 18:01:27 +0000
+++ lib/core/session.h	2015-02-24 14:12:31 +0000
@@ -30,7 +30,7 @@
 
 #include "eventtimer.h"
 
-Q_DECLARE_LOGGING_CATEGORY(TG_NET_SESSION)
+Q_DECLARE_LOGGING_CATEGORY(TG_CORE_SESSION)
 
 class Session : public Connection
 {

=== modified file 'lib/core/sessionmanager.cpp'
--- lib/core/sessionmanager.cpp	2014-12-17 11:12:11 +0000
+++ lib/core/sessionmanager.cpp	2015-02-24 14:12:31 +0000
@@ -20,6 +20,8 @@
 
 #include "sessionmanager.h"
 
+Q_LOGGING_CATEGORY(TG_CORE_SESSIONMANAGER, "tg.core.sessionmanager")
+
 SessionManager::SessionManager(Session *session, QObject *parent) :
     QObject(parent), mMainSession(session) {
     connect(mMainSession, SIGNAL(sessionReady(DC*)), this, SIGNAL(mainSessionReady()), Qt::UniqueConnection);
@@ -49,7 +51,7 @@
     }
 
     resourcesAtDc++;
-    qCDebug(TG_NET_SESSION) << "file session resources at DC" << dc->id() << resourcesAtDc;
+    qCDebug(TG_CORE_SESSIONMANAGER) << "file session resources at DC" << dc->id() << resourcesAtDc;
 
     return session;
 }
@@ -58,7 +60,7 @@
     Session *session = createSession(dc);
     mFileSessions.insert(session->sessionId(), session);
     mDcSessionIds.insert(dc->id(), session->sessionId());
-    qCDebug(TG_NET_SESSION) << "created file session at DC" << dc->id();
+    qCDebug(TG_CORE_SESSIONMANAGER) << "created file session at DC" << dc->id();
     return session;
 }
 
@@ -80,10 +82,10 @@
         if (!resourcesAtDc) {
             session->close();
             mDcSessionIds.remove(dcId);
-            qCDebug(TG_NET_SESSION) << "closed file session at DC" << dcId;
-            qCDebug(TG_NET_SESSION) << "remaining" << mFileSessions.count() << "file sessions, counting all DCs";
+            qCDebug(TG_CORE_SESSIONMANAGER) << "closed file session at DC" << dcId;
+            qCDebug(TG_CORE_SESSIONMANAGER) << "remaining" << mFileSessions.count() << "file sessions, counting all DCs";
         } else {
-            qCDebug(TG_NET_SESSION) << "released file session at DC" << dcId << ", remaining" << resourcesAtDc << "resources";
+            qCDebug(TG_CORE_SESSIONMANAGER) << "released file session at DC" << dcId << ", remaining" << resourcesAtDc << "resources";
         }
     } else if (mMainSession && mMainSession->sessionId() == sessionId) {
         mMainSession->close();

=== modified file 'lib/core/sessionmanager.h'
--- lib/core/sessionmanager.h	2014-11-20 13:44:13 +0000
+++ lib/core/sessionmanager.h	2015-02-24 14:12:31 +0000
@@ -23,9 +23,12 @@
 
 #include <QObject>
 #include <QMap>
+#include <QLoggingCategory>
 #include "session.h"
 #include "dc.h"
 
+Q_DECLARE_LOGGING_CATEGORY(TG_CORE_SESSIONMANAGER)
+
 class SessionManager : public QObject
 {
     Q_OBJECT

=== modified file 'lib/core/settings.cpp'
--- lib/core/settings.cpp	2015-02-11 18:35:01 +0000
+++ lib/core/settings.cpp	2015-02-24 14:12:31 +0000
@@ -19,8 +19,8 @@
  */
 
 #include "settings.h"
-#include "utils.h"
-#include "constants.h"
+#include "util/utils.h"
+#include "util/constants.h"
 #include "dc.h"
 
 #include <QDir>
@@ -31,7 +31,7 @@
 
 #include <openssl/bn.h>
 
-Q_LOGGING_CATEGORY(TG_INIT_SETTINGS, "tg.init.settings")
+Q_LOGGING_CATEGORY(TG_CORE_SETTINGS, "tg.core.settings")
 
 Settings::Settings() :
     m_phoneNumber(""),
@@ -64,16 +64,16 @@
     if (!m_pubKey) {
         m_pubKey = Utils::rsaLoadPublicKey(publicKeyFile);
         m_pkFingerprint = Utils::computeRSAFingerprint(m_pubKey);
-        qCDebug(TG_INIT_SETTINGS) << "loaded Telegram public key from file:" << publicKeyFile;
+        qCDebug(TG_CORE_SETTINGS) << "loaded Telegram public key from file:" << publicKeyFile;
     }
 
-    qCDebug(TG_INIT_SETTINGS) << "loading configuration from path:" << configPath;
+    qCDebug(TG_CORE_SETTINGS) << "loading configuration from path:" << configPath;
     QDir configDir = QDir(configPath);
     if (!configDir.exists()) {
         if (QDir::root().mkpath(configPath)) {
-            qCDebug(TG_INIT_SETTINGS) << configPath << "config directory created";
+            qCDebug(TG_CORE_SETTINGS) << configPath << "config directory created";
         } else {
-            qCWarning(TG_INIT_SETTINGS) << "error creating config directory: " << configPath;
+            qCWarning(TG_CORE_SETTINGS) << "error creating config directory: " << configPath;
             return false;
         }
     }
@@ -88,13 +88,13 @@
             out << DEFAULT_CONFIG_CONTENTS;
             configFile.close();
         } else {
-            qCWarning(TG_INIT_SETTINGS) << "Impossible to open file " << configFilename << " for writting default configuration";
+            qCWarning(TG_CORE_SETTINGS) << "Impossible to open file " << configFilename << " for writting default configuration";
             return false;
         }
     }
 
     //read settings
-    qCDebug(TG_INIT_SETTINGS) << "loading settings file" << configFilename;
+    qCDebug(TG_CORE_SETTINGS) << "loading settings file" << configFilename;
     QSettings settings(configFilename, QSettings::IniFormat);
     m_testMode = settings.value(ST_TEST_MODE, false).toBool();
     m_managedDownloads = settings.value(ST_MANAGED_DOWNLOADS, false).toBool();
@@ -105,12 +105,12 @@
     m_stateFilename = settings.value(ST_STATE_FILE, configPath + '/' + STATE_FILE).toString();
 
     // log readed data
-    qCDebug(TG_INIT_SETTINGS) << "testMode:" << m_testMode;
-    qCDebug(TG_INIT_SETTINGS) << "managedDownloads:" << m_managedDownloads;
-    qCDebug(TG_INIT_SETTINGS) << "lang:" << m_langCode;
-    qCDebug(TG_INIT_SETTINGS) << "authFile:" << m_authFilename;
-    qCDebug(TG_INIT_SETTINGS) << "secretChatFile:" << m_secretChatFilename;
-    qCDebug(TG_INIT_SETTINGS) << "stateFile:" << m_stateFilename;
+    qCDebug(TG_CORE_SETTINGS) << "testMode:" << m_testMode;
+    qCDebug(TG_CORE_SETTINGS) << "managedDownloads:" << m_managedDownloads;
+    qCDebug(TG_CORE_SETTINGS) << "lang:" << m_langCode;
+    qCDebug(TG_CORE_SETTINGS) << "authFile:" << m_authFilename;
+    qCDebug(TG_CORE_SETTINGS) << "secretChatFile:" << m_secretChatFilename;
+    qCDebug(TG_CORE_SETTINGS) << "stateFile:" << m_stateFilename;
 
     readAuthFile();
     readSecretFile();
@@ -150,8 +150,8 @@
     m_workingDcNum = settings.value(ST_WORKING_DC_NUM, defaultDcId).toInt();
     m_ourId = settings.value(ST_OUR_ID).toInt();
 
-    qCDebug(TG_INIT_SETTINGS) << "workingDcNum:" << m_workingDcNum;
-    qCDebug(TG_INIT_SETTINGS) << "ourId:" << m_ourId;
+    qCDebug(TG_CORE_SETTINGS) << "workingDcNum:" << m_workingDcNum;
+    qCDebug(TG_CORE_SETTINGS) << "ourId:" << m_ourId;
 
     // read all dcs
     m_dcsList.clear();
@@ -171,7 +171,7 @@
         dc->setServerSalt(settings.value(ST_SERVER_SALT, 0).toLongLong());
         dc->setExpires(settings.value(ST_EXPIRES).toInt());
 
-        qCDebug(TG_INIT_SETTINGS) << "DC | id:" << dc->id() << ", state:" << dc->state() <<
+        qCDebug(TG_CORE_SETTINGS) << "DC | id:" << dc->id() << ", state:" << dc->state() <<
                     ", host:" << dc->host() << ", port:" << dc->port() <<
                     ", expires:" << dc->expires() << ", authKeyId:" << dc->authKeyId() <<
                     ", serverSalt:" << dc->serverSalt();
@@ -186,10 +186,10 @@
     QFile authFile(m_authFilename);
     if (authFile.exists()) {
         if (authFile.remove()) {
-            qCDebug(TG_INIT_SETTINGS) << "Auth file has been reset";
+            qCDebug(TG_CORE_SETTINGS) << "Auth file has been reset";
             return true;
         } else {
-            qCDebug(TG_INIT_SETTINGS) << "An error has happened when trying to remove auth file";
+            qCDebug(TG_CORE_SETTINGS) << "An error has happened when trying to remove auth file";
         }
     }
     return false;
@@ -201,9 +201,9 @@
     mG = settings.value(ST_G, 0).toInt();
     mP = QByteArray::fromBase64(settings.value(ST_P).toByteArray());
 
-    qCDebug(TG_INIT_SETTINGS) << "secret chats dh version:" << mVersion;
-    qCDebug(TG_INIT_SETTINGS) << "secret chats g:" << mG;
-    qCDebug(TG_INIT_SETTINGS) << "secret chats p:" << mP.toBase64();
+    qCDebug(TG_CORE_SETTINGS) << "secret chats dh version:" << mVersion;
+    qCDebug(TG_CORE_SETTINGS) << "secret chats g:" << mG;
+    qCDebug(TG_CORE_SETTINGS) << "secret chats p:" << mP.toBase64();
 
     mSecretChats.clear();
     qint32 n = settings.beginReadArray(ST_SECRET_CHATS_ARRAY);
@@ -236,7 +236,7 @@
         secretChat->setOutSeqNo(settings.value(ST_OUT_SEQ_NO, 0).toInt());
         mSecretChats.append(secretChat);
 
-        qCDebug(TG_INIT_SETTINGS) << "SecretChat:\nid:" << secretChat->chatId()
+        qCDebug(TG_CORE_SETTINGS) << "SecretChat:\nid:" << secretChat->chatId()
                                   << "\nadminId:" << secretChat->adminId()
                                   << "\nparticipantId:" << secretChat->participantId()
                                   << "\ndate:" << secretChat->date()

=== modified file 'lib/core/settings.h'
--- lib/core/settings.h	2015-02-04 15:46:54 +0000
+++ lib/core/settings.h	2015-02-24 14:12:31 +0000
@@ -78,7 +78,7 @@
 #include <openssl/rsa.h>
 #include "secret/secretchat.h"
 
-Q_DECLARE_LOGGING_CATEGORY(TG_INIT_SETTINGS)
+Q_DECLARE_LOGGING_CATEGORY(TG_CORE_SETTINGS)
 
 class DC;
 

=== removed file 'lib/core/tlvalues.h'
--- lib/core/tlvalues.h	2015-02-17 11:35:00 +0000
+++ lib/core/tlvalues.h	1970-01-01 00:00:00 +0000
@@ -1,444 +0,0 @@
-/*
- * Copyright 2014 Canonical Ltd.
- * Authors:
- *      Roberto Mier
- *      Tiago Herrmann
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef TLVALUES_H
-#define TLVALUES_H
-
-enum TLValues {
-    // https://core.telegram.org/mtproto/auth_key
-    TL_ReqPQ = 0x60469778,
-    TL_ResPQ = 0x05162463,
-    TL_ReqDHParams = 0xd712e4be,
-    TL_PQInnerData = 0x83c95aec,
-    TL_PQInnerDataTemp = 0x3c6a84d4,
-    TL_ServerDHParamsOK = 0xd0e8075c,
-    TL_ServerDHParamsFail = 0x79cb045d,
-    TL_ServerDHInnerData = 0xb5890dba,
-    TL_ClientDHInnerData = 0x6643b654,
-    TL_SetClientDHParams = 0xf5045f1f,
-    TL_DHGenOK = 0x3bcbf734,
-
-    // https://core.telegram.org/mtproto/service_messages
-    TL_RpcResult = 0xf35c6d01,
-    TL_RpcError = 0x2144ca19,
-    TL_RpcDropAnswer = 0x58e4a740,
-    TL_RpcAnswerUnknown = 0x5e2ad36e,
-    TL_RpcAnswerDroppedRunning = 0xcd78e586,
-    TL_RpcAnswerDropped = 0xa43ad8b7,
-    TL_GetFutureSalts = 0xb921bd04,
-    TL_FutureSalt = 0x0949d9dc,
-    TL_FutureSalts = 0xae500895,
-    TL_Ping = 0x7abe77ec,
-    TL_Pong = 0x347773c5,
-    TL_PingDelayDisconnect = 0xf3427b8c,
-    TL_DestroySession = 0xe7512126,
-    TL_DestroySessionOk = 0xe22045fc,
-    TL_DestroySessionNone = 0x62d350c9,
-    TL_NewSessionCreated = 0x9ec20908,
-    TL_MsgContainer = 0x73f1f8dc,
-    TL_MsgCopy = 0xe06046b2,
-    TL_GZipPacked = 0x3072cfa1,
-    TL_HttpWait = 0x9299359f,
-
-    // https://core.telegram.org/mtproto/service_messages_about_messages
-    TL_MsgsAck = 0x62d6b459,
-    TL_BadMsgNotification = 0xa7eff811,
-    TL_BadServerSalt = 0xedab447b,
-    TL_MsgsStateReq = 0xda69fb52,
-    TL_MsgsStateInfo = 0x04deb57d,
-    TL_MsgsAllInfo = 0x8cc0d131,
-    TL_MsgDetailedInfo = 0x276d3ec6,
-    TL_MsgNewDetailedInfo = 0x809db6df,
-    TL_MsgResendReq = 0x7d861a08,
-
-    // https://core.telegram.org/schema by generator
-    TL_BoolFalse = 0xbc799737,
-    TL_BoolTrue = 0x997275b5,
-    TL_Vector = 0x1cb5c415,
-    TL_Error = 0xc4b9f9bb,
-    TL_Null = 0x56730bcc,
-    TL_InputPeerEmpty = 0x7f3b18ea,
-    TL_InputPeerSelf = 0x7da07ec9,
-    TL_InputPeerContact = 0x1023dbe8,
-    TL_InputPeerForeign = 0x9b447325,
-    TL_InputPeerChat = 0x179be863,
-    TL_InputUserEmpty = 0xb98886cf,
-    TL_InputUserSelf = 0xf7c1b13f,
-    TL_InputUserContact = 0x86e94f65,
-    TL_InputUserForeign = 0x655e74ff,
-    TL_InputPhoneContact = 0xf392b7f4,
-    TL_InputFile = 0xf52ff27f,
-    TL_InputMediaEmpty = 0x9664f57f,
-    TL_InputMediaUploadedPhoto = 0x2dc53a7d,
-    TL_InputMediaPhoto = 0x8f2ab2ec,
-    TL_InputMediaGeoPoint = 0xf9c44144,
-    TL_InputMediaContact = 0xa6e45987,
-    TL_InputMediaUploadedVideo = 0x133ad6f6,
-    TL_InputMediaUploadedThumbVideo = 0x9912dabf,
-    TL_InputMediaVideo = 0x7f023ae6,
-    TL_InputChatPhotoEmpty = 0x1ca48f57,
-    TL_InputChatUploadedPhoto = 0x94254732,
-    TL_InputChatPhoto = 0xb2e1bf08,
-    TL_InputGeoPointEmpty = 0xe4c123d6,
-    TL_InputGeoPoint = 0xf3b7acc9,
-    TL_InputPhotoEmpty = 0x1cd7bf0d,
-    TL_InputPhoto = 0xfb95c6c4,
-    TL_InputVideoEmpty = 0x5508ec75,
-    TL_InputVideo = 0xee579652,
-    TL_InputFileLocation = 0x14637196,
-    TL_InputVideoFileLocation = 0x3d0364ec,
-    TL_InputPhotoCropAuto = 0xade6b004,
-    TL_InputPhotoCrop = 0xd9915325,
-    TL_InputAppEvent = 0x770656a8,
-    TL_PeerUser = 0x9db1bc6d,
-    TL_PeerChat = 0xbad0e5bb,
-    TL_StorageFileUnknown = 0xaa963b05,
-    TL_StorageFileJpeg = 0x7efe0e,
-    TL_StorageFileGif = 0xcae1aadf,
-    TL_StorageFilePng = 0xa4f63c0,
-    TL_StorageFilePdf = 0xae1e508d,
-    TL_StorageFileMp3 = 0x528a0677,
-    TL_StorageFileMov = 0x4b09ebbc,
-    TL_StorageFilePartial = 0x40bc6f52,
-    TL_StorageFileMp4 = 0xb3cea0e4,
-    TL_StorageFileWebp = 0x1081464c,
-    TL_FileLocationUnavailable = 0x7c596b46,
-    TL_FileLocation = 0x53d69076,
-    TL_UserEmpty = 0x200250ba,
-    TL_UserSelf = 0x720535ec,
-    TL_UserContact = 0xf2fb8319,
-    TL_UserRequest = 0x22e8ceb0,
-    TL_UserForeign = 0x5214c89d,
-    TL_UserDeleted = 0xb29ad7cc,
-    TL_UserProfilePhotoEmpty = 0x4f11bae1,
-    TL_UserProfilePhoto = 0xd559d8c8,
-    TL_UserStatusEmpty = 0x9d05049,
-    TL_UserStatusOnline = 0xedb93949,
-    TL_UserStatusOffline = 0x8c703f,
-    TL_ChatEmpty = 0x9ba2d800,
-    TL_Chat = 0x6e9c9bc7,
-    TL_ChatForbidden = 0xfb0ccc41,
-    TL_ChatFull = 0x630e61be,
-    TL_ChatParticipant = 0xc8d7493e,
-    TL_ChatParticipantsForbidden = 0xfd2bb8a,
-    TL_ChatParticipants = 0x7841b415,
-    TL_ChatPhotoEmpty = 0x37c1011c,
-    TL_ChatPhoto = 0x6153276a,
-    TL_MessageEmpty = 0x83e5de54,
-    TL_Message = 0x22eb6aba,
-    TL_MessageForwarded = 0x5f46804,
-    TL_MessageService = 0x9f8d60bb,
-    TL_MessageMediaEmpty = 0x3ded6320,
-    TL_MessageMediaPhoto = 0xc8c45a2a,
-    TL_MessageMediaVideo = 0xa2d24290,
-    TL_MessageMediaGeo = 0x56e0d474,
-    TL_MessageMediaContact = 0x5e7d2f39,
-    TL_MessageMediaUnsupported = 0x29632a36,
-    TL_MessageActionEmpty = 0xb6aef7b0,
-    TL_MessageActionChatCreate = 0xa6638b9a,
-    TL_MessageActionChatEditTitle = 0xb5a1ce5a,
-    TL_MessageActionChatEditPhoto = 0x7fcb13a8,
-    TL_MessageActionChatDeletePhoto = 0x95e3fbef,
-    TL_MessageActionChatAddUser = 0x5e3cfc4b,
-    TL_MessageActionChatDeleteUser = 0xb2ae9b0c,
-    TL_Dialog = 0x214a8cdf,
-    TL_PhotoEmpty = 0x2331b22d,
-    TL_Photo = 0x22b56751,
-    TL_PhotoSizeEmpty = 0xe17e23c,
-    TL_PhotoSize = 0x77bfb61b,
-    TL_PhotoCachedSize = 0xe9a734fa,
-    TL_VideoEmpty = 0xc10658a8,
-    TL_Video = 0x388fa391,
-    TL_GeoPointEmpty = 0x1117dd5f,
-    TL_GeoPoint = 0x2049d70c,
-    TL_AuthCheckedPhone = 0xe300cc3b,
-    TL_AuthSentCode = 0xefed51d9,
-    TL_AuthSentAppCode = 0xe325edcf,
-    TL_AuthAuthorization = 0xf6b673a4,
-    TL_AuthExportedAuthorization = 0xdf969c2d,
-    TL_InputNotifyPeer = 0xb8bc5b0c,
-    TL_InputNotifyUsers = 0x193b4417,
-    TL_InputNotifyChats = 0x4a95e84e,
-    TL_InputNotifyAll = 0xa429b886,
-    TL_InputPeerNotifyEventsEmpty = 0xf03064d8,
-    TL_InputPeerNotifyEventsAll = 0xe86a2c74,
-    TL_InputPeerNotifySettings = 0x46a2ce98,
-    TL_PeerNotifyEventsEmpty = 0xadd53cb3,
-    TL_PeerNotifyEventsAll = 0x6d1ded88,
-    TL_PeerNotifySettingsEmpty = 0x70a68512,
-    TL_PeerNotifySettings = 0x8d5e11ee,
-    TL_WallPaper = 0xccb03657,
-    TL_UserFull = 0x771095da,
-    TL_Contact = 0xf911c994,
-    TL_ImportedContact = 0xd0028438,
-    TL_ContactBlocked = 0x561bc879,
-    TL_ContactFound = 0xea879f95,
-    TL_ContactSuggested = 0x3de191a1,
-    TL_ContactStatus = 0xaa77b873,
-    TL_ChatLocated = 0x3631cf4c,
-    TL_ContactsForeignLinkUnknown = 0x133421f8,
-    TL_ContactsForeignLinkRequested = 0xa7801f47,
-    TL_ContactsForeignLinkMutual = 0x1bea8ce1,
-    TL_ContactsMyLinkEmpty = 0xd22a1c60,
-    TL_ContactsMyLinkRequested = 0x6c69efee,
-    TL_ContactsMyLinkContact = 0xc240ebd9,
-    TL_ContactsLink = 0xeccea3f5,
-    TL_ContactsContacts = 0x6f8b8cb2,
-    TL_ContactsContactsNotModified = 0xb74ba9d2,
-    TL_ContactsImportedContacts = 0xad524315,
-    TL_ContactsBlocked = 0x1c138d15,
-    TL_ContactsBlockedSlice = 0x900802a1,
-    TL_ContactsFound = 0x566000e,
-    TL_ContactsSuggested = 0x5649dcc5,
-    TL_MessagesDialogs = 0x15ba6c40,
-    TL_MessagesDialogsSlice = 0x71e094f3,
-    TL_MessagesMessages = 0x8c718e87,
-    TL_MessagesMessagesSlice = 0xb446ae3,
-    TL_MessagesMessageEmpty = 0x3f4e0648,
-    TL_MessagesMessage = 0xff90c417,
-    TL_MessagesStatedMessages = 0x969478bb,
-    TL_MessagesStatedMessage = 0xd07ae726,
-    TL_MessagesSentMessage = 0xd1f4d35c,
-    TL_MessagesChat = 0x40e9002a,
-    TL_MessagesChats = 0x8150cbd8,
-    TL_MessagesChatFull = 0xe5d7d19c,
-    TL_MessagesAffectedHistory = 0xb7de36f2,
-    TL_InputMessagesFilterEmpty = 0x57e2f66c,
-    TL_InputMessagesFilterPhotos = 0x9609a51c,
-    TL_InputMessagesFilterVideo = 0x9fc00e65,
-    TL_InputMessagesFilterPhotoVideo = 0x56e9f0e4,
-    TL_InputMessagesFilterDocument = 0x9eddf188,
-    TL_UpdateNewMessage = 0x13abdb3,
-    TL_UpdateMessageID = 0x4e90bfd6,
-    TL_UpdateReadMessages = 0xc6649e31,
-    TL_UpdateDeleteMessages = 0xa92bfe26,
-    TL_UpdateRestoreMessages = 0xd15de04d,
-    TL_UpdateUserTyping = 0x6baa8508,
-    TL_UpdateChatUserTyping = 0x3c46cfe6,
-    TL_UpdateChatParticipants = 0x7761198,
-    TL_UpdateUserStatus = 0x1bfbd823,
-    TL_UpdateUserName = 0xda22d9ad,
-    TL_UpdateUserPhoto = 0x95313b0c,
-    TL_UpdateContactRegistered = 0x2575bbb9,
-    TL_UpdateContactLink = 0x51a48a9a,
-    TL_UpdateActivation = 0x6f690963,
-    TL_UpdateNewAuthorization = 0x8f06529a,
-    TL_UpdatesState = 0xa56c2a3e,
-    TL_UpdatesDifferenceEmpty = 0x5d75a138,
-    TL_UpdatesDifference = 0xf49ca0,
-    TL_UpdatesDifferenceSlice = 0xa8fb1981,
-    TL_UpdatesTooLong = 0xe317af7e,
-    TL_UpdateShortMessage = 0xd3f45784,
-    TL_UpdateShortChatMessage = 0x2b2fbd4e,
-    TL_UpdateShort = 0x78d4dec1,
-    TL_UpdatesCombined = 0x725b04c3,
-    TL_Updates = 0x74ae4240,
-    TL_PhotosPhotos = 0x8dca6aa5,
-    TL_PhotosPhotosSlice = 0x15051f54,
-    TL_PhotosPhoto = 0x20212ca8,
-    TL_UploadFile = 0x96a18d5,
-    TL_DcOption = 0x2ec2a43c,
-    TL_Config = 0x2e54dd74,
-    TL_NearestDc = 0x8e1a1775,
-    TL_HelpAppUpdate = 0x8987f311,
-    TL_HelpNoAppUpdate = 0xc45a6536,
-    TL_HelpInviteText = 0x18cb9f78,
-    TL_MessagesStatedMessagesLinks = 0x3e74f5c6,
-    TL_MessagesStatedMessageLink = 0xa9af2881,
-    TL_MessagesSentMessageLink = 0xe9db4a3f,
-    TL_InputGeoChat = 0x74d456fa,
-    TL_InputNotifyGeoChatPeer = 0x4d8ddec8,
-    TL_GeoChat = 0x75eaea5a,
-    TL_GeoChatMessageEmpty = 0x60311a9b,
-    TL_GeoChatMessage = 0x4505f8e1,
-    TL_GeoChatMessageService = 0xd34fa24e,
-    TL_GeochatsStatedMessage = 0x17b1578b,
-    TL_GeochatsLocated = 0x48feb267,
-    TL_GeochatsMessages = 0xd1526db1,
-    TL_GeochatsMessagesSlice = 0xbc5863e8,
-    TL_MessageActionGeoChatCreate = 0x6f038ebc,
-    TL_MessageActionGeoChatCheckin = 0xc7d53de,
-    TL_UpdateNewGeoChatMessage = 0x5a68e3f7,
-    TL_WallPaperSolid = 0x63117f24,
-    TL_UpdateNewEncryptedMessage = 0x12bcbd9a,
-    TL_UpdateEncryptedChatTyping = 0x1710f156,
-    TL_UpdateEncryption = 0xb4a2e88d,
-    TL_UpdateEncryptedMessagesRead = 0x38fe25b7,
-    TL_EncryptedChatEmpty = 0xab7ec0a0,
-    TL_EncryptedChatWaiting = 0x3bf703dc,
-    TL_EncryptedChatRequested = 0xc878527e,
-    TL_EncryptedChat = 0xfa56ce36,
-    TL_EncryptedChatDiscarded = 0x13d6dd27,
-    TL_InputEncryptedChat = 0xf141b5e1,
-    TL_EncryptedFileEmpty = 0xc21f497e,
-    TL_EncryptedFile = 0x4a70994c,
-    TL_InputEncryptedFileEmpty = 0x1837c364,
-    TL_InputEncryptedFileUploaded = 0x64bd0306,
-    TL_InputEncryptedFile = 0x5a17b5e5,
-    TL_InputEncryptedFileLocation = 0xf5235d55,
-    TL_EncryptedMessage = 0xed18c118,
-    TL_EncryptedMessageService = 0x23734b06,
-    TL_DecryptedMessageLayer = 0x1be31789,
-    TL_DecryptedMessage_layer8 = 0x1f814f1f,
-    TL_DecryptedMessage = 0x204d3878,
-    TL_DecryptedMessageService_layer8 = 0xaa48327d,
-    TL_DecryptedMessageService = 0x73164160,
-    TL_DecryptedMessageMediaEmpty = 0x89f5c4a,
-    TL_DecryptedMessageMediaPhoto = 0x32798a8c,
-    TL_DecryptedMessageMediaVideo_layer8 = 0x4cee6ef3,
-    TL_DecryptedMessageMediaVideo = 0x524a415d,
-    TL_DecryptedMessageMediaGeoPoint = 0x35480a59,
-    TL_DecryptedMessageMediaContact = 0x588a0a97,
-    TL_DecryptedMessageMediaAudio_layer8 = 0x6080758f,
-    TL_DecryptedMessageMediaAudio = 0x57e0a9cb,
-    TL_DecryptedMessageActionSetMessageTTL = 0xa1733aec,
-    TL_DecryptedMessageActionReadMessages = 0xc4f40be,
-    TL_DecryptedMessageActionDeleteMessages = 0x65614304,
-    TL_DecryptedMessageActionScreenshotMessages = 0x8ac1f475,
-    TL_DecryptedMessageActionFlushHistory = 0x6719e45c,
-    TL_DecryptedMessageActionResend = 0x511110b0,
-    TL_DecryptedMessageActionNotifyLayer = 0xf3048883,
-    TL_DecryptedMessageActionTyping = 0xccb27641,
-    TL_MessagesDhConfigNotModified = 0xc0e24635,
-    TL_MessagesDhConfig = 0x2c221edd,
-    TL_MessagesSentEncryptedMessage = 0x560f8935,
-    TL_MessagesSentEncryptedFile = 0x9493ff32,
-    TL_InputFileBig = 0xfa4f0bb5,
-    TL_InputEncryptedFileBigUploaded = 0x2dc173c8,
-    TL_UpdateChatParticipantAdd = 0x3a0eeb22,
-    TL_UpdateChatParticipantDelete = 0x6e5f8c22,
-    TL_UpdateDcOptions = 0x8e5e9873,
-    TL_InputMediaUploadedAudio = 0x4e498cab,
-    TL_InputMediaAudio = 0x89938781,
-    TL_InputMediaUploadedDocument = 0x34e794bd,
-    TL_InputMediaUploadedThumbDocument = 0x3e46de5d,
-    TL_InputMediaDocument = 0xd184e841,
-    TL_MessageMediaDocument = 0x2fda2204,
-    TL_MessageMediaAudio = 0xc6b68300,
-    TL_InputAudioEmpty = 0xd95adc84,
-    TL_InputAudio = 0x77d440ff,
-    TL_InputDocumentEmpty = 0x72f0eaae,
-    TL_InputDocument = 0x18798952,
-    TL_InputAudioFileLocation = 0x74dc404d,
-    TL_InputDocumentFileLocation = 0x4e45abe9,
-    TL_DecryptedMessageMediaDocument = 0xb095434b,
-    TL_AudioEmpty = 0x586988d8,
-    TL_Audio = 0xc7ac6496,
-    TL_DocumentEmpty = 0x36f8c871,
-    TL_Document = 0x9efc6326,
-    TL_HelpSupport = 0x17c6b5f6,
-    TL_InvokeAfterMsg = 0xcb9f372d,
-    TL_InvokeAfterMsgs = 0x3dc4b4f0,
-    TL_AuthCheckPhone = 0x6fe51dfb,
-    TL_AuthSendCode = 0x768d5f4d,
-    TL_AuthSendSms = 0xda9f3e8,
-    TL_AuthSendCall = 0x3c51564,
-    TL_AuthSignUp = 0x1b067634,
-    TL_AuthSignIn = 0xbcd51581,
-    TL_AuthLogOut = 0x5717da40,
-    TL_AuthResetAuthorizations = 0x9fab0d1a,
-    TL_AuthSendInvites = 0x771c1d97,
-    TL_AuthExportAuthorization = 0xe5bfffcd,
-    TL_AuthImportAuthorization = 0xe3ef9613,
-    TL_AccountRegisterDevice = 0x446c712c,
-    TL_AccountUnregisterDevice = 0x65c55b40,
-    TL_AccountUpdateNotifySettings = 0x84be5b93,
-    TL_AccountGetNotifySettings = 0x12b3ad31,
-    TL_AccountResetNotifySettings = 0xdb7e1747,
-    TL_AccountUpdateProfile = 0xf0888d68,
-    TL_AccountUpdateStatus = 0x6628562c,
-    TL_AccountGetWallPapers = 0xc04cfac2,
-    TL_UsersGetUsers = 0xd91a548,
-    TL_UsersGetFullUser = 0xca30a5b1,
-    TL_ContactsGetStatuses = 0xc4a353ee,
-    TL_ContactsGetContacts = 0x22c6aa08,
-    TL_ContactsImportContacts = 0xda30b32d,
-    TL_ContactsSearch = 0x11f812d8,
-    TL_ContactsGetSuggested = 0xcd773428,
-    TL_ContactsDeleteContact = 0x8e953744,
-    TL_ContactsDeleteContacts = 0x59ab389e,
-    TL_ContactsBlock = 0x332b49fc,
-    TL_ContactsUnblock = 0xe54100bd,
-    TL_ContactsGetBlocked = 0xf57c350f,
-    TL_MessagesGetMessages = 0x4222fa74,
-    TL_MessagesGetDialogs = 0xeccf1df6,
-    TL_MessagesGetHistory = 0x92a1df2f,
-    TL_MessagesSearch = 0x7e9f2ab,
-    TL_MessagesReadHistory = 0xeed884c6,
-    TL_MessagesReadMessageContents = 0x354b5bc2,
-    TL_MessagesDeleteHistory = 0xf4f8fb61,
-    TL_MessagesDeleteMessages = 0x14f2dd0a,
-    TL_MessagesRestoreMessages = 0x395f9d7e,
-    TL_MessagesReceivedMessages = 0x28abcb68,
-    TL_MessagesSetTyping = 0xa3825e50,
-    TL_MessagesSendMessage = 0x4cde0aab,
-    TL_MessagesSendMedia = 0xa3c85d76,
-    TL_MessagesForwardMessages = 0x514cd10f,
-    TL_MessagesGetChats = 0x3c6aa187,
-    TL_MessagesGetFullChat = 0x3b831c66,
-    TL_MessagesEditChatTitle = 0xb4bc68b5,
-    TL_MessagesEditChatPhoto = 0xd881821d,
-    TL_MessagesAddChatUser = 0x2ee9ee9e,
-    TL_MessagesDeleteChatUser = 0xc3c5cd23,
-    TL_MessagesCreateChat = 0x419d9aee,
-    TL_UpdatesGetState = 0xedd4882a,
-    TL_UpdatesGetDifference = 0xa041495,
-    TL_PhotosUpdateProfilePhoto = 0xeef579a0,
-    TL_PhotosUploadProfilePhoto = 0xd50f9c88,
-    TL_UploadSaveFilePart = 0xb304a621,
-    TL_UploadGetFile = 0xe3a6cfb5,
-    TL_HelpGetConfig = 0xc4f9186b,
-    TL_HelpGetNearestDc = 0x1fb33026,
-    TL_HelpGetAppUpdate = 0xc812ac7e,
-    TL_HelpSaveAppLog = 0x6f02f748,
-    TL_HelpGetInviteText = 0xa4a95186,
-    TL_PhotosGetUserPhotos = 0xb7ee553c,
-    TL_MessagesForwardMessage = 0x3f3f4f2,
-    TL_MessagesSendBroadcast = 0x41bb0972,
-    TL_GeochatsGetLocated = 0x7f192d8f,
-    TL_GeochatsGetRecents = 0xe1427e6f,
-    TL_GeochatsCheckin = 0x55b3e8fb,
-    TL_GeochatsGetFullChat = 0x6722dd6f,
-    TL_GeochatsEditChatTitle = 0x4c8e2273,
-    TL_GeochatsEditChatPhoto = 0x35d81a95,
-    TL_GeochatsSearch = 0xcfcdc44d,
-    TL_GeochatsGetHistory = 0xb53f7a68,
-    TL_GeochatsSetTyping = 0x8b8a729,
-    TL_GeochatsSendMessage = 0x61b0044,
-    TL_GeochatsSendMedia = 0xb8f0deff,
-    TL_GeochatsCreateGeoChat = 0xe092e16,
-    TL_MessagesGetDhConfig = 0x26cf8950,
-    TL_MessagesRequestEncryption = 0xf64daf43,
-    TL_MessagesAcceptEncryption = 0x3dbc0415,
-    TL_MessagesDiscardEncryption = 0xedd923c5,
-    TL_MessagesSetEncryptedTyping = 0x791451ed,
-    TL_MessagesReadEncryptedHistory = 0x7f4b690a,
-    TL_MessagesSendEncrypted = 0xa9776773,
-    TL_MessagesSendEncryptedFile = 0x9a901b66,
-    TL_MessagesSendEncryptedService = 0x32d439a4,
-    TL_MessagesReceivedQueue = 0x55a5bb66,
-    TL_UploadSaveBigFilePart = 0xde7b673d,
-    TL_InitConnection = 0x69796de9,
-    TL_HelpGetSupport = 0x9cdf08cd,
-    //TL_InvokeWithLayer14 = 0x2b9b08fa
-    TL_InvokeWithLayer17 = 0x50858a19
-};
-
-#endif // TLVALUES_H

=== removed file 'lib/core/utils.cpp'
--- lib/core/utils.cpp	2015-01-07 15:59:33 +0000
+++ lib/core/utils.cpp	1970-01-01 00:00:00 +0000
@@ -1,377 +0,0 @@
-/*
- * Copyright 2013 Vitaly Valtman
- * Copyright 2014 Canonical Ltd.
- * Authors:
- *      Roberto Mier
- *      Tiago Herrmann
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include "utils.h"
-#include <openssl/rand.h>
-#include <openssl/pem.h>
-#include <openssl/err.h>
-#include <sys/utsname.h>
-#include <zlib.h>
-
-#include <QDebug>
-#include <QEventLoop>
-#include <QtMultimedia/QMediaPlayer>
-#include <QtMultimedia/QMediaContent>
-#include <QtMultimedia/QMediaResource>
-#include <QProcess>
-#include <QStringList>
-#include <QtCore>
-
-
-Q_LOGGING_CATEGORY(TG_UTILS, "tg.utils")
-
-
-Utils::Utils(QObject *parent) :
-    QObject(parent)
-{
-}
-
-qint32 Utils::randomBytes(void *buffer, qint32 count) {
-    qint32 returnValue = RAND_bytes ((uchar *)buffer, count);
-    if (returnValue < 0) {
-        returnValue = RAND_pseudo_bytes ((uchar *)buffer, count);
-    }
-    return returnValue;
-}
-
-qint32 Utils::serializeBignum(BIGNUM *b, char *buffer, qint32 maxlen) {
-    qint32 itslen = BN_num_bytes (b);
-    qint32 reqlen;
-    if (itslen < 254) {
-        reqlen = itslen + 1;
-    } else {
-        reqlen = itslen + 4;
-    }
-    qint32 newlen = (reqlen + 3) & -4;
-    qint32 pad = newlen - reqlen;
-    reqlen = newlen;
-    if (reqlen > maxlen) {
-        return -reqlen;
-    }
-    if (itslen < 254) {
-        *buffer++ = itslen;
-    } else {
-        *(qint32 *)buffer = (itslen << 8) + 0xfe;
-        buffer += 4;
-    }
-    qint32 l = BN_bn2bin (b, (uchar *)buffer);
-    Q_ASSERT (l == itslen);
-    buffer += l;
-    while (pad --> 0) {
-        *buffer++ = 0;
-    }
-    return reqlen;
-}
-
-double Utils::getUTime(qint32 clockId) {
-    struct timespec T;
-    qint32 success = clock_gettime(clockId, &T);
-    Q_UNUSED(success);
-    Q_ASSERT(success == 0);
-    double res = T.tv_sec + (double) T.tv_nsec * 1e-9;
-    return res;
-}
-
-quint64 Utils::gcd(quint64 a, quint64 b) {
-  return b ? gcd (b, a % b) : a;
-}
-
-qint32 Utils::check_g (uchar p[256], BIGNUM *g) {
-    static uchar s[256];
-    memset (s, 0, 256);
-    Q_ASSERT(BN_num_bytes (g) <= 256);
-    BN_bn2bin (g, s);
-    qint32 ok = 0;
-    qint32 i;
-    for (i = 0; i < 64; i++) {
-        if (s[i]) {
-            ok = 1;
-            break;
-        }
-    }
-    if (!ok) { return -1; }
-    ok = 0;
-    for (i = 0; i < 64; i++) {
-        if (s[255 - i]) {
-            ok = 1;
-            break;
-        }
-    }
-    if (!ok) { return -1; }
-    ok = 0;
-    for (i = 0; i < 64; i++) {
-        if (s[i] < p[i]) {
-            ok = 1;
-            break;
-        } else if (s[i] > p[i]) {
-            qDebug() << i << "=" << (qint32)s[i] << (qint32)p[i];
-            return -1;
-        }
-    }
-    if (!ok) { return -1; }
-    return 0;
-}
-
-qint32 Utils::check_g_bn (BIGNUM *p, BIGNUM *g) {
-    static uchar s[256];
-    memset (s, 0, 256);
-    Q_ASSERT(BN_num_bytes (p) <= 256);
-    BN_bn2bin (p, s);
-    return check_g (s, g);
-}
-
-void Utils::ensurePtr(void *p) {
-    if (p == NULL) {
-        qFatal("Out of memory");
-        exit (1);
-    }
-}
-
-void Utils::ensure (qint32 r) {
-  if (!r) {
-    ERR_print_errors_fp (stderr);
-    Q_ASSERT(0);
-  }
-}
-
-void Utils::freeSecure(void *ptr, qint32 size) {
-    if (!ptr) return;
-    memset (ptr, 0, size);
-    free (ptr);
-}
-
-RSA *Utils::rsaLoadPublicKey(const QString &publicKeyName) {
-    RSA *pubKey = NULL;
-    FILE *f = fopen (publicKeyName.toLocal8Bit().data(), "r");
-    if (f == NULL) {
-        qCWarning(TG_UTILS) << "Couldn't open public key file" << publicKeyName;
-        return NULL;
-    }
-    pubKey = PEM_read_RSAPublicKey (f, NULL, NULL, NULL);
-    fclose (f);
-    if (pubKey == NULL) {
-        qCWarning(TG_UTILS) << "PEM_read_RSAPublicKey returns NULL";
-        return NULL;
-    }
-    qCDebug(TG_UTILS) << "public key" << publicKeyName << "loaded successfully";
-    return pubKey;
-}
-
-qint64 Utils::computeRSAFingerprint(RSA *key) {
-    static char tempbuff[4096];
-    static uchar sha[20];
-    Q_ASSERT(key->n && key->e);
-    qint32 l1 = serializeBignum (key->n, tempbuff, 4096);
-    Q_ASSERT(l1 > 0);
-    qint32 l2 = serializeBignum (key->e, tempbuff + l1, 4096 - l1);
-    Q_ASSERT(l2 > 0 && l1 + l2 <= 4096);
-    SHA1 ((uchar *)tempbuff, l1 + l2, sha);
-    return *(qint64 *)(sha + 12);
-}
-
-void *Utils::talloc(size_t size) {
-#ifdef DEBUG
-  total_allocated_bytes += size;
-  void *p = malloc (size + RES_PRE + RES_AFTER);
-  ensurePtr (p);
-  *(qint32 *)p = size ^ 0xbedabeda;
-  *(qint32 *)(p + 4) = size;
-  *(qint32 *)(p + RES_PRE + size) = size ^ 0x7bed7bed;
-  *(qint32 *)(p + RES_AFTER + 4 + size) = usedBlocks;
-  blocks[usedBlocks ++] = p;
-  return p + 8;
-#else
-  void *p = malloc (size);
-  ensurePtr (p);
-  return p;
-#endif
-}
-
-qint32 Utils::tinflate(void *input, qint32 ilen, void *output, qint32 olen) {
-    z_stream strm;
-    memset(&strm, 0, sizeof (strm));
-    qint32 inflateResult = inflateInit2(&strm, 16 + MAX_WBITS);
-    Q_UNUSED(inflateResult);
-    Q_ASSERT(inflateResult == Z_OK);
-    strm.avail_in = ilen;
-    strm.next_in = (Bytef *)input;
-    strm.avail_out = olen ;
-    strm.next_out = (Bytef *)output;
-    qint32 err = inflate (&strm, Z_FINISH), totalOut = 0;
-    if (err == Z_OK || err == Z_STREAM_END) {
-        totalOut = (qint32) strm.total_out;
-    }
-    inflateEnd (&strm);
-    return totalOut;
-}
-
-QString Utils::toHex(qint32 x) {
-    return "0x" + QString::number(static_cast<quint32>(x), 16);
-}
-
-QString Utils::toHex(void *buffer, qint32 size) {
-    QByteArray array((char *)buffer, size);
-    QByteArray hexArray = array.toHex();
-    QString sb;
-    qint32 count = 0;
-    for (qint32 i = 0; i < hexArray.length(); i += 2) {
-        count++;
-        sb.append(QString(hexArray.at(i)).toUpper());
-        sb.append(QString(hexArray.at(i+1)).toUpper());
-        if (count == 8) {
-            sb.append("\n");
-            count = 0;
-        } else if (count == 4) {
-            sb.append("\t");
-        } else {
-            sb.append(" ");
-        }
-    }
-    return sb;
-}
-
-BIGNUM *Utils::padBytesAndGetBignum(const QByteArray &gAOrB) {
-    // padding of B (gAOrB) to have exactly 256 bytes
-    uchar paddedGAOrB[256];
-    qint32 length = gAOrB.length();
-    // check that size of
-    uchar *rawGAOrB = (uchar *)gAOrB.data();
-    if (length < 256) {
-      memcpy (paddedGAOrB + 256 - length, rawGAOrB, length);
-    } else {
-      memcpy (paddedGAOrB, rawGAOrB + (length - 256), 256);
-    }
-
-    BIGNUM *bigNumGAOrB = BN_bin2bn(paddedGAOrB, 256, 0);
-    return bigNumGAOrB;
-}
-
-BIGNUM *Utils::bytesToBignum(const QByteArray &bytes) {
-    uchar *data = (uchar *)bytes.data();
-    qint32 length = bytes.length();
-    BIGNUM *bignum = BN_bin2bn(data, length, 0);
-    return bignum;
-}
-
-QByteArray Utils::bignumToBytes(BIGNUM *bignum) {
-    qint32 length = BN_num_bytes(bignum);
-    uchar data[length];
-    BN_bn2bin(bignum, data);
-    return QByteArray((char *)data, length);
-}
-
-qint64 Utils::getKeyFingerprint(uchar *sharedKey) {
-    uchar shaBuffer[20];
-    SHA1(sharedKey, 256, shaBuffer);
-    qint64 keyFingerprint = *(qint64 *)(shaBuffer + 12);
-    return keyFingerprint;
-}
-
-QString Utils::getDeviceModel() {
-    struct utsname st;
-    uname(&st);
-    return QString(st.machine);
-}
-
-QString Utils::getSystemVersion() {
-    struct utsname st;
-    uname(&st);
-    return QString(QString(st.sysname) + " " + QString(st.release) + " " + QString(st.version));
-}
-
-QString Utils::getAppVersion() {
-    return LIBQTELEGRAM_VERSION " (build " LIBQTELEGRAM_BUILD ")";
-}
-
-QString Utils::parsePhoneNumberDigits(const QString &phoneNumber) {
-    // Only allowing + and [0..9] chars
-    QString filteredChars;
-
-    if (phoneNumber.length() > 0) {
-
-        for (int i = 0; i < phoneNumber.length(); i++) {
-            const QChar c = phoneNumber.at(i);
-            if (c.isDigit() || c == '+') {
-                filteredChars.append(c);
-            }
-        }
-    }
-
-    return filteredChars;
-}
-
-QByteArray Utils::pToBigEndian(quint32 p) {;
-    qint32 pLength;
-    if (p < (1 << 8)) {
-        pLength = 1;
-    } else if (p < (1 << 16)) {
-        pLength = 2;
-    } else if (p < (1 << 24)) {
-        pLength = 3;
-    } else {
-        pLength = 4;
-    }
-
-    uchar beP[4];
-    qToBigEndian(p, beP);
-
-    return QByteArray((const char *)beP, pLength);
-}
-
-qint64 Utils::findDivider(qint64 pq) {
-    qint32 it = 0;
-    quint64 g = 0;
-    for (int i = 0; i < 3 || it < 1000; i++) {
-        qint32 q = ((lrand48() & 15) + 17) % pq;
-        quint64 x = (qint64)lrand48 () % (pq - 1) + 1, y = x;
-        qint32 lim = 1 << (i + 18);
-        qint32 j;
-        for (j = 1; j < lim; j++) {
-            ++it;
-            quint64 a = x, b = x, c = q;
-            while (b) {
-                if (b & 1) {
-                    c += a;
-                    if (c >= pq) {
-                        c -= pq;
-                    }
-                }
-                a += a;
-                if (a >= pq) {
-                    a -= pq;
-                }
-                b >>= 1;
-            }
-            x = c;
-            quint64 z = x < y ? pq + x - y : x - y;
-            g = Utils::gcd(z, pq);
-            if (g != 1) {
-                break;
-            }
-            if (!(j & (j - 1))) {
-                y = x;
-            }
-        }
-        if (g > 1 && g < pq) break;
-    }
-    qCDebug(TG_UTILS) << "got" << g << "divider after" << it << "iterations";
-    return g;
-}

=== removed file 'lib/core/utils.h'
--- lib/core/utils.h	2014-12-22 22:01:28 +0000
+++ lib/core/utils.h	1970-01-01 00:00:00 +0000
@@ -1,88 +0,0 @@
-/*
- * Copyright 2013 Vitaly Valtman
- * Copyright 2014 Canonical Ltd.
- * Authors:
- *      Roberto Mier
- *      Tiago Herrmann
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef UTILS_H
-#define UTILS_H
-
-#ifdef DEBUG
-#define RES_PRE 8
-#define RES_AFTER 8
-#define MAX_BLOCKS 1000000
-void *blocks[MAX_BLOCKS];
-void *free_blocks[MAX_BLOCKS];
-qint32 usedBlocks;
-qint32 freeBlocksCnt;
-#endif
-
-#include <QObject>
-#include <openssl/bn.h>
-#include "constants.h"
-#include <QLoggingCategory>
-
-Q_DECLARE_LOGGING_CATEGORY(TG_UTILS)
-
-
-class Utils : public QObject
-{
-    Q_OBJECT
-public:
-    explicit Utils(QObject *parent = 0);
-
-    static qint32 randomBytes(void *buffer, qint32 count);
-    static qint32 serializeBignum(BIGNUM *b, char *buffer, qint32 maxlen);
-    static double getUTime(qint32 clockId);
-    static quint64 gcd (quint64 a, quint64 b);
-
-    static RSA *rsaLoadPublicKey (const QString &publicKeyName);
-    static qint64 computeRSAFingerprint(RSA *key);
-
-    static qint32 check_g (uchar p[256], BIGNUM *g);
-    static qint32 check_g_bn (BIGNUM *p, BIGNUM *g);
-
-    static void ensure(qint32 r);
-    static void ensurePtr(void *p);
-    static void freeSecure (void *ptr, qint32 size);
-
-    static void *talloc(size_t size);
-    static qint32 tinflate (void *input, qint32 ilen, void *output, qint32 olen);
-
-    static QString toHex(qint32 x);
-    static QString toHex(void *buffer, qint32 size);
-
-    static BIGNUM *padBytesAndGetBignum(const QByteArray &bytes);
-    static BIGNUM *bytesToBignum(const QByteArray &bytes);
-    static QByteArray bignumToBytes(BIGNUM *bignum);
-    static qint64 getKeyFingerprint(uchar *sharedKey);
-
-    static QString getDeviceModel();
-    static QString getSystemVersion();
-    static QString getAppVersion();
-
-    static qint64 getMediaDuration(const QString &resource, const QString &type);
-    static QString createThumbnail(const QString &resource);
-
-    static QString parsePhoneNumberDigits(const QString &phoneNumber);
-
-    static QByteArray pToBigEndian(quint32 p);
-    static qint64 findDivider(qint64 pq);
-};
-
-#endif // UTILS_H

=== added directory 'lib/file'
=== added file 'lib/file/CMakeLists.txt'
--- lib/file/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ lib/file/CMakeLists.txt	2015-02-24 14:12:31 +0000
@@ -0,0 +1,11 @@
+set(FILE_HEADERS
+    file.h
+    downloadfile.h
+    filehandler.h
+    fileoperation.h
+    uploadfile.h)
+
+if(NOT CLICK_MODE)
+INSTALL(FILES ${FILE_HEADERS}
+    DESTINATION ${CMAKE_INSTALL_PREFIX}/include/libqtelegram/file)
+endif(NOT CLICK_MODE)    

=== added file 'lib/file/downloadfile.cpp'
--- lib/file/downloadfile.cpp	1970-01-01 00:00:00 +0000
+++ lib/file/downloadfile.cpp	2015-02-24 14:12:31 +0000
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Roberto Mier
+ *      Tiago Herrmann
+ */
+
+#include "downloadfile.h"
+
+DownloadFile::DownloadFile(Session *session, InputFileLocation fileLocation, qint32 expectedSize, QObject *parent) :
+    File(session, 0, parent),
+    mFileLocation(fileLocation),
+    mOffset(0),
+    mMtime(0),
+    mExpectedSize(expectedSize),
+    mPartId(0) {
+}
+
+DownloadFile::~DownloadFile() {
+}
+
+QByteArray DownloadFile::bytes() const {
+    return mBytes;
+}
+
+void DownloadFile::appendBytes(const QByteArray &bytes) {
+    mBytes.append(bytes);
+    mOffset += bytes.length();
+}
+
+qint32 DownloadFile::offset() const {
+    return mOffset;
+}
+
+void DownloadFile::setOffset(qint32 offset) {
+    mOffset = offset;
+}
+
+qint32 DownloadFile::mtime() const  {
+    return mMtime;
+}
+void DownloadFile::setMtime(qint32 mtime) {
+    mMtime = mtime;
+}
+
+InputFileLocation DownloadFile::fileLocation() const {
+    return mFileLocation;
+}
+
+qint32 DownloadFile::expectedSize() const {
+    return mExpectedSize;
+}
+
+qint32 DownloadFile::partId() const {
+    return mPartId;
+}
+
+void DownloadFile::incrementPartId() {
+    mPartId++;
+}
+
+bool DownloadFile::encrypted() const {
+    return mEncrypted;
+}
+
+uchar *DownloadFile::key() {
+    return mKey;
+}
+
+uchar *DownloadFile::iv() {
+    return mIv;
+}

=== added file 'lib/file/downloadfile.h'
--- lib/file/downloadfile.h	1970-01-01 00:00:00 +0000
+++ lib/file/downloadfile.h	2015-02-24 14:12:31 +0000
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Roberto Mier
+ *      Tiago Herrmann
+ */
+
+#ifndef DOWNLOADFILE_H
+#define DOWNLOADFILE_H
+
+#include <QString>
+#include <QByteArray>
+#include <QSharedPointer>
+#include "util/constants.h"
+#include "types/inputfilelocation.h"
+#include "file.h"
+#include "core/session.h"
+
+class DownloadFile : public File
+{
+    Q_OBJECT
+public:
+
+    typedef QSharedPointer<DownloadFile> Ptr;
+
+    DownloadFile(Session *session, InputFileLocation fileLocation, qint32 expectedSize, QObject *parent = 0);
+    ~DownloadFile();
+
+    void appendBytes(const QByteArray &bytes);
+    QByteArray bytes() const;
+    qint32 offset() const;
+    void setOffset(qint32 offset);
+    void setMtime(qint32 mtime);
+    qint32 mtime() const;
+    InputFileLocation fileLocation() const;
+    qint32 expectedSize() const ;
+    qint32 partId() const;
+    void incrementPartId();
+    bool encrypted() const;
+    uchar *key();
+    uchar *iv();
+
+private:
+    InputFileLocation mFileLocation;
+    QString mName;
+    QByteArray mBytes;
+    qint32 mOffset;
+    qint32 mMtime;
+    qint32 mExpectedSize;
+    qint32 mPartId;
+};
+
+#endif // DOWNLOADFILE_H

=== added file 'lib/file/file.h'
--- lib/file/file.h	1970-01-01 00:00:00 +0000
+++ lib/file/file.h	2015-02-24 14:12:31 +0000
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Roberto Mier
+ *      Tiago Herrmann
+ */
+
+#ifndef FILE_H
+#define FILE_H
+
+#include <QObject>
+#include <QLoggingCategory>
+#include "util/constants.h"
+#include "util/utils.h"
+#include "core/session.h"
+
+Q_DECLARE_LOGGING_CATEGORY(TG_FILE_FILEHANDLER)
+
+class File : public QObject
+{
+    Q_OBJECT
+public:
+    explicit File(Session *session, qint64 length, QObject *parent = 0) :
+        QObject(parent),
+        mSession(session),
+        mLength(length),
+        mPartLength(BLOCK),
+        mEncrypted(false) {
+
+        // generate random file id
+        Utils::randomBytes(&mId, 8);
+
+        // calculate part length
+        qint32 tmp = ((mLength + 2999) / 3000);
+        while (mPartLength < tmp) {
+            mPartLength *= 2;
+        }
+        if (mPartLength > (512 << 10)) {
+            qCCritical(TG_FILE_FILEHANDLER) << "Too big file. Max supported part size is" << ((512 << 10) + 1000);
+            return;
+        }
+    }
+    virtual ~File() {
+        if (mSession) {
+            mSession->release();
+        }
+    }
+
+    void setSession(Session *session) { mSession = session; }
+    Session *session() { return mSession; }
+    qint64 id() const { return mId; }
+    qint64 length() const { return mLength; }
+    qint64 partLength() const { return mPartLength; }
+
+    void setEncrypted(bool encrypted) { mEncrypted = encrypted; }
+    void setKey(const QByteArray &key) { memcpy(mKey, key.data(), 32); }
+    void setIv(const QByteArray &iv) { memcpy(mIv, iv.data(), 32); }
+
+protected:
+    Session *mSession;
+    qint64 mId;
+    qint64 mLength;
+    qint64 mPartLength;
+
+    bool mEncrypted; // if true, this file upload belongs to a secret chat
+    //key and initialization vector for encrypted files
+    uchar mKey[32]; // 32 bytes
+    uchar mIv[32];  // 32 bytes
+};
+
+#endif // FILE_H

=== added file 'lib/file/filehandler.cpp'
--- lib/file/filehandler.cpp	1970-01-01 00:00:00 +0000
+++ lib/file/filehandler.cpp	2015-02-24 14:12:31 +0000
@@ -0,0 +1,422 @@
+#include "filehandler.h"
+#include "secret/secretchat.h"
+#include "secret/encrypter.h"
+
+Q_LOGGING_CATEGORY(TG_FILE_FILEHANDLER, "tg.file.filehandler")
+
+FileHandler::FileHandler(Api *api, DcProvider &dcProvider, SecretState &secretState, QObject *parent) :
+    QObject(parent),
+    mApi(api),
+    mDcProvider(dcProvider),
+    mSecretState(secretState) {
+
+    connect(mApi, SIGNAL(uploadSaveFilePartResult(qint64,qint64,bool)), this, SLOT(onUploadSaveFilePartResult(qint64,qint64,bool)));
+    connect(mApi, SIGNAL(uploadSaveBigFilePartResult(qint64,qint64,bool)), this, SLOT(onUploadSaveFilePartResult(qint64,qint64,bool)));
+    connect(mApi, SIGNAL(uploadFile(qint64,StorageFileType,qint32,QByteArray)), this, SLOT(onUploadGetFileAnswer(qint64,StorageFileType,qint32,QByteArray)));
+    connect(mApi, SIGNAL(uploadFileError(qint64,qint32,QString)), this, SLOT(onUploadGetFileError(qint64,qint32,QString)));
+    connect(mApi, SIGNAL(messagesSentMediaStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)), SLOT(onMessagesSendMediaStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesSentMediaStatedMessageLink(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)), SLOT(onMessagesSendMediaStatedMessageLink(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesSendEncryptedFileSentEncryptedMessage(qint64,qint32)), this, SLOT(onMessagesSentEncryptedFile(qint64,qint32)));
+    connect(mApi, SIGNAL(messagesSendEncryptedFileSentEncryptedFile(qint64,qint32,EncryptedFile)), this, SLOT(onMessagesSentEncryptedFile(qint64,qint32,EncryptedFile)));
+}
+
+FileHandler::~FileHandler() {
+    Q_FOREACH (UploadFile::Ptr f, mUploadsMap.values()) {
+        f.clear();
+    }
+    Q_FOREACH (FileOperation::Ptr op, mFileOperationsMap.values()) {
+        op.clear();
+    }
+    Q_FOREACH (DownloadFile::Ptr f, mDownloadsMap.values()) {
+        f.clear();
+    }
+}
+
+qint64 FileHandler::uploadSendFile(FileOperation &op, const QString &fileName, const QByteArray &bytes, const QByteArray &thumbnailBytes, const QString &thumbnailName) {
+    // create dedicated session to working dc for the main file
+    DC *dc = mDcProvider.getWorkingDc();
+    Session *session = mApi->fileSession(dc);
+    UploadFile::Ptr f = UploadFile::Ptr(new UploadFile(session, UploadFile::Main, bytes, this));
+    bool encrypted = op.opType() == FileOperation::sendEncryptedFile;
+    if (encrypted) {
+        f->setEncrypted(true);
+        f->setKey(op.key());
+        f->setIv(op.iv());
+    }
+    f->setName(fileName);
+    mUploadsMap.insert(f->id(), f);
+    mFileOperationsMap.insert(f->id(), FileOperation::Ptr(&op));
+    UploadFile::Ptr firstFileToUpload = f;
+    // if exists thumbnail, create its file object and assign id to main file thumbnail_id (and viceversa)
+    // first send all thumbnail before sending main file
+    if (!thumbnailBytes.isEmpty()) {
+        // use same session for thumbnail and main file. In case a thumbnail exists, send it first
+        UploadFile::Ptr thumb = UploadFile::Ptr(new UploadFile(session, UploadFile::Thumbnail, thumbnailBytes, this));
+        f->setRelatedFileId(thumb->id());
+        thumb->setRelatedFileId(f->id());
+        thumbnailName.length() > 0 ? thumb->setName(thumbnailName) : thumb->setName(fileName);
+        // insert the relationship fileId <-> thumb file
+        mUploadsMap.insert(thumb->id(), thumb);
+        firstFileToUpload = thumb;
+    }
+
+    if (session->state() == QAbstractSocket::ConnectedState) {
+        uploadSendFileParts(*firstFileToUpload);
+    } else {
+        mInitialUploadsMap[session->sessionId()] << firstFileToUpload;
+        connect(session, SIGNAL(sessionReady(DC*)), this, SLOT(onUploadSendFileSessionCreated()));
+        session->connectToServer();
+    }
+
+    return f->id();
+}
+
+qint64 FileHandler::uploadSendFile(FileOperation &op, const QString &filePath, const QString &thumbnailPath) {
+    // create dedicated session to working dc for the main file
+    DC *dc = mDcProvider.getWorkingDc();
+    Session *session = mApi->fileSession(dc);
+    UploadFile::Ptr f = UploadFile::Ptr(new UploadFile(session, UploadFile::Main, filePath, this));
+    bool encrypted = op.opType() == FileOperation::sendEncryptedFile;
+    if (encrypted) {
+        f->setEncrypted(true);
+        f->setKey(op.key());
+        f->setIv(op.iv());
+    }
+    mUploadsMap.insert(f->id(), f);
+    mFileOperationsMap.insert(f->id(), FileOperation::Ptr(&op));
+    UploadFile::Ptr firstFileToUpload = f;
+    // if exists thumbnail, create its file object and assign id to main file thumbnail_id (and viceversa)
+    // first send all thumbnail before sending main file
+    if (thumbnailPath.length() > 0) {
+        // use same session for thumbnail and main file. In case a thumbnail exists, send it first
+        UploadFile::Ptr thumb = UploadFile::Ptr(new UploadFile(session, UploadFile::Thumbnail, thumbnailPath, this));
+        f->setRelatedFileId(thumb->id());
+        thumb->setRelatedFileId(f->id());
+        // insert the relationship fileId <-> thumb file
+        mUploadsMap.insert(thumb->id(), thumb);
+        firstFileToUpload = thumb;
+    }
+
+    if (session->state() == QAbstractSocket::ConnectedState) {
+        uploadSendFileParts(*firstFileToUpload);
+    } else {
+        mInitialUploadsMap[session->sessionId()] << firstFileToUpload;
+        connect(session, SIGNAL(sessionReady(DC*)), this, SLOT(onUploadSendFileSessionCreated()));
+        session->connectToServer();
+    }
+
+    return f->id();
+}
+
+void FileHandler::onUploadSendFileSessionCreated() {
+    Session *session = qobject_cast<Session*>(sender());
+    QList<UploadFile::Ptr> sessionInitialFiles = mInitialUploadsMap.take(session->sessionId());
+    Q_FOREACH (UploadFile::Ptr f, sessionInitialFiles) {
+        uploadSendFileParts(*f);
+    }
+}
+
+qint64 FileHandler::uploadSendFileParts(UploadFile &file) {
+    // depending on size use one or other api method to upload every part
+    qint32 partId = 0;
+
+    while (file.hasMoreParts()) {
+        QByteArray bytes = file.nextPart();
+        if (file.length() > 10 * 1024 * 1024) {
+            mApi->uploadSaveBigFilePart(file.session(), file.id(), partId++, file.nParts(), bytes);
+        } else {
+            mApi->uploadSaveFilePart(file.session(), file.id(), partId++, bytes);
+        }
+    }
+    // return file id instead of every part msg id
+    return file.id();
+}
+
+void FileHandler::onUploadSaveFilePartResult(qint64, qint64 fileId, bool) {
+    UploadFile::Ptr uploadFile = mUploadsMap.value(fileId);
+    Q_ASSERT(!uploadFile.isNull());
+    uploadFile->increaseUploadedParts();
+    qCDebug(TG_FILE_FILEHANDLER) << "uploaded" << uploadFile->uploadedParts() << "parts out of" << uploadFile->nParts();
+
+    // emit signal with upload progress
+    qint32 length = uploadFile->length();
+    qint32 uploaded = uploadFile->uploadedParts() * uploadFile->partLength();
+    uploaded = uploaded > length ? length : uploaded;
+    qint32 partId = uploadFile->uploadedParts() - 1;
+    Q_EMIT uploadSendFileAnswer(fileId, partId, uploaded, length);
+
+    if (uploadFile->uploadedParts() == uploadFile->nParts()) {
+        // if finished a thumbnail, send the main file. Send media metadata if finished is the main file
+        qCDebug(TG_FILE_FILEHANDLER) << "file upload finished for fileId" << fileId;
+        if (uploadFile->fileType() == UploadFile::Thumbnail) {
+            qint64 mainFileId = uploadFile->relatedFileId();
+            UploadFile::Ptr main = mUploadsMap.value(mainFileId);
+            Q_ASSERT(!main.isNull());
+            uploadSendFileParts(*main);
+        } else {
+            // compose InputFile to be added to metadata
+            InputFile inputFile(InputFile::typeInputFile);
+            if (uploadFile->length() > 10 * 1024 * 1024) {
+                inputFile.setClassType(InputFile::typeInputFileBig);
+            } else {
+                inputFile.setMd5Checksum(QString(uploadFile->md5().toHex()));
+            }
+            inputFile.setId(fileId);
+            inputFile.setParts(uploadFile->nParts());
+            inputFile.setName(uploadFile->name());
+
+            qint64 requestId;
+            // Read operation and execute internal api operation depending on file operation type
+            FileOperation::Ptr op = mFileOperationsMap.take(uploadFile->id());
+            switch (op->opType()) {
+                case FileOperation::sendMedia: {
+                    InputMedia metadata = op->inputMedia();
+                    metadata.setFile(inputFile);
+                    // once filled input main file, check if there is a thumbnail and fill its data
+                    if (uploadFile->relatedFileId()) {
+                        UploadFile::Ptr thumb = mUploadsMap.take(uploadFile->relatedFileId());
+                        InputFile inputThumb(InputFile::typeInputFile);
+                        if (thumb->length() > 10 * 1024 * 1024) {
+                            inputThumb.setClassType(InputFile::typeInputFileBig);
+                        } else {
+                            inputThumb.setMd5Checksum(QString(thumb->md5().toHex()));
+                        }
+                        inputThumb.setId(thumb->id());
+                        inputThumb.setParts(thumb->nParts());
+                        inputThumb.setName(thumb->name());
+                        metadata.setThumb(inputThumb);
+                        thumb.clear();
+                    }
+                    // retrieve peer related to file, generate random id and send media metadata
+                    InputPeer peer = op->peer();
+                    qint64 randomId = op->randomId();
+                    requestId = mApi->messagesSendMedia(peer, metadata, randomId);
+                    break;
+                }
+                case FileOperation::editChatPhoto: {
+                    InputChatPhoto metadata = op->inputChatPhoto();
+                    metadata.setFile(inputFile);
+                    qint32 chatId = op->chatId();
+                    requestId = mApi->messagesEditChatPhoto(chatId, metadata);
+                    break;
+                }
+                case FileOperation::uploadProfilePhoto: {
+                    QString caption = op->caption();
+                    InputGeoPoint geoPoint = op->geoPoint();
+                    InputPhotoCrop crop = op->crop();
+                    requestId = mApi->photosUploadProfilePhoto(inputFile, caption, geoPoint, crop);
+                    break;
+                }
+                case FileOperation::sendEncryptedFile: {
+                    InputEncryptedChat inputEncryptedChat = op->inputEncryptedChat();
+                    qint64 randomId = op->randomId();
+                    DecryptedMessage decryptedMessage = op->decryptedMessage();
+
+                    InputEncryptedFile inputEncryptedFile(InputEncryptedFile::typeInputEncryptedFileUploaded);
+                    inputEncryptedFile.setId(fileId);
+                    inputEncryptedFile.setParts(uploadFile->nParts());
+                    inputEncryptedFile.setMd5Checksum(QString(uploadFile->md5().toHex()));
+
+                    qint32 keyFingerprint = CryptoUtils::getInstance()->computeKeyFingerprint(op->key(), op->iv());
+                    inputEncryptedFile.setKeyFingerprint(keyFingerprint);
+
+                    SecretChat *secretChat = mSecretState.chats().value(inputEncryptedChat.chatId());
+                    QList<qint64> previousMsgs = secretChat->sequence();
+                    Encrypter encrypter;
+                    encrypter.setSecretChat(secretChat);
+                    QByteArray data = encrypter.generateEncryptedData(decryptedMessage);
+                    requestId = mApi->messagesSendEncryptedFile(previousMsgs, inputEncryptedChat, randomId, data, inputEncryptedFile);
+
+                    secretChat->increaseOutSeqNo();
+                    secretChat->appendToSequence(randomId);
+                    mSecretState.save();
+                    break;
+                }
+            }
+            //correlate response of sendmedia with file id (that will be the id value to correlate the initial request)
+            mFileIdsMap.insert(requestId, uploadFile->id());
+            // delete main file from map after sending
+            mUploadsMap.remove(fileId);
+            // delete operation and main file pointers
+            uploadFile.clear();
+            op.clear();
+        }
+    }
+}
+
+qint64 FileHandler::uploadGetFile(const InputFileLocation &location, qint32 fileSize, qint32 dcNum, const QByteArray &key, const QByteArray &iv) {
+    // change of dc if received a dcNum
+    DC *dc;
+    dcNum ? dc = mDcProvider.getDc(dcNum) : dc = mDcProvider.getWorkingDc();
+    Session *session = mApi->fileSession(dc);
+    DownloadFile::Ptr f = DownloadFile::Ptr(new DownloadFile(session, location, fileSize, this));
+    if (location.classType() == InputFileLocation::typeInputEncryptedFileLocation) {
+        f->setEncrypted(true);
+        f->setKey(key);
+        f->setIv(iv);
+    }
+    mActiveDownloadsMap.insert(f->id(), true);
+
+    switch (session->state()) {
+    case QAbstractSocket::ConnectingState: {
+        mInitialDownloadsMap[session->sessionId()] << f;
+        break;
+    }
+    case QAbstractSocket::ConnectedState: {
+        qint64 msgId = mApi->uploadGetFile(session, f->fileLocation());
+        mDownloadsMap.insert(msgId, f);
+        break;
+    }
+    default: {
+        QList<DownloadFile::Ptr> sessionInitialFiles;
+        sessionInitialFiles << f;
+        mInitialDownloadsMap.insert(session->sessionId(), sessionInitialFiles);
+        connect(session, SIGNAL(sessionReady(DC*)), this, SLOT(onUploadGetFileSessionCreated()));
+        session->connectToServer();
+        break;
+    }
+    }
+
+    // return file id as request id for apps
+    return f->id();
+}
+
+void FileHandler::onUploadGetFileSessionCreated() {
+    Session *session = qobject_cast<Session *>(sender());
+    QList<DownloadFile::Ptr> sessionInitialFiles = mInitialDownloadsMap.take(session->sessionId());
+    Q_FOREACH (DownloadFile::Ptr f, sessionInitialFiles) {
+        qint64 msgId = mApi->uploadGetFile(session, f->fileLocation());
+        mDownloadsMap.insert(msgId, f);
+    }
+}
+
+void FileHandler::onUploadGetFileAnswer(qint64 msgId, StorageFileType type, qint32 mtime, QByteArray bytes) {
+    DownloadFile::Ptr f = mDownloadsMap.take(msgId);
+    Q_ASSERT(!f.isNull());
+
+    if (mCancelDownloadsMap.take(f->id())) {
+        Q_EMIT uploadCancelFileAnswer(f->id(), true);
+        mActiveDownloadsMap.remove(f->id());
+        f.clear();
+        return;
+    }
+
+    if (f->encrypted()) {
+        CryptoUtils::getInstance()->decryptFilePart(bytes, f->key(), f->iv());
+        // if decrypted bytes are more than the last part expected ones, remove surplus
+        qint32 expectedMaxPartSize = f->expectedSize() - f->offset();
+        if (bytes.length() > expectedMaxPartSize) {
+            bytes.truncate(expectedMaxPartSize);
+        }
+    }
+
+    // if 'managedDownloads' flag is set, store all temporal received data and return a unique event
+    // when file downloading is finished. Emit an event for every part otherwise.
+    if (Settings::getInstance()->managedDownloads()) {
+        // partial bytes appended to DownloadFile object
+        f->appendBytes(bytes);
+
+        qint32 expectedSize = f->expectedSize();
+        if (expectedSize == 0 && (bytes.length() < BLOCK || bytes.length() == 0)) {
+            expectedSize = f->offset();
+        }
+
+        if (expectedSize == 0 || f->bytes().length() < expectedSize) {
+            qint64 newMsgId = mApi->uploadGetFile(f->session(), f->fileLocation(), f->offset(), f->partLength());
+            mDownloadsMap.insert(newMsgId, f);
+        } else {
+            Q_EMIT uploadGetFileAnswer(f->id(), type, mtime, f->bytes(), 0, f->length(), expectedSize); //emit signal of finished
+            mActiveDownloadsMap.remove(f->id());
+            f.clear();
+        }
+    } else {
+        qint32 downloaded = f->partId() * f->partLength() + bytes.length();
+        qint32 thisPartId = f->partId();
+        qint32 expectedSize = f->expectedSize();
+
+        f->incrementPartId();
+        f->setOffset(f->offset() + bytes.length());
+
+        if (expectedSize == 0 && (bytes.length() < BLOCK || bytes.length() == 0)) {
+            expectedSize = f->offset();
+        }
+
+        Q_EMIT uploadGetFileAnswer(f->id(), type, mtime, bytes, thisPartId, downloaded, expectedSize);
+
+        if (expectedSize == 0 || f->offset() < expectedSize) {
+            qint64 newMsgId = mApi->uploadGetFile(f->session(), f->fileLocation(), f->offset(), f->partLength());
+            mDownloadsMap.insert(newMsgId, f);
+        } else {
+            mActiveDownloadsMap.remove(f->id());
+            f.clear();
+        }
+    }
+}
+
+void FileHandler::onUploadGetFileError(qint64 id, qint32 errorCode, const QString &errorText) {
+    // check for error and resend authCheckPhone() request
+    if (errorText.contains("_MIGRATE_")) {
+        qint32 newDc = errorText.mid(errorText.lastIndexOf("_") + 1).toInt();
+        qCDebug(TG_FILE_FILEHANDLER) << "file migrated to dc" << newDc;
+        DC *dc = mDcProvider.getDc(newDc);
+        DownloadFile::Ptr f = mDownloadsMap.take(id);
+        // release previous session
+        f->session()->release();
+        // get session against new dc
+        Session *newDcSession = mApi->fileSession(dc);
+        f->setSession(newDcSession);
+
+        switch (newDcSession->state()) {
+        case QAbstractSocket::ConnectingState: {
+            mInitialDownloadsMap[newDcSession->sessionId()] << f;
+            break;
+        }
+        case QAbstractSocket::ConnectedState: {
+            qint64 msgId = mApi->uploadGetFile(newDcSession, f->fileLocation());
+            mDownloadsMap.insert(msgId, f);
+            break;
+        }
+        default: {
+            QList<DownloadFile::Ptr> sessionInitialFiles;
+            sessionInitialFiles << f;
+            mInitialDownloadsMap.insert(newDcSession->sessionId(), sessionInitialFiles);
+            connect(newDcSession, SIGNAL(sessionReady(DC*)), this, SLOT(onUploadGetFileSessionCreated()));
+            newDcSession->connectToServer();
+            break;
+        }
+        }
+
+    } else {
+        Q_EMIT error(id, errorCode, errorText);
+    }
+}
+
+qint64 FileHandler::uploadCancelFile(qint64 fileId) {
+    if (!mActiveDownloadsMap.value(fileId)) {
+        // return signal of cancelled file, setting the 'cancelled' flag to false, only if the file is not into active
+        // downloads. Otherwise, the signal will be emitted when received next part of the file
+        Q_EMIT uploadCancelFileAnswer(fileId, false);
+    } else {
+        mCancelDownloadsMap.insert(fileId, true);
+    }
+    return fileId;
+}
+
+void FileHandler::onMessagesSendMediaStatedMessage(qint64 id, Message message, QList<Chat> chats, QList<User> users, qint32 pts, qint32 seq) {
+    QList<ContactsLink> links;
+    onMessagesSendMediaStatedMessageLink(id, message, chats, users, links, pts, seq);
+}
+
+void FileHandler::onMessagesSendMediaStatedMessageLink(qint64 id, Message message, QList<Chat> chats, QList<User> users, QList<ContactsLink> links, qint32 pts, qint32 seq) {
+    //recover correlated send media request id -> fileId
+    qint64 fileId = mFileIdsMap.take(id);
+    Q_ASSERT(fileId);
+    Q_EMIT messagesSendMediaAnswer(fileId, message, chats, users, links, pts, seq);
+}
+
+void FileHandler::onMessagesSentEncryptedFile(qint64 id, qint32 date, const EncryptedFile &encryptedFile) {
+    //recover correlated send media request id -> fileId
+    qint64 fileId = mFileIdsMap.take(id);
+    Q_ASSERT(fileId);
+    Q_EMIT messagesSendEncryptedFileAnswer(fileId, date, encryptedFile);
+}

=== added file 'lib/file/filehandler.h'
--- lib/file/filehandler.h	1970-01-01 00:00:00 +0000
+++ lib/file/filehandler.h	2015-02-24 14:12:31 +0000
@@ -0,0 +1,79 @@
+#ifndef FILEHANDLER_H
+#define FILEHANDLER_H
+
+#include <QObject>
+#include <QSharedPointer>
+#include "uploadfile.h"
+#include "fileoperation.h"
+#include "downloadfile.h"
+#include "core/dcprovider.h"
+#include "core/api.h"
+#include "secret/secretstate.h"
+
+Q_DECLARE_LOGGING_CATEGORY(TG_FILE_FILEHANDLER)
+
+class FileHandler : public QObject
+{
+    Q_OBJECT
+public:
+    typedef QSharedPointer<FileHandler> Ptr;
+
+    explicit FileHandler(Api* api, DcProvider &dcProvider, SecretState &secretState, QObject *parent = 0);
+    ~FileHandler();
+
+    qint64 uploadSendFile(FileOperation &op, const QString &fileName, const QByteArray &bytes, const QByteArray &thumbnailBytes = 0, const QString &thumbnailName = "");
+    qint64 uploadSendFile(FileOperation &op, const QString &filePath, const QString &thumbnailPath = "");
+    qint64 uploadGetFile(const InputFileLocation &file, qint32 fileSize, qint32 dc = 0, const QByteArray &key = QByteArray(), const QByteArray &iv = QByteArray());
+    qint64 uploadCancelFile(qint64 fileId);
+
+Q_SIGNALS:
+    void uploadSendFileAnswer(qint64 fileId, qint32 partId, qint32 uploaded, qint32 totalSize);
+    void uploadGetFileAnswer(qint64 fileId, StorageFileType type, qint32 mtime, QByteArray bytes, qint32 partId, qint32 downloaded, qint32 total);
+    void uploadCancelFileAnswer(qint64 fileId, bool cancelled);
+    void error(qint64 id, qint32 errorCode, QString errorText);
+
+    void messagesSendMediaAnswer(qint64 fileId, Message message, QList<Chat> chats, QList<User> users, QList<ContactsLink> links, qint32 pts, qint32 seq);
+    void messagesSendEncryptedFileAnswer(qint64 id, qint32 date, EncryptedFile encryptedFile = EncryptedFile());
+
+private:
+    Api *mApi;
+    DcProvider &mDcProvider;
+    SecretState &mSecretState;
+
+    /* File Sending */
+    // fileId -> physical file details (length, bytes, parts, every part details, etc..)
+    QMap<qint64, UploadFile::Ptr> mUploadsMap;
+    // mainFileId -> operation additional data to be done with the file (peer, operation type)
+    QMap<qint64, FileOperation::Ptr> mFileOperationsMap;
+    // sessionId -> list of files waiting for session connection to be ready for being uploaded
+    QMap<qint64, QList<UploadFile::Ptr> > mInitialUploadsMap;
+    // finally, when sending media by using telegram api messagesSendMedia, we need to correlate
+    // requestId -> fileId, cos fileId is what we returned in request and the identifier we need
+    // to answer in final response
+    QMap<qint64, qint64> mFileIdsMap;
+
+    qint64 uploadSendFileParts(UploadFile &file);
+
+    /* File receiving */
+    // requestId -> physical downloading file details (DownloadFile structure includes fileId)
+    QMap<qint64, DownloadFile::Ptr> mDownloadsMap;
+    // sessionId -> list of files waiting for session connection to be ready for being downloaded
+    QMap<qint64, QList<DownloadFile::Ptr> > mInitialDownloadsMap;
+    // fileId -> true if the file download is in progress. An entry does not exists for that fileId if not downloading
+    QMap<qint64, bool> mActiveDownloadsMap;
+    // fileId -> true if requested a download cancel for that fileId
+    QMap<qint64, bool> mCancelDownloadsMap;
+
+private Q_SLOTS:
+    void onUploadSendFileSessionCreated();
+    void onUploadSaveFilePartResult(qint64 msgId, qint64 fileId, bool ok);
+    void onUploadGetFileSessionCreated();
+    void onUploadGetFileAnswer(qint64 msgId, StorageFileType type, qint32 mtime, QByteArray bytes);
+    void onUploadGetFileError(qint64 id, qint32 errorCode, const QString &errorText);
+
+    void onMessagesSendMediaStatedMessage(qint64 id, Message message, QList<Chat> chats, QList<User> users, qint32 pts, qint32 seq);
+    void onMessagesSendMediaStatedMessageLink(qint64 id, Message message, QList<Chat> chats, QList<User> users, QList<ContactsLink> links, qint32 pts, qint32 seq);
+    void onMessagesSentEncryptedFile(qint64, qint32 date, const EncryptedFile &encryptedFile = EncryptedFile());
+};
+
+#endif // FILEHANDLER_H

=== added file 'lib/file/fileoperation.h'
--- lib/file/fileoperation.h	1970-01-01 00:00:00 +0000
+++ lib/file/fileoperation.h	2015-02-24 14:12:31 +0000
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Roberto Mier
+ *      Tiago Herrmann
+ */
+
+#ifndef FILEOPERATION_H
+#define FILEOPERATION_H
+
+#include "uploadfile.h"
+#include "types/inputpeer.h"
+#include "types/inputmedia.h"
+#include "types/inputchatphoto.h"
+#include <QSharedPointer>
+
+class FileOperation
+{
+public:
+    enum OpType {
+        sendMedia,
+        editChatPhoto,
+        uploadProfilePhoto,
+        sendEncryptedFile
+    };
+
+    typedef QSharedPointer<FileOperation> Ptr;
+
+    FileOperation(OpType opType) :
+        mPeer(InputPeer::typeInputPeerEmpty),
+        mInputMedia(InputMedia::typeInputMediaEmpty),
+        mRandomId(0),
+        mInputChatPhoto(InputChatPhoto::typeInputChatPhotoEmpty),
+        mGeoPoint(InputGeoPoint::typeInputGeoPointEmpty),
+        mCrop(InputPhotoCrop::typeInputPhotoCropAuto),
+        mType(opType) {}
+
+    InputPeer peer() const { return mPeer; }
+    void setInputPeer(const InputPeer &peer) { mPeer = peer; }
+    InputMedia inputMedia() const { return mInputMedia; }
+    void setInputMedia(const InputMedia &inputMedia) { mInputMedia = inputMedia; }
+    qint64 randomId() const { return mRandomId; }
+    void setRandomId(qint64 randomId) { mRandomId = randomId; }
+    qint32 chatId() const { return mChatId; }
+    void setChatId(qint32 chatId) { mChatId = chatId; }
+    InputChatPhoto inputChatPhoto() const { return mInputChatPhoto; }
+    void setInputChatPhoto(InputChatPhoto inputChatPhoto) { mInputChatPhoto = inputChatPhoto; }
+    QString caption() const { return mCaption; }
+    void setCaption(QString caption) { mCaption = caption; }
+    InputGeoPoint geoPoint() const { return mGeoPoint; }
+    void setGeoPoint(InputGeoPoint geoPoint) { mGeoPoint = geoPoint; }
+    InputPhotoCrop crop() const { return mCrop; }
+    void setCrop(InputPhotoCrop crop) { mCrop = crop; }
+    OpType opType() const { return mType; }
+
+
+    void setInputEncryptedChat(const InputEncryptedChat &inputEncryptedChat) { mInputEncryptedChat = inputEncryptedChat; }
+    void setDecryptedMessage(const DecryptedMessage &decryptedMessage) { mDecryptedMessage = decryptedMessage; }
+    InputEncryptedChat inputEncryptedChat() const { return mInputEncryptedChat; }
+    DecryptedMessage decryptedMessage() const { return mDecryptedMessage; }
+    QByteArray key() const { return mKey; }
+    QByteArray iv() const { return mIv; }
+
+    void initializeKeyAndIv() {
+        char keyData[32];
+        Utils::randomBytes(keyData, 32);
+        mKey = QByteArray(keyData, 32);
+        char ivData[32];
+        Utils::randomBytes(ivData, 32);
+        mIv = QByteArray(ivData, 32);
+    }
+
+private:
+    // sendMedia operation attributes
+    InputPeer mPeer;
+    InputMedia mInputMedia;
+    qint64 mRandomId;
+    // editChatPhoto operation attributes
+    qint32 mChatId;
+    InputChatPhoto mInputChatPhoto;
+    // uploadProfilePhoto operation attributes
+    QString mCaption;
+    InputGeoPoint mGeoPoint;
+    InputPhotoCrop mCrop;
+    OpType mType;
+
+    InputEncryptedChat mInputEncryptedChat;
+    DecryptedMessage mDecryptedMessage;
+    //key and initialization vector for encrypted files
+    QByteArray mKey; // 32 bytes
+    QByteArray mIv; // 32 bytes
+};
+
+#endif // FILEOPERATION_H

=== added file 'lib/file/uploadfile.cpp'
--- lib/file/uploadfile.cpp	1970-01-01 00:00:00 +0000
+++ lib/file/uploadfile.cpp	2015-02-24 14:12:31 +0000
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Roberto Mier
+ *      Tiago Herrmann
+ */
+
+#include "uploadfile.h"
+
+#include <QFileInfo>
+
+UploadFile::UploadFile(Session *session, UploadFile::FileType fileType, const QByteArray &buffer, QObject *parent) :
+    File(session, buffer.size(), parent),
+    mFileType(fileType),
+    mRelatedFileId(0),
+    mName(""),
+    mBytes(buffer),
+    mFilePath(""),
+    mNParts(0),
+    mCurrentPart(0),
+    mUploadedParts(0),
+    mKrypt(QCryptographicHash::Md5)
+{
+    calculatePartsCount();
+}
+
+UploadFile::UploadFile(Session *session, UploadFile::FileType fileType, const QString &filePath, QObject *parent) :
+    File(session, QFileInfo(filePath).size(), parent),
+    mFileType(fileType),
+    mRelatedFileId(0),
+    mName(QFileInfo(filePath).fileName()),
+    mFilePath(filePath),
+    mNParts(0),
+    mCurrentPart(0),
+    mUploadedParts(0),
+    mIODevice(filePath),
+    mKrypt(QCryptographicHash::Md5)
+{
+    openIODevice();
+    calculatePartsCount();
+}
+
+UploadFile::~UploadFile() {
+}
+
+void UploadFile::openIODevice() {
+    if (mIODevice.open(QIODevice::ReadOnly)) {
+        // get file size with file open
+        mLength = mIODevice.size();
+    } else {
+        Q_EMIT fileNotFound();
+    }
+}
+
+bool UploadFile::hasMoreParts() const {
+    return mCurrentPart < mNParts;
+}
+
+QByteArray UploadFile::nextPart() {
+    QByteArray partBytes(mPartLength, Qt::Uninitialized);
+
+    //let's see if the file content is loaded or a filepath is set
+    if (!mBytes.isEmpty()) {
+        qint32 k = 0;
+        if (mCurrentPart < mNParts -1) {
+            // if not the last part
+            qint32 n = (mCurrentPart + 1) * mPartLength;
+            for (qint32 j = (mCurrentPart * mPartLength); j < n; j++) {
+                partBytes[k++] = mBytes[j];
+            }
+        } else {
+            // if last part
+            qint32 lastPartSize = mLength % mPartLength;
+            // if not the last part
+            qint32 n = (mCurrentPart * mPartLength) + lastPartSize;
+            for (qint32 j = (mCurrentPart * mPartLength); j < n; j++) {
+                partBytes[k++] = mBytes[j];
+            }
+        }
+    } else {
+        // in this case we're reading an open file from a local path
+        if (mIODevice.isOpen()) {
+            mIODevice.seek(mCurrentPart * mPartLength); //set offset
+            partBytes = mIODevice.read(mPartLength);
+            if (!hasMoreParts()) {
+                mIODevice.close();
+            }
+        } else {
+            Q_EMIT fileNotOpen();
+        }
+    }
+    mCurrentPart++;
+
+    QByteArray processedBytes;
+    if (mEncrypted) {
+        processedBytes = CryptoUtils::getInstance()->encryptFilePart(partBytes, mKey, mIv);
+    } else {
+        processedBytes = partBytes;
+    }
+
+    // add the new data to cryptographic hash before return it
+    mKrypt.addData(processedBytes, processedBytes.length());
+    return processedBytes;
+}
+
+void UploadFile::increaseUploadedParts() {
+    mUploadedParts++;
+}
+
+QByteArray UploadFile::md5() {
+    return mKrypt.result();
+}
+
+void UploadFile::calculatePartsCount() {
+    // calculate number of parts to be uploaded
+    mNParts = mLength / mPartLength;
+    if (mNParts * mPartLength < mLength) mNParts++;
+}

=== added file 'lib/file/uploadfile.h'
--- lib/file/uploadfile.h	1970-01-01 00:00:00 +0000
+++ lib/file/uploadfile.h	2015-02-24 14:12:31 +0000
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Roberto Mier
+ *      Tiago Herrmann
+ */
+
+#ifndef UPLOADFILE_H
+#define UPLOADFILE_H
+
+#include <QObject>
+#include <QSharedPointer>
+#include <QFile>
+#include <QCryptographicHash>
+#include "file.h"
+#include "types/inputmedia.h"
+
+class UploadFile : public File
+{
+    Q_OBJECT
+public:
+
+    enum FileType {
+        Main,
+        Thumbnail
+    };
+
+    typedef QSharedPointer<UploadFile> Ptr;
+
+    explicit UploadFile(Session *session, FileType type, const QByteArray &buffer, QObject *parent = 0);
+    explicit UploadFile(Session *session, FileType type, const QString &filePath, QObject *parent = 0);
+    ~UploadFile();
+
+    qint64 relatedFileId() const { return mRelatedFileId; }
+    void setRelatedFileId(qint64 relatedFileId) { mRelatedFileId = relatedFileId; }
+    QString name() const { return mName; }
+    void setName(const QString &name) { mName = name; }
+    FileType fileType() const { return mFileType; }
+    qint32 nParts() const { return mNParts; }
+    qint32 uploadedParts() const { return mUploadedParts; }
+
+    bool hasMoreParts() const;
+    QByteArray nextPart();
+    void increaseUploadedParts();
+    QByteArray md5();
+
+Q_SIGNALS:
+    void fileNotFound();
+    void fileNotOpen();
+
+private:
+    FileType mFileType;
+    qint64 mRelatedFileId; // if this is the main file, related file is thumbnail and viceversa
+    QString mName;
+    QByteArray mBytes;
+    QString mFilePath;
+    qint32 mNParts;
+    qint32 mCurrentPart;
+    qint32 mUploadedParts;
+    QFile mIODevice;
+    QCryptographicHash mKrypt;
+
+    void openIODevice();
+    void calculatePartsCount();
+};
+
+#endif // UPLOADFILE_H

=== removed directory 'lib/logic'
=== removed file 'lib/logic/CMakeLists.txt'
--- lib/logic/CMakeLists.txt	2014-07-30 23:27:10 +0000
+++ lib/logic/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,10 +0,0 @@
-set(LOGIC_HEADERS
-    fileoperation.h
-    downloadfile.h
-    uploadfile.h
-    file.h)
-
-if(NOT CLICK_MODE)
-INSTALL(FILES ${LOGIC_HEADERS}
-    DESTINATION ${CMAKE_INSTALL_PREFIX}/include/libqtelegram/logic)
-endif(NOT CLICK_MODE)    

=== removed file 'lib/logic/downloadfile.cpp'
--- lib/logic/downloadfile.cpp	2014-11-28 18:46:13 +0000
+++ lib/logic/downloadfile.cpp	1970-01-01 00:00:00 +0000
@@ -1,85 +0,0 @@
-/*
- * Copyright 2014 Canonical Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors:
- *      Roberto Mier
- *      Tiago Herrmann
- */
-
-#include "downloadfile.h"
-
-DownloadFile::DownloadFile(Session *session, InputFileLocation fileLocation, qint32 expectedSize, QObject *parent) :
-    File(session, 0, parent),
-    m_fileLocation(fileLocation),
-    m_offset(0),
-    m_mtime(0),
-    m_expectedSize(expectedSize),
-    m_partId(0) {
-}
-
-DownloadFile::~DownloadFile() {
-}
-
-QByteArray DownloadFile::bytes() const {
-    return m_bytes;
-}
-
-void DownloadFile::appendBytes(const QByteArray &bytes) {
-    m_bytes.append(bytes);
-    m_offset += bytes.length();
-}
-
-qint32 DownloadFile::offset() const {
-    return m_offset;
-}
-
-void DownloadFile::setOffset(qint32 offset) {
-    m_offset = offset;
-}
-
-qint32 DownloadFile::mtime() const  {
-    return m_mtime;
-}
-void DownloadFile::setMtime(qint32 mtime) {
-    m_mtime = mtime;
-}
-
-InputFileLocation DownloadFile::fileLocation() const {
-    return m_fileLocation;
-}
-
-qint32 DownloadFile::expectedSize() const {
-    return m_expectedSize;
-}
-
-qint32 DownloadFile::partId() const {
-    return m_partId;
-}
-
-void DownloadFile::incrementPartId() {
-    m_partId++;
-}
-
-bool DownloadFile::encrypted() const {
-    return mEncrypted;
-}
-
-uchar *DownloadFile::key() {
-    return mKey;
-}
-
-uchar *DownloadFile::iv() {
-    return mIv;
-}

=== removed file 'lib/logic/downloadfile.h'
--- lib/logic/downloadfile.h	2014-11-28 18:46:13 +0000
+++ lib/logic/downloadfile.h	1970-01-01 00:00:00 +0000
@@ -1,63 +0,0 @@
-/*
- * Copyright 2014 Canonical Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors:
- *      Roberto Mier
- *      Tiago Herrmann
- */
-
-#ifndef DOWNLOADFILE_H
-#define DOWNLOADFILE_H
-
-#include <QString>
-#include <QByteArray>
-#include "core/constants.h"
-#include "types/inputfilelocation.h"
-#include "file.h"
-#include "core/session.h"
-
-class DownloadFile : public File
-{
-    Q_OBJECT
-public:
-    DownloadFile(Session *session, InputFileLocation fileLocation, qint32 expectedSize, QObject *parent = 0);
-    ~DownloadFile();
-
-    void appendBytes(const QByteArray &bytes);
-    QByteArray bytes() const;
-    qint32 offset() const;
-    void setOffset(qint32 offset);
-    void setMtime(qint32 mtime);
-    qint32 mtime() const;
-    InputFileLocation fileLocation() const;
-    qint32 expectedSize() const ;
-    qint32 partId() const;
-    void incrementPartId();
-
-    bool encrypted() const;
-    uchar *key();
-    uchar *iv();
-
-private:
-    InputFileLocation m_fileLocation;
-    QString m_name;
-    QByteArray m_bytes;
-    qint32 m_offset;
-    qint32 m_mtime;
-    qint32 m_expectedSize;
-    qint32 m_partId;
-};
-
-#endif // DOWNLOADFILE_H

=== removed file 'lib/logic/file.h'
--- lib/logic/file.h	2015-01-29 11:41:41 +0000
+++ lib/logic/file.h	1970-01-01 00:00:00 +0000
@@ -1,88 +0,0 @@
-/*
- * Copyright 2014 Canonical Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors:
- *      Roberto Mier
- *      Tiago Herrmann
- */
-
-#ifndef FILE_H
-#define FILE_H
-
-#include <QObject>
-#include <QLoggingCategory>
-#include "core/constants.h"
-#include "core/utils.h"
-#include "core/session.h"
-
-Q_DECLARE_LOGGING_CATEGORY(TG_LIB_API)
-
-class File : public QObject
-{
-    Q_OBJECT
-public:
-    explicit File(Session *session, qint64 length, QObject *parent = 0) :
-        QObject(parent),
-        m_session(session),
-        m_length(length),
-        mPartLength(BLOCK),
-        mEncrypted(false) {
-
-        // generate random file id
-        Utils::randomBytes(&m_id, 8);
-
-        // calculate part length
-        // TODO Roberto: commented out this code until solving the problem with percentage when so calculated the length part
-        /*
-        int tmp = ((m_length + 2999) / 3000);
-        mPartLength = (1 << 14);
-        while (mPartLength < tmp) {
-          mPartLength *= 2;
-        }
-        if (mPartLength > (512 << 10)) {
-            qCCritical(TG_LIB_API) << "Too big file. Max supported size is" << ((512 << 10) + 1000);
-            return;
-        }
-        */
-    }
-    ~File() {
-        if (m_session) {
-            m_session->release();
-        }
-    }
-
-    void setSession(Session *session) { m_session = session; }
-    Session *session() { return m_session; }
-    qint64 id() const { return m_id; }
-    qint64 length() const { return m_length; }
-    qint64 partLength() const { return mPartLength; }
-
-    void setEncrypted(bool encrypted) { mEncrypted = encrypted; }
-    void setKey(const QByteArray &key) { memcpy(mKey, key.data(), 32); }
-    void setIv(const QByteArray &iv) { memcpy(mIv, iv.data(), 32); }
-
-protected:
-    Session *m_session;
-    qint64 m_id;
-    qint64 m_length;
-    qint64 mPartLength;
-
-    bool mEncrypted; // if true, this file upload belongs to a secret chat
-    //key and initialization vector for encrypted files
-    uchar mKey[32]; // 32 bytes
-    uchar mIv[32];  // 32 bytes
-};
-
-#endif // FILE_H

=== removed file 'lib/logic/fileoperation.h'
--- lib/logic/fileoperation.h	2015-01-30 08:20:13 +0000
+++ lib/logic/fileoperation.h	1970-01-01 00:00:00 +0000
@@ -1,104 +0,0 @@
-/*
- * Copyright 2014 Canonical Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors:
- *      Roberto Mier
- *      Tiago Herrmann
- */
-
-#ifndef FILEOPERATION_H
-#define FILEOPERATION_H
-
-#include "uploadfile.h"
-#include "types/inputpeer.h"
-#include "types/inputmedia.h"
-#include "types/inputchatphoto.h"
-
-class FileOperation
-{
-public:
-    enum OpType {
-        sendMedia,
-        editChatPhoto,
-        uploadProfilePhoto,
-        sendEncryptedFile
-    };
-
-    FileOperation(OpType opType) :
-        m_peer(InputPeer::typeInputPeerEmpty),
-        m_inputMedia(InputMedia::typeInputMediaEmpty),
-        mRandomId(0),
-        m_inputChatPhoto(InputChatPhoto::typeInputChatPhotoEmpty),
-        m_geoPoint(InputGeoPoint::typeInputGeoPointEmpty),
-        m_crop(InputPhotoCrop::typeInputPhotoCropAuto),
-        m_type(opType) {}
-
-    InputPeer peer() const { return m_peer; }
-    void setInputPeer(const InputPeer &peer) { m_peer = peer; }
-    InputMedia inputMedia() const { return m_inputMedia; }
-    void setInputMedia(const InputMedia &inputMedia) { m_inputMedia = inputMedia; }
-    qint64 randomId() const { return mRandomId; }
-    void setRandomId(qint64 randomId) { mRandomId = randomId; }
-    qint32 chatId() const { return m_chatId; }
-    void setChatId(qint32 chatId) { m_chatId = chatId; }
-    InputChatPhoto inputChatPhoto() const { return m_inputChatPhoto; }
-    void setInputChatPhoto(InputChatPhoto inputChatPhoto) { m_inputChatPhoto = inputChatPhoto; }
-    QString caption() const { return m_caption; }
-    void setCaption(QString caption) { m_caption = caption; }
-    InputGeoPoint geoPoint() const { return m_geoPoint; }
-    void setGeoPoint(InputGeoPoint geoPoint) { m_geoPoint = geoPoint; }
-    InputPhotoCrop crop() const { return m_crop; }
-    void setCrop(InputPhotoCrop crop) { m_crop = crop; }
-    OpType opType() const { return m_type; }
-
-
-    void setInputEncryptedChat(const InputEncryptedChat &inputEncryptedChat) { mInputEncryptedChat = inputEncryptedChat; }
-    void setDecryptedMessage(const DecryptedMessage &decryptedMessage) { mDecryptedMessage = decryptedMessage; }
-    InputEncryptedChat inputEncryptedChat() const { return mInputEncryptedChat; }
-    DecryptedMessage decryptedMessage() const { return mDecryptedMessage; }
-    QByteArray key() const { return mKey; }
-    QByteArray iv() const { return mIv; }
-
-    void initializeKeyAndIv() {
-        char keyData[32];
-        Utils::randomBytes(keyData, 32);
-        mKey = QByteArray(keyData, 32);
-        char ivData[32];
-        Utils::randomBytes(ivData, 32);
-        mIv = QByteArray(ivData, 32);
-    }
-
-private:
-    // sendMedia operation attributes
-    InputPeer m_peer;
-    InputMedia m_inputMedia;
-    qint64 mRandomId;
-    // editChatPhoto operation attributes
-    qint32 m_chatId;
-    InputChatPhoto m_inputChatPhoto;
-    // uploadProfilePhoto operation attributes
-    QString m_caption;
-    InputGeoPoint m_geoPoint;
-    InputPhotoCrop m_crop;
-    OpType m_type;
-
-    InputEncryptedChat mInputEncryptedChat;
-    DecryptedMessage mDecryptedMessage;
-    //key and initialization vector for encrypted files
-    QByteArray mKey; // 32 bytes
-    QByteArray mIv; // 32 bytes
-};
-
-#endif // FILEOPERATION_H

=== removed file 'lib/logic/uploadfile.cpp'
--- lib/logic/uploadfile.cpp	2015-01-28 07:57:21 +0000
+++ lib/logic/uploadfile.cpp	1970-01-01 00:00:00 +0000
@@ -1,130 +0,0 @@
-/*
- * Copyright 2014 Canonical Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors:
- *      Roberto Mier
- *      Tiago Herrmann
- */
-
-#include "uploadfile.h"
-
-#include <QFileInfo>
-
-UploadFile::UploadFile(Session *session, UploadFile::FileType fileType, const QByteArray &buffer, QObject *parent) :
-    File(session, buffer.size(), parent),
-    m_fileType(fileType),
-    m_relatedFileId(0),
-    m_name(""),
-    m_bytes(buffer),
-    m_filePath(""),
-    m_nParts(0),
-    m_currentPart(0),
-    m_uploadedParts(0),
-    m_krypt(QCryptographicHash::Md5)
-{
-    // calculate number of parts to be uploaded
-    m_nParts = m_length / mPartLength;
-    if (m_nParts * mPartLength < m_length) m_nParts++;
-}
-
-UploadFile::UploadFile(Session *session, UploadFile::FileType fileType, const QString &filePath, QObject *parent) :
-    File(session, QFileInfo(filePath).size(), parent),
-    m_fileType(fileType),
-    m_relatedFileId(0),
-    m_name(QFileInfo(filePath).fileName()),
-    m_filePath(filePath),
-    m_nParts(0),
-    m_currentPart(0),
-    m_uploadedParts(0),
-    m_ioDevice(filePath),
-    m_krypt(QCryptographicHash::Md5)
-{
-    // open file
-    openIODevice();
-    // calculate number of parts to be uploaded
-    m_nParts = m_length / mPartLength;
-    if (m_nParts * mPartLength < m_length) m_nParts++;
-}
-
-UploadFile::~UploadFile() {
-}
-
-void UploadFile::openIODevice() {
-    if (m_ioDevice.open(QIODevice::ReadOnly)) {
-        // get file size with file open
-        m_length = m_ioDevice.size();
-    } else {
-        Q_EMIT fileNotFound();
-    }
-}
-
-bool UploadFile::hasMoreParts() const {
-    return m_currentPart < m_nParts;
-}
-
-QByteArray UploadFile::nextPart() {
-    QByteArray partBytes(mPartLength, Qt::Uninitialized);
-
-    //let's see if the file content is loaded or a filepath is set
-    if (!m_bytes.isEmpty()) {
-        qint32 k = 0;
-        if (m_currentPart < m_nParts -1) {
-            // if not the last part
-            qint32 n = (m_currentPart + 1) * mPartLength;
-            for (qint32 j = (m_currentPart * mPartLength); j < n; j++) {
-                partBytes[k++] = m_bytes[j];
-            }
-        } else {
-            // if last part
-            qint32 lastPartSize = m_length % mPartLength;
-            // if not the last part
-            qint32 n = (m_currentPart * mPartLength) + lastPartSize;
-            for (qint32 j = (m_currentPart * mPartLength); j < n; j++) {
-                partBytes[k++] = m_bytes[j];
-            }
-        }
-    } else {
-        // in this case we're reading an open file from a local path
-        if (m_ioDevice.isOpen()) {
-            m_ioDevice.seek(m_currentPart * mPartLength); //set offset
-            partBytes = m_ioDevice.read(mPartLength);
-            if (!hasMoreParts()) {
-                m_ioDevice.close();
-            }
-        } else {
-            Q_EMIT fileNotOpen();
-        }
-    }
-    m_currentPart++;
-
-    QByteArray processedBytes;
-    if (mEncrypted) {
-        processedBytes = CryptoUtils::getInstance()->encryptFilePart(partBytes, mKey, mIv);
-    } else {
-        processedBytes = partBytes;
-    }
-
-    // add the new data to cryptographic hash before return it
-    m_krypt.addData(processedBytes, processedBytes.length());
-    return processedBytes;
-}
-
-void UploadFile::increaseUploadedParts() {
-    m_uploadedParts++;
-}
-
-QByteArray UploadFile::md5() {
-    return m_krypt.result();
-}

=== removed file 'lib/logic/uploadfile.h'
--- lib/logic/uploadfile.h	2014-11-28 18:46:13 +0000
+++ lib/logic/uploadfile.h	1970-01-01 00:00:00 +0000
@@ -1,76 +0,0 @@
-/*
- * Copyright 2014 Canonical Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors:
- *      Roberto Mier
- *      Tiago Herrmann
- */
-
-#ifndef UPLOADFILE_H
-#define UPLOADFILE_H
-
-#include <QObject>
-#include <QFile>
-#include <QCryptographicHash>
-#include "file.h"
-#include "types/inputmedia.h"
-
-class UploadFile : public File
-{
-    Q_OBJECT
-public:
-
-    enum FileType {
-        file,
-        thumbnail
-    };
-
-    explicit UploadFile(Session *session, FileType type, const QByteArray &buffer, QObject *parent = 0);
-    explicit UploadFile(Session *session, FileType type, const QString &filePath, QObject *parent = 0);
-    ~UploadFile();
-
-    qint64 relatedFileId() const { return m_relatedFileId; }
-    void setRelatedFileId(qint64 relatedFileId) { m_relatedFileId = relatedFileId; }
-    QString name() const { return m_name; }
-    void setName(const QString &name) { m_name = name; }
-    FileType fileType() const { return m_fileType; }
-    qint32 nParts() const { return m_nParts; }
-    qint32 uploadedParts() const { return m_uploadedParts; }
-
-    bool hasMoreParts() const;
-    QByteArray nextPart();
-    void increaseUploadedParts();
-    QByteArray md5();
-
-Q_SIGNALS:
-    void fileNotFound();
-    void fileNotOpen();
-
-private:
-    FileType m_fileType;
-    qint64 m_relatedFileId; // if this is the main file, related file is thumbnail and viceversa
-    QString m_name;
-    QByteArray m_bytes;
-    QString m_filePath;
-    qint32 m_nParts;
-    qint32 m_currentPart;
-    qint32 m_uploadedParts;
-    QFile m_ioDevice;
-    QCryptographicHash m_krypt;
-
-    void openIODevice();
-};
-
-#endif // UPLOADFILE_H

=== modified file 'lib/secret/CMakeLists.txt'
--- lib/secret/CMakeLists.txt	2014-11-17 15:27:33 +0000
+++ lib/secret/CMakeLists.txt	2015-02-24 14:12:31 +0000
@@ -1,7 +1,9 @@
 set(SECRET_HEADERS
+    decryptedmessagebuilder.h
     decrypter.h
     encrypter.h
     secretstate.h
+    secretchatmessage.h
     secretchat.h)
 
 if(NOT CLICK_MODE)

=== modified file 'lib/secret/decryptedmessagebuilder.cpp'
--- lib/secret/decryptedmessagebuilder.cpp	2015-02-06 10:19:34 +0000
+++ lib/secret/decryptedmessagebuilder.cpp	2015-02-24 14:12:31 +0000
@@ -1,5 +1,5 @@
 #include "decryptedmessagebuilder.h"
-#include "core/utils.h"
+#include "util/utils.h"
 
 DecryptedMessageBuilder::DecryptedMessageBuilder(qint32 layer) : mLayer(layer) {
 }

=== modified file 'lib/secret/decrypter.cpp'
--- lib/secret/decrypter.cpp	2015-02-11 18:35:01 +0000
+++ lib/secret/decrypter.cpp	2015-02-24 14:12:31 +0000
@@ -16,12 +16,14 @@
  */
 
 #include "decrypter.h"
-#include "core/constants.h"
-#include "core/tlvalues.h"
+#include "util/constants.h"
+#include "util/tlvalues.h"
 #include "core/settings.h"
 #include <openssl/sha.h>
 #include <openssl/aes.h>
 
+Q_LOGGING_CATEGORY(TG_SECRET_DECRYPTER, "tg.secret.decrypter")
+
 template <typename T_>
 void do_delete(T_ buf[]) {
     delete[] buf;
@@ -30,11 +32,11 @@
 Decrypter::Decrypter() :
     InboundPkt(0, 0),
     mSecretChat(0) {
-    __buffer = QSharedPointer<char>(new char[PACKET_BUFFER_SIZE], do_delete<char>);
+    mBufferPtr = QSharedPointer<char>(new char[PACKET_BUFFER_SIZE], do_delete<char>);
 }
 
 Decrypter::~Decrypter() {
-    __buffer.clear();
+    mBufferPtr.clear();
 }
 
 void Decrypter::setSecretChat(SecretChat *secretChat) {
@@ -49,11 +51,11 @@
         return DecryptedMessage();
     }
 
-    m_buffer = __buffer.data();
+    m_buffer = mBufferPtr.data();
     memcpy(m_buffer, bytes.data(), m_length);
 
     if (!(m_length & 15) == 8) {
-        qCWarning(TG_LIB_SECRET) << "Received packet doesn't satisfy length rule (!(length & 0xF) == 1000)";
+        qCWarning(TG_SECRET_DECRYPTER) << "Received packet doesn't satisfy length rule (!(length & 0xF) == 1000)";
         return DecryptedMessage();
     }
 
@@ -66,7 +68,7 @@
     qint32 receivedOutSeqNoParam = -1;
     // message must be read completly regardless it belongs to a valid secret chat
     if (!mSecretChat) {
-        qCDebug(TG_LIB_SECRET) << "Received messsage to unknown chat. Dropping";
+        qCDebug(TG_SECRET_DECRYPTER) << "Received messsage to unknown chat. Dropping";
         processMessage = false;
     } else {
         processMessage = checkKeyFingerprints();
@@ -89,14 +91,14 @@
 
             qint32 receivedInSeqNoParam = fetchInt();
             receivedOutSeqNoParam = fetchInt();
-            qCDebug(TG_LIB_SECRET) << "Received in_seq_no=" << receivedInSeqNoParam << "(expected" << (mSecretChat->getOutSeqNoParam() - 2) << ")";
-            qCDebug(TG_LIB_SECRET) << "Received out_seq_no=" << receivedOutSeqNoParam << "(expected" << mSecretChat->getInSeqNoParam() << ")";
+            qCDebug(TG_SECRET_DECRYPTER) << "Received in_seq_no=" << receivedInSeqNoParam << "(expected" << (mSecretChat->getOutSeqNoParam() - 2) << ")";
+            qCDebug(TG_SECRET_DECRYPTER) << "Received out_seq_no=" << receivedOutSeqNoParam << "(expected" << mSecretChat->getInSeqNoParam() << ")";
 
             qint32 ourId = Settings::getInstance()->ourId();
 
             if ((receivedOutSeqNoParam & 1) != 1 - (mSecretChat->adminId() == ourId) ||
                     (receivedInSeqNoParam & 1) != (mSecretChat->adminId() == ourId)) {
-                qCWarning(TG_LIB_SECRET) << "Bad message admin";
+                qCWarning(TG_SECRET_DECRYPTER) << "Bad message admin";
                 processMessage = false;
             }
 
@@ -105,11 +107,11 @@
 
             if (deflatedOutSeqNo != mSecretChat->inSeqNo()) {
                 if (deflatedOutSeqNo < mSecretChat->inSeqNo()) {
-                    qCWarning(TG_LIB_SECRET) << "Received out_seq_no (" << deflatedOutSeqNo
+                    qCWarning(TG_SECRET_DECRYPTER) << "Received out_seq_no (" << deflatedOutSeqNo
                                              << ") is lower than expected (" << mSecretChat->inSeqNo() << ")";
                     processMessage = false;
                 } else if (deflatedOutSeqNo > mSecretChat->inSeqNo()) {
-                    qCWarning(TG_LIB_SECRET) << "Found gap since received out_seq_no (" << deflatedOutSeqNo
+                    qCWarning(TG_SECRET_DECRYPTER) << "Found gap since received out_seq_no (" << deflatedOutSeqNo
                                              << ") is greater than expected (" << mSecretChat->inSeqNo()
                                              << "). Requesting intermediate messages to fill the gap";
                     processMessage = false;
@@ -118,7 +120,7 @@
                 }
             }
             if (deflatedInSeqNo > mSecretChat->outSeqNo()) {
-                qCWarning(TG_LIB_SECRET) << "deflated received in_seq_no is bigger than our's out seq no sent in last message (out_seq_no ="
+                qCWarning(TG_SECRET_DECRYPTER) << "deflated received in_seq_no is bigger than our's out seq no sent in last message (out_seq_no ="
                                          << deflatedInSeqNo << ", our out_seq_no =" << mSecretChat->outSeqNo();
                 processMessage = false;
             }
@@ -126,7 +128,7 @@
             if (processMessage) {
                 mSecretChat->setLayer(layer);
                 mSecretChat->setInSeqNo(receivedOutSeqNoParam / 2 + 1);
-                qCDebug(TG_LIB_SECRET) << "Updating in_seq_no; Current values -> out_seq_no:" << mSecretChat->outSeqNo()
+                qCDebug(TG_SECRET_DECRYPTER) << "Updating in_seq_no; Current values -> out_seq_no:" << mSecretChat->outSeqNo()
                                        << ",in_seq_no:" << mSecretChat->inSeqNo();
             }
         }
@@ -147,7 +149,7 @@
                 switch (action.classType()) {
                 case DecryptedMessageAction::typeDecryptedMessageActionNotifyLayer: {
                     mSecretChat->setLayer(action.layer());
-                    qCDebug(TG_LIB_SECRET) << "Received layer" << action.layer() << "from peer";
+                    qCDebug(TG_SECRET_DECRYPTER) << "Received layer" << action.layer() << "from peer";
                     break;
                 }
                 default:
@@ -155,7 +157,7 @@
                     //TODO Roberto: implement rest of cases
                 }
             } else {
-                qCDebug(TG_LIB_SECRET) << "Received message";
+                qCDebug(TG_SECRET_DECRYPTER) << "Received message";
             }
 
             // append to secret chat sequence
@@ -176,12 +178,12 @@
     bool result = false;
     if (mSecretChat) {
         qint64 keyFingerprint = fetchLong();
-        qCDebug(TG_LIB_SECRET) << "Received keyFingerprint" << keyFingerprint;
-        qCDebug(TG_LIB_SECRET) << "Stored keyFingerprint" << mSecretChat->keyFingerprint();
+        qCDebug(TG_SECRET_DECRYPTER) << "Received keyFingerprint" << keyFingerprint;
+        qCDebug(TG_SECRET_DECRYPTER) << "Stored keyFingerprint" << mSecretChat->keyFingerprint();
         if (keyFingerprint != mSecretChat->keyFingerprint()) {
-            qCWarning(TG_LIB_SECRET) << "Encrypted message with bad keyFingerprint for chat" << mSecretChat->chatId();
+            qCWarning(TG_SECRET_DECRYPTER) << "Encrypted message with bad keyFingerprint for chat" << mSecretChat->chatId();
         } else {
-            qCDebug(TG_LIB_SECRET) << "keyFingerprints matches!!";
+            qCDebug(TG_SECRET_DECRYPTER) << "keyFingerprints matches!!";
             result = true;
         }
     }
@@ -236,21 +238,21 @@
 
     qint32 x = prefetchInt();
     if (x < 0 || (x & 3)) {
-        qCWarning(TG_LIB_SECRET) << "Not valid value for internal data length" << x;
+        qCWarning(TG_SECRET_DECRYPTER) << "Not valid value for internal data length" << x;
         return QByteArray();
     }
     ASSERT(x >= 0 && !(x & 3));
     SHA1((uchar *)m_inPtr, 4 + x, sha1a_buffer);
 
     if (memcmp(sha1a_buffer + 4, msgKey, 16)) {
-        qCWarning(TG_LIB_SECRET) << "SHA1 mismatch";
+        qCWarning(TG_SECRET_DECRYPTER) << "SHA1 mismatch";
         return QByteArray();
     }
-    qCDebug(TG_LIB_SECRET) << "SHA1 checked and valid";
+    qCDebug(TG_SECRET_DECRYPTER) << "SHA1 checked and valid";
 
     qint32 plainDataLength = fetchInt();
     m_inEnd = m_inPtr + plainDataLength;
-    qCDebug(TG_LIB_SECRET) << "decrypted data length" << plainDataLength;
+    qCDebug(TG_SECRET_DECRYPTER) << "decrypted data length" << plainDataLength;
 
     QByteArray plainData((char *)m_inPtr, plainDataLength);
     return plainData;

=== modified file 'lib/secret/decrypter.h'
--- lib/secret/decrypter.h	2015-01-28 15:50:32 +0000
+++ lib/secret/decrypter.h	2015-02-24 14:12:31 +0000
@@ -26,7 +26,7 @@
 #include <QSharedPointer>
 #include <QPair>
 
-Q_DECLARE_LOGGING_CATEGORY(TG_LIB_SECRET)
+Q_DECLARE_LOGGING_CATEGORY(TG_SECRET_DECRYPTER)
 
 class Decrypter : public QObject, public InboundPkt
 {
@@ -44,7 +44,7 @@
 
 protected:
     SecretChat *mSecretChat;
-    QSharedPointer<char> __buffer;
+    QSharedPointer<char> mBufferPtr;
 
     bool checkKeyFingerprints();
     QByteArray decryptEncryptedMessage();

=== modified file 'lib/secret/encrypter.cpp'
--- lib/secret/encrypter.cpp	2015-01-30 08:20:13 +0000
+++ lib/secret/encrypter.cpp	2015-02-24 14:12:31 +0000
@@ -16,12 +16,13 @@
  */
 
 #include "encrypter.h"
-#include "core/utils.h"
+#include "util/utils.h"
 #include "openssl/sha.h"
 #include "openssl/aes.h"
 #include "decryptedmessagebuilder.h"
+#include "util/tlvalues.h"
 
-#include "core/tlvalues.h"
+Q_LOGGING_CATEGORY(TG_SECRET_ENCRYPTER, "tg.secret.encrypter")
 
 Encrypter::Encrypter() :
     OutboundPkt(),
@@ -32,7 +33,6 @@
     mSecretChat(0) {
 }
 
-
 void Encrypter::setSecretChat(SecretChat *secretChat) {
     mSecretChat = secretChat;
 }

=== modified file 'lib/secret/encrypter.h'
--- lib/secret/encrypter.h	2015-01-30 08:20:13 +0000
+++ lib/secret/encrypter.h	2015-02-24 14:12:31 +0000
@@ -23,7 +23,7 @@
 #include "secret/secretchat.h"
 #include <QLoggingCategory>
 
-Q_DECLARE_LOGGING_CATEGORY(TG_LIB_SECRET)
+Q_DECLARE_LOGGING_CATEGORY(TG_SECRET_ENCRYPTER)
 
 class Encrypter : public OutboundPkt
 {

=== modified file 'lib/secret/secretchat.cpp'
--- lib/secret/secretchat.cpp	2015-02-04 15:46:54 +0000
+++ lib/secret/secretchat.cpp	2015-02-24 14:12:31 +0000
@@ -16,9 +16,11 @@
  */
 
 #include "secretchat.h"
-#include "core/utils.h"
+#include "util/utils.h"
 #include "core/settings.h"
 
+Q_LOGGING_CATEGORY(TG_SECRET_SECRETCHAT, "tg.secret.secretchat")
+
 SecretChat::SecretChat(QObject *parent) :
     QObject(parent),
     mState(Init),
@@ -178,7 +180,7 @@
 
 void SecretChat::increaseOutSeqNo() {
     mOutSeqNo++;
-    qCDebug(TG_LIB_SECRET) << "updated -> out_seq_no:" << mOutSeqNo << ",in_seq_no:" << mInSeqNo;
+    qCDebug(TG_SECRET_SECRETCHAT) << "updated -> out_seq_no:" << mOutSeqNo << ",in_seq_no:" << mInSeqNo;
 }
 
 void SecretChat::appendToSequence(qint64 msgId) {
@@ -186,7 +188,7 @@
     if (mSequence.size() > SEQUENCE_MAX_SIZE) {
         mSequence.removeFirst();
     }
-    qCDebug(TG_LIB_SECRET) << "Current previous messages sequence:" << endl << mSequence;
+    qCDebug(TG_SECRET_SECRETCHAT) << "Current previous messages sequence:" << endl << mSequence;
 }
 
 QList<qint64> SecretChat::sequence() {

=== modified file 'lib/secret/secretchat.h'
--- lib/secret/secretchat.h	2015-02-04 15:46:54 +0000
+++ lib/secret/secretchat.h	2015-02-24 14:12:31 +0000
@@ -31,9 +31,9 @@
 #include "openssl/bn.h"
 #include "types/encryptedchat.h"
 #include "types/decryptedmessage.h"
-#include "core/constants.h"
+#include "util/constants.h"
 
-Q_DECLARE_LOGGING_CATEGORY(TG_LIB_SECRET)
+Q_DECLARE_LOGGING_CATEGORY(TG_SECRET_SECRETCHAT)
 
 class SecretChat : public QObject
 {

=== modified file 'lib/secret/secretstate.h'
--- lib/secret/secretstate.h	2014-11-18 17:13:16 +0000
+++ lib/secret/secretstate.h	2015-02-24 14:12:31 +0000
@@ -21,7 +21,7 @@
 #include <QObject>
 #include <QMap>
 #include <openssl/bn.h>
-#include "core/utils.h"
+#include "util/utils.h"
 #include "types/inputuser.h"
 #include "secretchat.h"
 

=== modified file 'lib/telegram.cpp'
--- lib/telegram.cpp	2015-02-19 12:15:37 +0000
+++ lib/telegram.cpp	2015-02-24 14:12:31 +0000
@@ -35,9 +35,9 @@
 #include <QtEndian>
 #include <QImage>
 
-#include "core/tlvalues.h"
+#include "util/tlvalues.h"
 
-Q_LOGGING_CATEGORY(TG_LIB_API, "tg.lib.api")
+Q_LOGGING_CATEGORY(TG_TELEGRAM, "tg.telegram")
 Q_LOGGING_CATEGORY(TG_LIB_SECRET, "tg.lib.secret")
 
 Telegram::Telegram(const QString &phoneNumber, const QString &configPath, const QString &publicKeyFile) :
@@ -70,8 +70,8 @@
 bool Telegram::sleep() {
     // sleep only if not slept and library already logged in. Returns true if sleep operations completes
     if (!mSlept && mLibraryState >= LoggedIn) {
-        if (m_api && m_api->mainSession()) {
-            m_api->mainSession()->close();
+        if (mApi && mApi->mainSession()) {
+            mApi->mainSession()->close();
         }
         mSlept = true;
         return true;
@@ -82,9 +82,9 @@
 bool Telegram::wake() {
     // wake only if slept and library already logged in. Returns true if wake operation completes
     if (mSlept && mLibraryState >= LoggedIn) {
-        connect(m_api, SIGNAL(mainSessionReady()), this, SIGNAL(woken()), Qt::UniqueConnection);
+        connect(mApi, SIGNAL(mainSessionReady()), this, SIGNAL(woken()), Qt::UniqueConnection);
         DC *dc = mDcProvider.getWorkingDc();
-        m_api->createMainSessionToDc(dc);
+        mApi->createMainSessionToDc(dc);
         mSlept = false;
         return true;
     }
@@ -105,21 +105,11 @@
 }
 
 Telegram::~Telegram() {
-    // delete any remainig download files, upload files or operations
-    Q_FOREACH (UploadFile *f, mUploadsMap) {
-        if (f) delete f;
-    }
-    Q_FOREACH (const FileOperation *op, mFileOperationsMap) {
-        if (op) delete op;
-    }
-    Q_FOREACH (const DownloadFile *f, mDownloadsMap) {
-        if (f) delete f;
-    }
 }
 
 bool Telegram::isConnected() {
-    if (m_api && m_api->mainSession()) {
-        return m_api->mainSession()->state() == QAbstractSocket::ConnectedState;
+    if (mApi && mApi->mainSession()) {
+        return mApi->mainSession()->state() == QAbstractSocket::ConnectedState;
     }
     return false;
 }
@@ -145,132 +135,132 @@
 
 void Telegram::onDcProviderReady() {
     mLibraryState = CreatedSharedKeys;
-    m_api = mDcProvider.getApi();
+    mApi = mDcProvider.getApi();
     // api signal-signal and signal-slot connections
     // updates
-    connect(m_api, SIGNAL(updatesTooLong()), this, SIGNAL(updatesTooLong()));
-    connect(m_api, SIGNAL(updateShortMessage(qint32,qint32,QString,qint32,qint32,qint32)), this, SIGNAL(updateShortMessage(qint32,qint32,QString,qint32,qint32,qint32)));
-    connect(m_api, SIGNAL(updateShortChatMessage(qint32,qint32,qint32,QString,qint32,qint32,qint32)), this, SIGNAL(updateShortChatMessage(qint32,qint32,qint32,QString,qint32,qint32,qint32)));
-    connect(m_api, SIGNAL(updateShort(Update,qint32)), this, SIGNAL(updateShort(Update,qint32)));
-    connect(m_api, SIGNAL(updatesCombined(QList<Update>,QList<User>,QList<Chat>,qint32,qint32,qint32)), this, SIGNAL(updatesCombined(QList<Update>,QList<User>,QList<Chat>,qint32,qint32,qint32)));
-    connect(m_api, SIGNAL(updates(QList<Update>,QList<User>,QList<Chat>,qint32,qint32)), this, SIGNAL(updates(QList<Update>,QList<User>,QList<Chat>,qint32,qint32)));
+    connect(mApi, SIGNAL(updatesTooLong()), this, SIGNAL(updatesTooLong()));
+    connect(mApi, SIGNAL(updateShortMessage(qint32,qint32,QString,qint32,qint32,qint32)), this, SIGNAL(updateShortMessage(qint32,qint32,QString,qint32,qint32,qint32)));
+    connect(mApi, SIGNAL(updateShortChatMessage(qint32,qint32,qint32,QString,qint32,qint32,qint32)), this, SIGNAL(updateShortChatMessage(qint32,qint32,qint32,QString,qint32,qint32,qint32)));
+    connect(mApi, SIGNAL(updateShort(Update,qint32)), this, SIGNAL(updateShort(Update,qint32)));
+    connect(mApi, SIGNAL(updatesCombined(QList<Update>,QList<User>,QList<Chat>,qint32,qint32,qint32)), this, SIGNAL(updatesCombined(QList<Update>,QList<User>,QList<Chat>,qint32,qint32,qint32)));
+    connect(mApi, SIGNAL(updates(QList<Update>,QList<User>,QList<Chat>,qint32,qint32)), this, SIGNAL(updates(QList<Update>,QList<User>,QList<Chat>,qint32,qint32)));
     // errors
-    connect(m_api, SIGNAL(error(qint64,qint32,QString)), this, SLOT(onError(qint64,qint32,QString)));
-    connect(m_api, SIGNAL(errorRetry(qint64,qint32,QString)), this, SLOT(onErrorRetry(qint64,qint32,QString)));
-    connect(m_api, SIGNAL(authSignInError(qint64,qint32,QString)), this, SIGNAL(authSignInError(qint64,qint32,QString)));
-    connect(m_api, SIGNAL(authSignUpError(qint64,qint32,QString)), this, SIGNAL(authSignUpError(qint64,qint32,QString)));
-    connect(m_api, SIGNAL(uploadFileError(qint64,qint32,QString)), this, SLOT(onUploadGetFileError(qint64,qint32,QString)));
+    connect(mApi, SIGNAL(error(qint64,qint32,QString)), this, SLOT(onError(qint64,qint32,QString)));
+    connect(mApi, SIGNAL(errorRetry(qint64,qint32,QString)), this, SLOT(onErrorRetry(qint64,qint32,QString)));
+    connect(mApi, SIGNAL(authSignInError(qint64,qint32,QString)), this, SIGNAL(authSignInError(qint64,qint32,QString)));
+    connect(mApi, SIGNAL(authSignUpError(qint64,qint32,QString)), this, SIGNAL(authSignUpError(qint64,qint32,QString)));
     // positive responses
-    connect(m_api, SIGNAL(helpGetInviteTextAnswer(qint64,QString)), this, SIGNAL(helpGetInviteTextAnswer(qint64,QString)));
-    connect(m_api, SIGNAL(authCheckedPhone(qint64,bool,bool)), this, SIGNAL(authCheckPhoneAnswer(qint64,bool,bool)));
-    connect(m_api, SIGNAL(authCheckPhoneSent(qint64,QString)), this, SIGNAL(authCheckPhoneSent(qint64,QString)));
-    connect(m_api, SIGNAL(authSentCode(qint64,bool,QString,qint32,bool)), this, SLOT(onAuthSentCode(qint64,bool,QString,qint32,bool)));
-    connect(m_api, SIGNAL(authSentAppCode(qint64,bool,QString,qint32,bool)), this, SLOT(onAuthSentCode(qint64,bool,QString,qint32,bool)));
-    connect(m_api, SIGNAL(authSendSmsResult(qint64,bool)), this, SIGNAL(authSendSmsAnswer(qint64,bool)));
-    connect(m_api, SIGNAL(authSendCallResult(qint64,bool)), this, SIGNAL(authSendCallAnswer(qint64,bool)));
-    connect(m_api, SIGNAL(authSignInAuthorization(qint64,qint32,User)), this, SLOT(onUserAuthorized(qint64,qint32,User)));
-    connect(m_api, SIGNAL(authSignUpAuthorization(qint64,qint32,User)), this, SLOT(onUserAuthorized(qint64,qint32,User)));
-    connect(m_api, SIGNAL(authLogOutResult(qint64,bool)), this, SLOT(onAuthLogOutAnswer(qint64,bool)));
-    connect(m_api, SIGNAL(authSendInvitesResult(qint64,bool)), this, SIGNAL(authSendInvitesAnswer(qint64,bool)));
-    connect(m_api, SIGNAL(authResetAuthorizationsResult(qint64,bool)), this, SIGNAL(authResetAuthorizationsAnswer(qint64,bool)));
-    connect(m_api, SIGNAL(accountRegisterDeviceResult(qint64,bool)), this, SIGNAL(accountRegisterDeviceAnswer(qint64,bool)));
-    connect(m_api, SIGNAL(accountUnregisterDeviceResult(qint64,bool)), this, SIGNAL(accountUnregisterDeviceAnswer(qint64,bool)));
-    connect(m_api, SIGNAL(accountUpdateNotifySettingsResult(qint64,bool)), this, SIGNAL(accountUpdateNotifySettingsAnswer(qint64,bool)));
-    connect(m_api, SIGNAL(accountPeerNotifySettings(qint64,PeerNotifySettings)), this, SIGNAL(accountGetNotifySettingsAnswer(qint64,PeerNotifySettings)));
-    connect(m_api, SIGNAL(accountResetNotifySettingsResult(qint64,bool)), this, SIGNAL(accountResetNotifySettingsAnswer(qint64,bool)));
-    connect(m_api, SIGNAL(accountUser(qint64,User)), this, SIGNAL(accountUpdateProfileAnswer(qint64,User)));
-    connect(m_api, SIGNAL(accountUpdateStatusResult(qint64,bool)), this, SIGNAL(accountUpdateStatusAnswer(qint64,bool)));
-    connect(m_api, SIGNAL(accountGetWallPapersResult(qint64,QList<WallPaper>)), this, SIGNAL(accountGetWallPapersAnswer(qint64,QList<WallPaper>)));
-    connect(m_api, SIGNAL(photosPhoto(qint64,Photo,QList<User>)), this, SIGNAL(photosUploadProfilePhotoAnswer(qint64,Photo,QList<User>)));
-    connect(m_api, SIGNAL(photosUserProfilePhoto(qint64,UserProfilePhoto)), this, SIGNAL(photosUpdateProfilePhotoAnswer(qint64,UserProfilePhoto)));
-    connect(m_api, SIGNAL(usersGetUsersResult(qint64,QList<User>)), this, SIGNAL(usersGetUsersAnswer(qint64,QList<User>)));
-    connect(m_api, SIGNAL(userFull(qint64,User,ContactsLink,Photo,PeerNotifySettings,bool,QString,QString)), this, SIGNAL(usersGetFullUserAnswer(qint64,User,ContactsLink,Photo,PeerNotifySettings,bool,QString,QString)));
-    connect(m_api, SIGNAL(photosPhotos(qint64,QList<Photo>,QList<User>)), this, SLOT(onPhotosPhotos(qint64, QList<Photo>, QList<User>)));
-    connect(m_api, SIGNAL(photosPhotosSlice(qint64,qint32,QList<Photo>,QList<User>)), this, SIGNAL(photosGetUserPhotosAnswer(qint64,qint32,QList<Photo>,QList<User>)));
-    connect(m_api, SIGNAL(contactsGetStatusesResult(qint64,QList<ContactStatus>)), this, SIGNAL(contactsGetStatusesAnswer(qint64,QList<ContactStatus>)));
-    connect(m_api, SIGNAL(contactsContacts(qint64,QList<Contact>,QList<User>)), this, SLOT(onContactsContacts(qint64,QList<Contact>,QList<User>)));
-    connect(m_api, SIGNAL(contactsContactsNotModified(qint64)), this, SLOT(onContactsContactsNotModified(qint64)));
-    connect(m_api, SIGNAL(contactsImportedContacts(qint64,QList<ImportedContact>,QList<qint64>,QList<User>)), this, SIGNAL(contactsImportContactsAnswer(qint64,QList<ImportedContact>,QList<qint64>,QList<User>)));
-    connect(m_api, SIGNAL(contactsImportedContacts(qint64,QList<ImportedContact>,QList<qint64>,QList<User>)), this, SLOT(onContactsImportContactsAnswer()));
-    connect(m_api, SIGNAL(contactsDeleteContactLink(qint64,ContactsMyLink,ContactsForeignLink,User)), this, SIGNAL(contactsDeleteContactAnswer(qint64,ContactsMyLink,ContactsForeignLink,User)));
-    connect(m_api, SIGNAL(contactsDeleteContactsResult(qint64,bool)), this, SIGNAL(contactsDeleteContactsAnswer(qint64,bool)));
-    connect(m_api, SIGNAL(contactsBlockResult(qint64,bool)), this, SIGNAL(contactsBlockAnswer(qint64,bool)));
-    connect(m_api, SIGNAL(contactsUnblockResult(qint64,bool)), this, SIGNAL(contactsUnblockAnswer(qint64,bool)));
-    connect(m_api, SIGNAL(contactsBlocked(qint64,QList<ContactBlocked>,QList<User>)), this, SLOT(onContactsBlocked(qint64,QList<ContactBlocked>,QList<User>)));
-    connect(m_api, SIGNAL(contactsBlockedSlice(qint64,qint32,QList<ContactBlocked>,QList<User>)), this, SIGNAL(contactsGetBlockedAnswer(qint64,qint32,QList<ContactBlocked>,QList<User>)));
-    connect(m_api, SIGNAL(messagesSentMessage(qint64,qint32,qint32,qint32,qint32)), this, SLOT(onMessagesSentMessage(qint64,qint32,qint32,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesSentMessageLink(qint64,qint32,qint32,qint32,qint32,QList<ContactsLink>)), this, SIGNAL(messagesSendMessageAnswer(qint64,qint32,qint32,qint32,qint32,QList<ContactsLink>)));
-    connect(m_api, SIGNAL(messagesSentMediaStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)), this, SLOT(onMessagesSendMediaStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesSentMediaStatedMessageLink(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)), this, SLOT(onMessagesSendMediaStatedMessageLink(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesSetTypingResult(qint64,bool)), this, SIGNAL(messagesSetTypingAnswer(qint64,bool)));
-    connect(m_api, SIGNAL(messagesGetMessagesMessages(qint64,QList<Message>,QList<Chat>,QList<User>)), this, SLOT(onMessagesGetMessagesMessages(qint64,QList<Message>,QList<Chat>,QList<User>)));
-    connect(m_api, SIGNAL(messagesGetMessagesMessagesSlice(qint64,qint32,QList<Message>,QList<Chat>,QList<User>)), this, SIGNAL(messagesGetMessagesAnswer(qint64,qint32,QList<Message>,QList<Chat>,QList<User>)));
-    connect(m_api, SIGNAL(messagesDialogs(qint64, QList<Dialog>,QList<Message>,QList<Chat>,QList<User>)), this, SLOT(onMessagesDialogs(qint64,QList<Dialog>,QList<Message>,QList<Chat>,QList<User>)));
-    connect(m_api, SIGNAL(messagesDialogsSlice(qint64,qint32,QList<Dialog>,QList<Message>,QList<Chat>,QList<User>)), this, SIGNAL(messagesGetDialogsAnswer(qint64,qint32,QList<Dialog>,QList<Message>,QList<Chat>,QList<User>)));
-    connect(m_api, SIGNAL(messagesGetHistoryMessages(qint64,QList<Message>,QList<Chat>,QList<User>)), this, SLOT(onMessagesGetHistoryMessages(qint64,QList<Message>,QList<Chat>,QList<User>)));
-    connect(m_api, SIGNAL(messagesGetHistoryMessagesSlice(qint64,qint32,QList<Message>,QList<Chat>,QList<User>)), this, SIGNAL(messagesGetHistoryAnswer(qint64,qint32,QList<Message>,QList<Chat>,QList<User>)));
-    connect(m_api, SIGNAL(messagesSearchMessages(qint64,QList<Message>,QList<Chat>,QList<User>)), this, SLOT(onMessagesSearchMessages(qint64,QList<Message>,QList<Chat>,QList<User>)));
-    connect(m_api, SIGNAL(messagesSearchMessagesSlice(qint64,qint32,QList<Message>,QList<Chat>,QList<User>)), this, SIGNAL(messagesSearchAnswer(qint64,qint32,QList<Message>,QList<Chat>,QList<User>)));
-    connect(m_api, SIGNAL(messagesReadAffectedHistory(qint64,qint32,qint32,qint32)), this, SIGNAL(messagesReadHistoryAnswer(qint64,qint32,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesReadMessageContentsResult(qint64,QList<qint32>)), this, SIGNAL(messagesReadMessageContentsAnswer(qint64,QList<qint32>)));
-    connect(m_api, SIGNAL(messagesDeleteAffectedHistory(qint64,qint32,qint32,qint32)), this, SIGNAL(messagesDeleteHistoryAnswer(qint64,qint32,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesDeleteMessagesResult(qint64,QList<qint32>)), this, SIGNAL(messagesDeleteMessagesAnswer(qint64,QList<qint32>)));
-    connect(m_api, SIGNAL(messagesRestoreMessagesResult(qint64,QList<qint32>)), this, SIGNAL(messagesRestoreMessagesAnswer(qint64,QList<qint32>)));
-    connect(m_api, SIGNAL(messagesReceivedMessagesResult(qint64,QList<qint32>)), this, SIGNAL(messagesReceivedMessagesAnswer(qint64,QList<qint32>)));
-    connect(m_api, SIGNAL(messagesForwardMsgStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)), this, SLOT(onMessagesForwardMsgStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesForwardMsgStatedMessageLink(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)), this, SIGNAL(messagesForwardMessageAnswer(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesForwardMsgsStatedMessages(qint64,QList<Message>,QList<Chat>,QList<User>,qint32,qint32)), this, SLOT(onMessagesForwardMsgsStatedMessages(qint64,QList<Message>,QList<Chat>,QList<User>,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesForwardMsgsStatedMessagesLinks(qint64,QList<Message>,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)), this, SIGNAL(messagesForwardMessagesAnswer(qint64,QList<Message>,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesSendBroadcastStatedMessages(qint64,QList<Message>,QList<Chat>,QList<User>,qint32,qint32)), this, SLOT(onMessagesSendBroadcastStatedMessages(qint64,QList<Message>,QList<Chat>,QList<User>,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesSendBroadcastStatedMessagesLinks(qint64,QList<Message>,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)), this, SIGNAL(messagesSendBroadcastAnswer(qint64,QList<Message>,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesChats(qint64,QList<Chat>,QList<User>)), this, SIGNAL(messagesGetChatsAnswer(qint64,QList<Chat>,QList<User>)));
-    connect(m_api, SIGNAL(messagesChatFull(qint64,ChatFull,QList<Chat>,QList<User>)),
+    connect(mApi, SIGNAL(helpGetInviteTextAnswer(qint64,QString)), this, SIGNAL(helpGetInviteTextAnswer(qint64,QString)));
+    connect(mApi, SIGNAL(authCheckedPhone(qint64,bool,bool)), this, SIGNAL(authCheckPhoneAnswer(qint64,bool,bool)));
+    connect(mApi, SIGNAL(authCheckPhoneSent(qint64,QString)), this, SIGNAL(authCheckPhoneSent(qint64,QString)));
+    connect(mApi, SIGNAL(authSentCode(qint64,bool,QString,qint32,bool)), this, SLOT(onAuthSentCode(qint64,bool,QString,qint32,bool)));
+    connect(mApi, SIGNAL(authSentAppCode(qint64,bool,QString,qint32,bool)), this, SLOT(onAuthSentCode(qint64,bool,QString,qint32,bool)));
+    connect(mApi, SIGNAL(authSendSmsResult(qint64,bool)), this, SIGNAL(authSendSmsAnswer(qint64,bool)));
+    connect(mApi, SIGNAL(authSendCallResult(qint64,bool)), this, SIGNAL(authSendCallAnswer(qint64,bool)));
+    connect(mApi, SIGNAL(authSignInAuthorization(qint64,qint32,User)), this, SLOT(onUserAuthorized(qint64,qint32,User)));
+    connect(mApi, SIGNAL(authSignUpAuthorization(qint64,qint32,User)), this, SLOT(onUserAuthorized(qint64,qint32,User)));
+    connect(mApi, SIGNAL(authLogOutResult(qint64,bool)), this, SLOT(onAuthLogOutAnswer(qint64,bool)));
+    connect(mApi, SIGNAL(authSendInvitesResult(qint64,bool)), this, SIGNAL(authSendInvitesAnswer(qint64,bool)));
+    connect(mApi, SIGNAL(authResetAuthorizationsResult(qint64,bool)), this, SIGNAL(authResetAuthorizationsAnswer(qint64,bool)));
+    connect(mApi, SIGNAL(accountRegisterDeviceResult(qint64,bool)), this, SIGNAL(accountRegisterDeviceAnswer(qint64,bool)));
+    connect(mApi, SIGNAL(accountUnregisterDeviceResult(qint64,bool)), this, SIGNAL(accountUnregisterDeviceAnswer(qint64,bool)));
+    connect(mApi, SIGNAL(accountUpdateNotifySettingsResult(qint64,bool)), this, SIGNAL(accountUpdateNotifySettingsAnswer(qint64,bool)));
+    connect(mApi, SIGNAL(accountPeerNotifySettings(qint64,PeerNotifySettings)), this, SIGNAL(accountGetNotifySettingsAnswer(qint64,PeerNotifySettings)));
+    connect(mApi, SIGNAL(accountResetNotifySettingsResult(qint64,bool)), this, SIGNAL(accountResetNotifySettingsAnswer(qint64,bool)));
+    connect(mApi, SIGNAL(accountUser(qint64,User)), this, SIGNAL(accountUpdateProfileAnswer(qint64,User)));
+    connect(mApi, SIGNAL(accountUpdateStatusResult(qint64,bool)), this, SIGNAL(accountUpdateStatusAnswer(qint64,bool)));
+    connect(mApi, SIGNAL(accountGetWallPapersResult(qint64,QList<WallPaper>)), this, SIGNAL(accountGetWallPapersAnswer(qint64,QList<WallPaper>)));
+    connect(mApi, SIGNAL(photosPhoto(qint64,Photo,QList<User>)), this, SIGNAL(photosUploadProfilePhotoAnswer(qint64,Photo,QList<User>)));
+    connect(mApi, SIGNAL(photosUserProfilePhoto(qint64,UserProfilePhoto)), this, SIGNAL(photosUpdateProfilePhotoAnswer(qint64,UserProfilePhoto)));
+    connect(mApi, SIGNAL(usersGetUsersResult(qint64,QList<User>)), this, SIGNAL(usersGetUsersAnswer(qint64,QList<User>)));
+    connect(mApi, SIGNAL(userFull(qint64,User,ContactsLink,Photo,PeerNotifySettings,bool,QString,QString)), this, SIGNAL(usersGetFullUserAnswer(qint64,User,ContactsLink,Photo,PeerNotifySettings,bool,QString,QString)));
+    connect(mApi, SIGNAL(photosPhotos(qint64,QList<Photo>,QList<User>)), this, SLOT(onPhotosPhotos(qint64, QList<Photo>, QList<User>)));
+    connect(mApi, SIGNAL(photosPhotosSlice(qint64,qint32,QList<Photo>,QList<User>)), this, SIGNAL(photosGetUserPhotosAnswer(qint64,qint32,QList<Photo>,QList<User>)));
+    connect(mApi, SIGNAL(contactsGetStatusesResult(qint64,QList<ContactStatus>)), this, SIGNAL(contactsGetStatusesAnswer(qint64,QList<ContactStatus>)));
+    connect(mApi, SIGNAL(contactsContacts(qint64,QList<Contact>,QList<User>)), this, SLOT(onContactsContacts(qint64,QList<Contact>,QList<User>)));
+    connect(mApi, SIGNAL(contactsContactsNotModified(qint64)), this, SLOT(onContactsContactsNotModified(qint64)));
+    connect(mApi, SIGNAL(contactsImportedContacts(qint64,QList<ImportedContact>,QList<qint64>,QList<User>)), this, SIGNAL(contactsImportContactsAnswer(qint64,QList<ImportedContact>,QList<qint64>,QList<User>)));
+    connect(mApi, SIGNAL(contactsImportedContacts(qint64,QList<ImportedContact>,QList<qint64>,QList<User>)), this, SLOT(onContactsImportContactsAnswer()));
+    connect(mApi, SIGNAL(contactsDeleteContactLink(qint64,ContactsMyLink,ContactsForeignLink,User)), this, SIGNAL(contactsDeleteContactAnswer(qint64,ContactsMyLink,ContactsForeignLink,User)));
+    connect(mApi, SIGNAL(contactsDeleteContactsResult(qint64,bool)), this, SIGNAL(contactsDeleteContactsAnswer(qint64,bool)));
+    connect(mApi, SIGNAL(contactsBlockResult(qint64,bool)), this, SIGNAL(contactsBlockAnswer(qint64,bool)));
+    connect(mApi, SIGNAL(contactsUnblockResult(qint64,bool)), this, SIGNAL(contactsUnblockAnswer(qint64,bool)));
+    connect(mApi, SIGNAL(contactsBlocked(qint64,QList<ContactBlocked>,QList<User>)), this, SLOT(onContactsBlocked(qint64,QList<ContactBlocked>,QList<User>)));
+    connect(mApi, SIGNAL(contactsBlockedSlice(qint64,qint32,QList<ContactBlocked>,QList<User>)), this, SIGNAL(contactsGetBlockedAnswer(qint64,qint32,QList<ContactBlocked>,QList<User>)));
+    connect(mApi, SIGNAL(messagesSentMessage(qint64,qint32,qint32,qint32,qint32)), this, SLOT(onMessagesSentMessage(qint64,qint32,qint32,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesSentMessageLink(qint64,qint32,qint32,qint32,qint32,QList<ContactsLink>)), this, SIGNAL(messagesSendMessageAnswer(qint64,qint32,qint32,qint32,qint32,QList<ContactsLink>)));
+    connect(mApi, SIGNAL(messagesSetTypingResult(qint64,bool)), this, SIGNAL(messagesSetTypingAnswer(qint64,bool)));
+    connect(mApi, SIGNAL(messagesGetMessagesMessages(qint64,QList<Message>,QList<Chat>,QList<User>)), this, SLOT(onMessagesGetMessagesMessages(qint64,QList<Message>,QList<Chat>,QList<User>)));
+    connect(mApi, SIGNAL(messagesGetMessagesMessagesSlice(qint64,qint32,QList<Message>,QList<Chat>,QList<User>)), this, SIGNAL(messagesGetMessagesAnswer(qint64,qint32,QList<Message>,QList<Chat>,QList<User>)));
+    connect(mApi, SIGNAL(messagesDialogs(qint64, QList<Dialog>,QList<Message>,QList<Chat>,QList<User>)), this, SLOT(onMessagesDialogs(qint64,QList<Dialog>,QList<Message>,QList<Chat>,QList<User>)));
+    connect(mApi, SIGNAL(messagesDialogsSlice(qint64,qint32,QList<Dialog>,QList<Message>,QList<Chat>,QList<User>)), this, SIGNAL(messagesGetDialogsAnswer(qint64,qint32,QList<Dialog>,QList<Message>,QList<Chat>,QList<User>)));
+    connect(mApi, SIGNAL(messagesGetHistoryMessages(qint64,QList<Message>,QList<Chat>,QList<User>)), this, SLOT(onMessagesGetHistoryMessages(qint64,QList<Message>,QList<Chat>,QList<User>)));
+    connect(mApi, SIGNAL(messagesGetHistoryMessagesSlice(qint64,qint32,QList<Message>,QList<Chat>,QList<User>)), this, SIGNAL(messagesGetHistoryAnswer(qint64,qint32,QList<Message>,QList<Chat>,QList<User>)));
+    connect(mApi, SIGNAL(messagesSearchMessages(qint64,QList<Message>,QList<Chat>,QList<User>)), this, SLOT(onMessagesSearchMessages(qint64,QList<Message>,QList<Chat>,QList<User>)));
+    connect(mApi, SIGNAL(messagesSearchMessagesSlice(qint64,qint32,QList<Message>,QList<Chat>,QList<User>)), this, SIGNAL(messagesSearchAnswer(qint64,qint32,QList<Message>,QList<Chat>,QList<User>)));
+    connect(mApi, SIGNAL(messagesReadAffectedHistory(qint64,qint32,qint32,qint32)), this, SIGNAL(messagesReadHistoryAnswer(qint64,qint32,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesReadMessageContentsResult(qint64,QList<qint32>)), this, SIGNAL(messagesReadMessageContentsAnswer(qint64,QList<qint32>)));
+    connect(mApi, SIGNAL(messagesDeleteAffectedHistory(qint64,qint32,qint32,qint32)), this, SIGNAL(messagesDeleteHistoryAnswer(qint64,qint32,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesDeleteMessagesResult(qint64,QList<qint32>)), this, SIGNAL(messagesDeleteMessagesAnswer(qint64,QList<qint32>)));
+    connect(mApi, SIGNAL(messagesRestoreMessagesResult(qint64,QList<qint32>)), this, SIGNAL(messagesRestoreMessagesAnswer(qint64,QList<qint32>)));
+    connect(mApi, SIGNAL(messagesReceivedMessagesResult(qint64,QList<qint32>)), this, SIGNAL(messagesReceivedMessagesAnswer(qint64,QList<qint32>)));
+    connect(mApi, SIGNAL(messagesForwardMsgStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)), this, SLOT(onMessagesForwardMsgStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesForwardMsgStatedMessageLink(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)), this, SIGNAL(messagesForwardMessageAnswer(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesForwardMsgsStatedMessages(qint64,QList<Message>,QList<Chat>,QList<User>,qint32,qint32)), this, SLOT(onMessagesForwardMsgsStatedMessages(qint64,QList<Message>,QList<Chat>,QList<User>,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesForwardMsgsStatedMessagesLinks(qint64,QList<Message>,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)), this, SIGNAL(messagesForwardMessagesAnswer(qint64,QList<Message>,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesSendBroadcastStatedMessages(qint64,QList<Message>,QList<Chat>,QList<User>,qint32,qint32)), this, SLOT(onMessagesSendBroadcastStatedMessages(qint64,QList<Message>,QList<Chat>,QList<User>,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesSendBroadcastStatedMessagesLinks(qint64,QList<Message>,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)), this, SIGNAL(messagesSendBroadcastAnswer(qint64,QList<Message>,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesChats(qint64,QList<Chat>,QList<User>)), this, SIGNAL(messagesGetChatsAnswer(qint64,QList<Chat>,QList<User>)));
+    connect(mApi, SIGNAL(messagesChatFull(qint64,ChatFull,QList<Chat>,QList<User>)),
              this, SIGNAL(messagesGetFullChatAnswer(qint64,ChatFull,QList<Chat>,QList<User>)));
-    connect(m_api, SIGNAL(messagesEditChatTitleStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)), this, SLOT(onMessagesEditChatTitleStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesEditChatTitleStatedMessageLink(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)), this, SIGNAL(messagesEditChatTitleAnswer(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesEditChatPhotoStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)), this, SLOT(onMessagesEditChatPhotoStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesEditChatPhotoStatedMessageLink(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)), this, SIGNAL(messagesEditChatPhotoAnswer(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesAddChatUserStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)), this, SLOT(onMessagesAddChatUserStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesAddChatUserStatedMessageLink(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)), this, SIGNAL(messagesAddChatUserAnswer(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesDeleteChatUserStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)), this, SLOT(onMessagesDeleteChatUserStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesDeleteChatUserStatedMessageLink(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)), this, SIGNAL(messagesDeleteChatUserAnswer(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesCreateChatStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)), this, SLOT(onMessagesCreateChatStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)));
-    connect(m_api, SIGNAL(messagesCreateChatStatedMessageLink(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)), this, SIGNAL(messagesCreateChatAnswer(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesEditChatTitleStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)), this, SLOT(onMessagesEditChatTitleStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesEditChatTitleStatedMessageLink(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)), this, SIGNAL(messagesEditChatTitleAnswer(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesEditChatPhotoStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)), this, SLOT(onMessagesEditChatPhotoStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesEditChatPhotoStatedMessageLink(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)), this, SIGNAL(messagesEditChatPhotoAnswer(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesAddChatUserStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)), this, SLOT(onMessagesAddChatUserStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesAddChatUserStatedMessageLink(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)), this, SIGNAL(messagesAddChatUserAnswer(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesDeleteChatUserStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)), this, SLOT(onMessagesDeleteChatUserStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesDeleteChatUserStatedMessageLink(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)), this, SIGNAL(messagesDeleteChatUserAnswer(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesCreateChatStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)), this, SLOT(onMessagesCreateChatStatedMessage(qint64,Message,QList<Chat>,QList<User>,qint32,qint32)));
+    connect(mApi, SIGNAL(messagesCreateChatStatedMessageLink(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)), this, SIGNAL(messagesCreateChatAnswer(qint64,Message,QList<Chat>,QList<User>,QList<ContactsLink>,qint32,qint32)));
     // secret chats
-    connect(m_api, SIGNAL(messagesDhConfig(qint64,qint32,QByteArray,qint32,QByteArray)), this, SLOT(onMessagesDhConfig(qint64,qint32,QByteArray,qint32,QByteArray)));
-    connect(m_api, SIGNAL(messagesDhConfigNotModified(qint64,QByteArray)), this, SLOT(onMessagesDhConfigNotModified(qint64,QByteArray)));
-    connect(m_api, SIGNAL(messagesRequestEncryptionEncryptedChat(qint64,EncryptedChat)), this, SLOT(onMessagesRequestEncryptionEncryptedChat(qint64,EncryptedChat)));
-    connect(m_api, SIGNAL(messagesAcceptEncryptionEncryptedChat(qint64,EncryptedChat)), this, SLOT(onMessagesAcceptEncryptionEncryptedChat(qint64,EncryptedChat)));
-    connect(m_api, SIGNAL(messagesDiscardEncryptionResult(qint64,bool)), this, SLOT(onMessagesDiscardEncryptionResult(qint64,bool)));
-    connect(m_api, SIGNAL(messagesReadEncryptedHistoryResult(qint64,bool)), this, SIGNAL(messagesReadEncryptedHistoryAnswer(qint64,bool)));
-    connect(m_api, SIGNAL(messagesSendEncryptedSentEncryptedMessage(qint64,qint32)), this, SIGNAL(messagesSendEncryptedAnswer(qint64,qint32)));
-    connect(m_api, SIGNAL(messagesSendEncryptedSentEncryptedFile(qint64,qint32,EncryptedFile)), this, SIGNAL(messagesSendEncryptedAnswer(qint64,qint32,EncryptedFile)));
-    connect(m_api, SIGNAL(messagesSendEncryptedFileSentEncryptedMessage(qint64,qint32)), this, SLOT(onMessagesSentEncryptedFile(qint64,qint32)));
-    connect(m_api, SIGNAL(messagesSendEncryptedFileSentEncryptedFile(qint64,qint32,EncryptedFile)), this, SLOT(onMessagesSentEncryptedFile(qint64,qint32,EncryptedFile)));
-    connect(m_api, SIGNAL(messagesSendEncryptedServiceSentEncryptedMessage(qint64,qint32)), this, SIGNAL(messagesSendEncryptedServiceAnswer(qint64,qint32)));
-    connect(m_api, SIGNAL(messagesSendEncryptedServiceSentEncryptedFile(qint64,qint32,EncryptedFile)), this, SIGNAL(messagesSendEncryptedServiceAnswer(qint64,qint32,EncryptedFile)));
-    connect(m_api, SIGNAL(updateShort(Update,qint32)), SLOT(onUpdateShort(Update)));
-    connect(m_api, SIGNAL(updatesCombined(QList<Update>,QList<User>,QList<Chat>,qint32,qint32,qint32)), SLOT(onUpdatesCombined(QList<Update>)));
-    connect(m_api, SIGNAL(updates(QList<Update>,QList<User>,QList<Chat>,qint32,qint32)), SLOT(onUpdates(QList<Update>)));
+    connect(mApi, SIGNAL(messagesDhConfig(qint64,qint32,QByteArray,qint32,QByteArray)), this, SLOT(onMessagesDhConfig(qint64,qint32,QByteArray,qint32,QByteArray)));
+    connect(mApi, SIGNAL(messagesDhConfigNotModified(qint64,QByteArray)), this, SLOT(onMessagesDhConfigNotModified(qint64,QByteArray)));
+    connect(mApi, SIGNAL(messagesRequestEncryptionEncryptedChat(qint64,EncryptedChat)), this, SLOT(onMessagesRequestEncryptionEncryptedChat(qint64,EncryptedChat)));
+    connect(mApi, SIGNAL(messagesAcceptEncryptionEncryptedChat(qint64,EncryptedChat)), this, SLOT(onMessagesAcceptEncryptionEncryptedChat(qint64,EncryptedChat)));
+    connect(mApi, SIGNAL(messagesDiscardEncryptionResult(qint64,bool)), this, SLOT(onMessagesDiscardEncryptionResult(qint64,bool)));
+    connect(mApi, SIGNAL(messagesReadEncryptedHistoryResult(qint64,bool)), this, SIGNAL(messagesReadEncryptedHistoryAnswer(qint64,bool)));
+    connect(mApi, SIGNAL(messagesSendEncryptedSentEncryptedMessage(qint64,qint32)), this, SIGNAL(messagesSendEncryptedAnswer(qint64,qint32)));
+    connect(mApi, SIGNAL(messagesSendEncryptedSentEncryptedFile(qint64,qint32,EncryptedFile)), this, SIGNAL(messagesSendEncryptedAnswer(qint64,qint32,EncryptedFile)));
+    connect(mApi, SIGNAL(messagesSendEncryptedServiceSentEncryptedMessage(qint64,qint32)), this, SIGNAL(messagesSendEncryptedServiceAnswer(qint64,qint32)));
+    connect(mApi, SIGNAL(messagesSendEncryptedServiceSentEncryptedFile(qint64,qint32,EncryptedFile)), this, SIGNAL(messagesSendEncryptedServiceAnswer(qint64,qint32,EncryptedFile)));
+    connect(mApi, SIGNAL(updateShort(Update,qint32)), SLOT(onUpdateShort(Update)));
+    connect(mApi, SIGNAL(updatesCombined(QList<Update>,QList<User>,QList<Chat>,qint32,qint32,qint32)), SLOT(onUpdatesCombined(QList<Update>)));
+    connect(mApi, SIGNAL(updates(QList<Update>,QList<User>,QList<Chat>,qint32,qint32)), SLOT(onUpdates(QList<Update>)));
     // updates
-    connect(m_api, SIGNAL(updatesState(qint64,qint32,qint32,qint32,qint32,qint32)), this, SIGNAL(updatesGetStateAnswer(qint64,qint32,qint32,qint32,qint32,qint32)));
-    connect(m_api, SIGNAL(updatesDifferenceEmpty(qint64,qint32,qint32)), this, SIGNAL(updatesGetDifferenceAnswer(qint64,qint32,qint32)));
-    connect(m_api, SIGNAL(updatesDifference(qint64,QList<Message>,QList<EncryptedMessage>,QList<Update>,QList<Chat>,QList<User>,UpdatesState)), this, SLOT(onUpdatesDifference(qint64,QList<Message>,QList<EncryptedMessage>,QList<Update>,QList<Chat>,QList<User>,UpdatesState)));
-    connect(m_api, SIGNAL(updatesDifferenceSlice(qint64,QList<Message>,QList<EncryptedMessage>,QList<Update>,QList<Chat>,QList<User>,UpdatesState)), this, SLOT(onUpdatesDifferenceSlice(qint64,QList<Message>,QList<EncryptedMessage>,QList<Update>,QList<Chat>,QList<User>,UpdatesState)));
-    connect(m_api, SIGNAL(uploadSaveFilePartResult(qint64,qint64,bool)), this, SLOT(onUploadSaveFilePartResult(qint64,qint64,bool)));
-    connect(m_api, SIGNAL(uploadSaveBigFilePartResult(qint64,qint64,bool)), this, SLOT(onUploadSaveFilePartResult(qint64,qint64,bool)));
-    connect(m_api, SIGNAL(uploadFile(qint64,StorageFileType,qint32,QByteArray)), this, SLOT(onUploadGetFileAnswer(qint64,StorageFileType,qint32,QByteArray)));
+    connect(mApi, SIGNAL(updatesState(qint64,qint32,qint32,qint32,qint32,qint32)), this, SIGNAL(updatesGetStateAnswer(qint64,qint32,qint32,qint32,qint32,qint32)));
+    connect(mApi, SIGNAL(updatesDifferenceEmpty(qint64,qint32,qint32)), this, SIGNAL(updatesGetDifferenceAnswer(qint64,qint32,qint32)));