tdesktop/Telegram/SourceFiles/mtproto/mtpConnection.h

486 lines
11 KiB
C++

/*
This file is part of Telegram Desktop,
the official desktop version of Telegram messaging app, see https://telegram.org
Telegram Desktop 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, either version 3 of the License, or
(at your option) any later version.
It 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.
Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
Copyright (c) 2014 John Preston, https://desktop.telegram.org
*/
#pragma once
#include "mtproto/mtpCoreTypes.h"
#include "mtproto/mtpScheme.h"
enum {
MTPDmessage_flag_unread = (1 << 0),
MTPDmessage_flag_out = (1 << 1),
MTPDmessage_flag_notify_by_from = (1 << 4),
MTPDmessage_flag_media_unread = (1 << 5),
MTPmessages_SendMessage_flag_skipWebPage = (1 << 1),
};
#include "mtproto/mtpPublicRSA.h"
#include "mtproto/mtpAuthKey.h"
inline bool mtpRequestData::isSentContainer(const mtpRequest &request) { // "request-like" wrap for msgIds vector
if (request->size() < 9) return false;
return (!request->msDate && !(*request)[6]); // msDate = 0, seqNo = 0
}
inline bool mtpRequestData::isStateRequest(const mtpRequest &request) {
if (request->size() < 9) return false;
return (mtpTypeId((*request)[8]) == mtpc_msgs_state_req);
}
inline bool mtpRequestData::needAck(const mtpRequest &request) {
if (request->size() < 9) return false;
return mtpRequestData::needAckByType((*request)[8]);
}
inline bool mtpRequestData::needAckByType(mtpTypeId type) {
switch (type) {
case mtpc_msg_container:
case mtpc_msgs_ack:
case mtpc_http_wait:
case mtpc_bad_msg_notification:
case mtpc_msgs_all_info:
case mtpc_msgs_state_info:
case mtpc_msg_detailed_info:
case mtpc_msg_new_detailed_info:
return false;
}
return true;
}
class MTProtoConnectionPrivate;
class MTPSessionData;
class MTPThread : public QThread {
Q_OBJECT
public:
MTPThread(QObject *parent = 0);
uint32 getThreadId() const;
private:
uint32 threadId;
};
class MTProtoConnection {
public:
enum ConnectionType {
TcpConnection,
HttpConnection
};
MTProtoConnection();
int32 start(MTPSessionData *data, int32 dc = 0); // return dc
void stop();
void stopped();
~MTProtoConnection();
enum {
Disconnected = 0,
Connecting = 1,
Connected = 2,
UpdateAlways = 666
};
int32 state() const;
QString transport() const;
/*template <typename TRequest> // not used
uint64 sendAsync(const TRequest &request) {
return data->sendAsync(request);
}*/
private:
QThread *thread;
MTProtoConnectionPrivate *data;
};
class MTPabstractConnection : public QObject {
Q_OBJECT
typedef QList<mtpBuffer> BuffersQueue;
public:
MTPabstractConnection() : _sentEncrypted(false) {
}
void setSentEncrypted() {
_sentEncrypted = true;
}
virtual void sendData(mtpBuffer &buffer) = 0; // has size + 3, buffer[0] = len, buffer[1] = packetnum, buffer[last] = crc32
virtual void disconnectFromServer() = 0;
virtual void connectToServer(const QString &addr, int32 port) = 0;
virtual bool isConnected() = 0;
virtual bool usingHttpWait() {
return false;
}
virtual bool needHttpWait() {
return false;
}
virtual int32 debugState() const = 0;
virtual QString transport() const = 0;
BuffersQueue &received() {
return receivedQueue;
}
signals:
void receivedData();
void receivedSome(); // to stop restart timer
void error(bool maybeBadKey = false);
void connected();
void disconnected();
protected:
BuffersQueue receivedQueue; // list of received packets, not processed yet
bool _sentEncrypted;
};
class MTPabstractTcpConnection : public MTPabstractConnection {
Q_OBJECT
public:
MTPabstractTcpConnection();
public slots:
void socketRead();
protected:
QTcpSocket sock;
uint32 packetNum; // sent packet number
uint32 packetRead, packetLeft; // reading from socket
bool readingToShort;
char *currentPos;
mtpBuffer longBuffer;
mtpPrime shortBuffer[MTPShortBufferSize];
virtual void socketPacket(mtpPrime *packet, uint32 packetSize) = 0;
};
class MTPautoConnection : public MTPabstractTcpConnection {
Q_OBJECT
public:
MTPautoConnection(QThread *thread);
void sendData(mtpBuffer &buffer);
void disconnectFromServer();
void connectToServer(const QString &addr, int32 port);
bool isConnected();
bool usingHttpWait();
bool needHttpWait();
int32 debugState() const;
QString transport() const;
public slots:
void socketError(QAbstractSocket::SocketError e);
void requestFinished(QNetworkReply *reply);
void onSocketConnected();
void onSocketDisconnected();
void onHttpStart();
void onTcpTimeoutTimer();
protected:
void socketPacket(mtpPrime *packet, uint32 packetSize);
private:
void tcpSend(mtpBuffer &buffer);
void httpSend(mtpBuffer &buffer);
enum Status {
WaitingBoth = 0,
WaitingHttp,
WaitingTcp,
HttpReady,
UsingHttp,
UsingTcp,
FinishedWork
};
Status status;
MTPint128 tcpNonce, httpNonce;
QTimer httpStartTimer;
QNetworkAccessManager manager;
QUrl address;
typedef QSet<QNetworkReply*> Requests;
Requests requests;
QString _addr;
int32 _port, _tcpTimeout;
QTimer tcpTimeoutTimer;
};
class MTPtcpConnection : public MTPabstractTcpConnection {
Q_OBJECT
public:
MTPtcpConnection(QThread *thread);
void sendData(mtpBuffer &buffer);
void disconnectFromServer();
void connectToServer(const QString &addr, int32 port);
bool isConnected();
int32 debugState() const;
QString transport() const;
public slots:
void socketError(QAbstractSocket::SocketError e);
protected:
void socketPacket(mtpPrime *packet, uint32 packetSize);
};
class MTPhttpConnection : public MTPabstractConnection {
Q_OBJECT
public:
MTPhttpConnection(QThread *thread);
void sendData(mtpBuffer &buffer);
void disconnectFromServer();
void connectToServer(const QString &addr, int32 port);
bool isConnected();
bool usingHttpWait();
bool needHttpWait();
int32 debugState() const;
QString transport() const;
public slots:
void requestFinished(QNetworkReply *reply);
private:
QNetworkAccessManager manager;
QUrl address;
typedef QSet<QNetworkReply*> Requests;
Requests requests;
};
class MTProtoConnectionPrivate : public QObject {
Q_OBJECT
public:
MTProtoConnectionPrivate(QThread *thread, MTProtoConnection *owner, MTPSessionData *data, uint32 dc);
~MTProtoConnectionPrivate();
void stop();
int32 getDC() const;
int32 getState() const;
QString transport() const;
signals:
void needToReceive();
void needToRestart();
void stateChanged(qint32 newState);
void sessionResetDone();
void needToSendAsync();
void sendAnythingAsync(quint64 msWait);
void sendHttpWaitAsync();
void sendPongAsync(quint64 msgId, quint64 pingId);
void sendMsgsStateInfoAsync(quint64 msgId, QByteArray data);
void resendAsync(quint64 msgId, quint64 msCanWait, bool forceContainer, bool sendMsgStateInfo);
void resendManyAsync(QVector<quint64> msgIds, quint64 msCanWait, bool forceContainer, bool sendMsgStateInfo);
void resendAllAsync();
public slots:
void retryByTimer();
void restartNow();
void restart(bool maybeBadKey = false);
void onPingSender();
void onPingSendForce();
void onBadConnection();
void onOldConnection();
void onSentSome(uint64 size);
void onReceivedSome();
void onError(bool maybeBadKey = false);
void onReadyData();
void socketStart(bool afterConfig = false);
void onConnected();
void doDisconnect();
void doFinish();
// Auth key creation packet receive slots
void pqAnswered();
void dhParamsAnswered();
void dhClientParamsAnswered();
// General packet receive slot, connected to conn->receivedData signal
void handleReceived();
// Sessions signals, when we need to send something
void tryToSend();
bool updateAuthKey();
void onConfigLoaded();
private:
void createConn();
mtpMsgId placeToContainer(mtpRequest &toSendRequest, mtpMsgId &bigMsgId, mtpMsgId *&haveSentArr, mtpRequest &req);
mtpMsgId prepareToSend(mtpRequest &request, mtpMsgId currentLastId);
mtpMsgId replaceMsgId(mtpRequest &request, mtpMsgId newId);
bool sendRequest(mtpRequest &request, bool needAnyResponse);
mtpRequestId wasSent(mtpMsgId msgId) const;
int32 handleOneReceived(const mtpPrime *from, const mtpPrime *end, uint64 msgId, int32 serverTime, uint64 serverSalt, bool badTime);
mtpBuffer ungzip(const mtpPrime *from, const mtpPrime *end) const;
void handleMsgsStates(const QVector<MTPlong> &ids, const string &states, QVector<MTPlong> &acked);
void clearMessages();
bool setState(int32 state, int32 ifState = MTProtoConnection::UpdateAlways);
mutable QReadWriteLock stateMutex;
int32 _state;
bool _needSessionReset;
void resetSession();
uint32 dc;
MTProtoConnection *_owner;
MTPabstractConnection *conn;
SingleTimer retryTimer; // exp retry timer
uint32 retryTimeout;
quint64 retryWillFinish;
SingleTimer oldConnectionTimer;
bool oldConnection;
SingleTimer connCheckTimer;
uint32 receiveDelay;
int64 firstSentAt;
QVector<MTPlong> ackRequestData, resendRequestData;
// if badTime received - search for ids in sessionData->haveSent and sessionData->wereAcked and sync time/salt, return true if found
bool requestsFixTimeSalt(const QVector<MTPlong> &ids, int32 serverTime, uint64 serverSalt);
// remove msgs with such ids from sessionData->haveSent, add to sessionData->wereAcked
void requestsAcked(const QVector<MTPlong> &ids, bool byResponse = false);
mtpPingId _pingId, _pingIdToSend;
uint64 _pingSendAt;
mtpMsgId _pingMsgId;
SingleTimer _pingSender;
void resend(quint64 msgId, quint64 msCanWait = 0, bool forceContainer = false, bool sendMsgStateInfo = false);
void resendMany(QVector<quint64> msgIds, quint64 msCanWait = 0, bool forceContainer = false, bool sendMsgStateInfo = false);
template <typename TRequest>
void sendRequestNotSecure(const TRequest &request);
template <typename TResponse>
bool readResponseNotSecure(TResponse &response);
bool restarted;
uint64 keyId;
QReadWriteLock sessionDataMutex;
MTPSessionData *sessionData;
bool myKeyLock;
void lockKey();
void unlockKey();
// Auth key creation fields and methods
struct AuthKeyCreateData {
AuthKeyCreateData()
: new_nonce(*(MTPint256*)((uchar*)new_nonce_buf))
, auth_key_aux_hash(*(MTPlong*)((uchar*)new_nonce_buf + 33))
, retries(0)
, g(0)
, req_num(0)
, msgs_sent(0) {
memset(new_nonce_buf, 0, sizeof(new_nonce_buf));
memset(aesKey, 0, sizeof(aesKey));
memset(aesIV, 0, sizeof(aesIV));
memset(auth_key, 0, sizeof(auth_key));
}
MTPint128 nonce, server_nonce;
uchar new_nonce_buf[41]; // 32 bytes new_nonce + 1 check byte + 8 bytes of auth_key_aux_hash
MTPint256 &new_nonce;
MTPlong &auth_key_aux_hash;
uint32 retries;
MTPlong retry_id;
int32 g;
uchar aesKey[32], aesIV[32];
uint32 auth_key[64];
MTPlong auth_key_hash;
uint32 req_num; // sent not encrypted request number
uint32 msgs_sent;
};
struct AuthKeyCreateStrings {
QByteArray dh_prime;
QByteArray g_a;
};
AuthKeyCreateData *authKeyData;
AuthKeyCreateStrings *authKeyStrings;
void dhClientParamsSend();
void authKeyCreated();
void clearAuthKeyData();
};