Telegram Web K with changes to work inside I2P https://web.telegram.i2p/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

442 lines
14 KiB

/*
* https://github.com/morethanwords/tweb
* Copyright (C) 2019-2021 Eduard Kuzmenko
* https://github.com/morethanwords/tweb/blob/master/LICENSE
*
* Originally from:
* https://github.com/zhukov/webogram
* Copyright (C) 2014 Igor Zhukov <igor.beatle@gmail.com>
* https://github.com/zhukov/webogram/blob/master/LICENSE
*/
import sessionStorage from '../sessionStorage';
5 years ago
import MTPNetworker, { MTMessage } from './networker';
import { isObject } from './bin_utils';
5 years ago
import networkerFactory from './networkerFactory';
//import { telegramMeWebService } from './mtproto';
5 years ago
import authorizer from './authorizer';
import dcConfigurator, { ConnectionType, TransportType } from './dcConfigurator';
4 years ago
import { logger } from '../logger';
import type { InvokeApiOptions } from '../../types';
import type { MethodDeclMap } from '../../layer';
import { CancellablePromise, deferredPromise } from '../../helpers/cancellablePromise';
import { bytesFromHex, bytesToHex } from '../../helpers/bytes';
//import { clamp } from '../../helpers/number';
import { ctx, isSafari } from '../../helpers/userAgent';
4 years ago
import App from '../../config/app';
import { MOUNT_CLASS_TO } from '../../config/debug';
import IDBStorage from '../idb';
/// #if !MTPROTO_WORKER
import rootScope from '../rootScope';
/// #endif
/* var networker = apiManager.cachedNetworkers.websocket.upload[2];
networker.wrapMtpMessage({
_: 'msgs_state_req',
msg_ids: ["6888292542796810828"]
}, {
notContentRelated: true
}).then(res => {
console.log('status', res);
}); */
//console.error('apiManager included!');
// TODO: если запрос словил флуд, нужно сохранять его параметры и возвращать тот же промис на новый такой же запрос, например - загрузка истории
5 years ago
export type ApiError = Partial<{
code: number,
type: string,
description: string,
originalError: any,
stack: string,
handled: boolean,
input: string,
message: ApiError
}>;
/* class RotatableArray<T> {
public array: Array<T> = [];
private lastIndex = -1;
public get() {
this.lastIndex = clamp(this.lastIndex + 1, 0, this.array.length - 1);
return this.array[this.lastIndex];
}
} */
5 years ago
export class ApiManager {
public cachedNetworkers: {
[transportType in TransportType]: {
[connectionType in ConnectionType]: {
[dcId: number]: MTPNetworker[]
}
}
} = {} as any;
5 years ago
public cachedExportPromise: {[x: number]: Promise<unknown>} = {};
private gettingNetworkers: {[dcIdAndType: string]: Promise<MTPNetworker>} = {};
public baseDcId = 0;
5 years ago
//public telegramMeNotified = false;
5 years ago
private log: ReturnType<typeof logger> = logger('API');
private afterMessageTempIds: {[tempId: string]: string} = {};
//private lol = false;
5 years ago
constructor() {
//MtpSingleInstanceService.start();
/* AppStorage.get<number>('dc').then((dcId) => {
if(dcId) {
this.baseDcId = dcId;
5 years ago
}
}); */
}
/* public telegramMeNotify(newValue: boolean) {
5 years ago
if(this.telegramMeNotified !== newValue) {
this.telegramMeNotified = newValue;
//telegramMeWebService.setAuthorized(this.telegramMeNotified);
5 years ago
}
} */
5 years ago
// mtpSetUserAuth
public setUserAuth(userId: number) {
sessionStorage.set({
user_auth: userId
5 years ago
});
//this.telegramMeNotify(true);
/// #if !MTPROTO_WORKER
rootScope.broadcast('user_auth', userId);
/// #endif
5 years ago
}
public setBaseDcId(dcId: number) {
this.baseDcId = dcId;
sessionStorage.set({
dc: this.baseDcId
});
}
5 years ago
// mtpLogOut
public async logOut() {
const storageKeys: Array<string> = [];
5 years ago
const prefix = 'dc';
for(let dcId = 1; dcId <= 5; dcId++) {
storageKeys.push(prefix + dcId + '_auth_key');
//storageKeys.push(prefix + dcId + '_auth_keyId');
5 years ago
}
// WebPushApiManager.forceUnsubscribe(); // WARNING
const storageResult = await Promise.all(storageKeys.map(key => sessionStorage.get(key as any)));
5 years ago
const logoutPromises = [];
5 years ago
for(let i = 0; i < storageResult.length; i++) {
if(storageResult[i]) {
logoutPromises.push(this.invokeApi('auth.logOut', {}, {dcId: i + 1, ignoreErrors: true}));
5 years ago
}
}
const clear = () => {
//console.error('apiManager: logOut clear');
this.baseDcId = 0;
//this.telegramMeNotify(false);
IDBStorage.closeDatabases();
self.postMessage({type: 'clear'});
};
setTimeout(clear, 1e3);
//return;
return Promise.all(logoutPromises).then(() => {
}, (error) => {
error.handled = true;
}).finally(clear)/* .then(() => {
location.pathname = '/';
}) */;
5 years ago
}
// mtpGetNetworker
public getNetworker(dcId: number, options: InvokeApiOptions = {}): Promise<MTPNetworker> {
const connectionType: ConnectionType = options.fileDownload ? 'download' : (options.fileUpload ? 'upload' : 'client');
//const connectionType: ConnectionType = 'client';
/// #if MTPROTO_HTTP_UPLOAD
// @ts-ignore
4 years ago
const transportType: TransportType = connectionType === 'upload' && isSafari ? 'https' : 'websocket';
//const transportType: TransportType = connectionType !== 'client' ? 'https' : 'websocket';
/// #else
// @ts-ignore
const transportType = 'websocket';
/// #endif
if(!this.cachedNetworkers.hasOwnProperty(transportType)) {
this.cachedNetworkers[transportType] = {
client: {},
download: {},
upload: {}
};
}
const cache = this.cachedNetworkers[transportType][connectionType];
if(!(dcId in cache)) {
cache[dcId] = [];
}
5 years ago
const networkers = cache[dcId];
if(networkers.length >= /* 1 */(connectionType === 'client' || transportType === 'https' ? 1 : (connectionType === 'download' ? 3 : 3))) {
let i = networkers.length - 1, found = false;
for(; i >= 0; --i) {
if(networkers[i].isOnline) {
found = true;
break;
}
}
const networker = found ? networkers.splice(i, 1)[0] : networkers.pop();
networkers.unshift(networker);
return Promise.resolve(networker);
5 years ago
}
const getKey = [dcId, transportType, connectionType].join('-');
5 years ago
if(this.gettingNetworkers[getKey]) {
return this.gettingNetworkers[getKey];
}
const ak = 'dc' + dcId + '_auth_key';
const akId = 'dc' + dcId + '_auth_keyId';
const ss = 'dc' + dcId + '_server_salt';
5 years ago
return this.gettingNetworkers[getKey] = Promise.all([ak, akId, ss].map(key => sessionStorage.get(key as any)))
.then(async([authKeyHex, authKeyIdHex, serverSaltHex]) => {
const transport = dcConfigurator.chooseServer(dcId, connectionType, transportType, false);
let networker: MTPNetworker;
if(authKeyHex && authKeyHex.length === 512) {
if(!serverSaltHex || serverSaltHex.length !== 16) {
5 years ago
serverSaltHex = 'AAAAAAAAAAAAAAAA';
}
const authKey = bytesFromHex(authKeyHex);
const authKeyId = new Uint8Array(bytesFromHex(authKeyIdHex));
const serverSalt = bytesFromHex(serverSaltHex);
5 years ago
networker = networkerFactory.getNetworker(dcId, authKey, authKeyId, serverSalt, transport, options);
} else {
try { // if no saved state
const auth = await authorizer.auth(dcId);
const storeObj = {
[ak]: bytesToHex(auth.authKey),
[akId]: auth.authKeyId.hex,
[ss]: bytesToHex(auth.serverSalt)
};
sessionStorage.set(storeObj);
networker = networkerFactory.getNetworker(dcId, auth.authKey, auth.authKeyId, auth.serverSalt, transport, options);
} catch(error) {
this.log('Get networker error', error, error.stack);
delete this.gettingNetworkers[getKey];
throw error;
}
5 years ago
}
/* networker.onConnectionStatusChange = (online) => {
console.log('status:', online);
}; */
5 years ago
delete this.gettingNetworkers[getKey];
networkers.unshift(networker);
return networker;
5 years ago
});
}
// mtpInvokeApi
public invokeApi<T extends keyof MethodDeclMap>(method: T, params: MethodDeclMap[T]['req'] = {}, options: InvokeApiOptions = {}): CancellablePromise<MethodDeclMap[T]["res"]> {
5 years ago
///////this.log('Invoke api', method, params, options);
/* if(!this.lol) {
networkerFactory.updatesProcessor({_: 'new_session_created'}, true);
this.lol = true;
} */
const deferred = deferredPromise<MethodDeclMap[T]['res']>();
let afterMessageIdTemp = options.afterMessageId;
if(afterMessageIdTemp) {
deferred.finally(() => {
delete this.afterMessageTempIds[afterMessageIdTemp];
});
}
if(MOUNT_CLASS_TO) {
deferred.finally(() => {
clearInterval(interval);
});
const startTime = Date.now();
const interval = ctx.setInterval(() => {
this.log.error('Request is still processing:', method, params, options, 'time:', (Date.now() - startTime) / 1000);
//this.cachedUploadNetworkers[2].requestMessageStatus();
}, 5e3);
}
const rejectPromise = (error: ApiError) => {
if(!error) {
error = {type: 'ERROR_EMPTY'};
} else if(!isObject(error)) {
error = {message: error};
}
deferred.reject(error);
if((error.code === 401 && error.type === 'SESSION_REVOKED') ||
(error.code === 406 && error.type === 'AUTH_KEY_DUPLICATED')) {
this.logOut();
}
if(options.ignoreErrors) {
return;
}
5 years ago
if(error.code === 406) {
error.handled = true;
}
5 years ago
if(!options.noErrorBox) {
error.input = method;
error.stack = stack || (error.originalError && error.originalError.stack) || error.stack || (new Error()).stack;
setTimeout(() => {
if(!error.handled) {
if(error.code === 401) {
this.logOut();
} else {
// ErrorService.show({error: error}); // WARNING
}
error.handled = true;
}
}, 100);
}
};
let dcId: number;
let cachedNetworker: MTPNetworker;
let stack = (new Error()).stack || 'empty stack';
const performRequest = (networker: MTPNetworker) => {
if(afterMessageIdTemp) {
options.afterMessageId = this.afterMessageTempIds[afterMessageIdTemp];
}
const promise = (cachedNetworker = networker).wrapApiCall(method, params, options);
if(options.prepareTempMessageId) {
this.afterMessageTempIds[options.prepareTempMessageId] = (options as MTMessage).messageId;
}
return promise.then(deferred.resolve, (error: ApiError) => {
//if(!options.ignoreErrors) {
if(error.type !== 'FILE_REFERENCE_EXPIRED' && error.type !== 'MSG_WAIT_FAILED') {
this.log.error('Error', error.code, error.type, this.baseDcId, dcId, method, params);
}
if(error.code === 401 && this.baseDcId === dcId) {
if(error.type !== 'SESSION_PASSWORD_NEEDED') {
sessionStorage.delete('dc')
sessionStorage.delete('user_auth'); // ! возможно тут вообще не нужно это делать, но нужно проверить случай с USER_DEACTIVATED (https://core.telegram.org/api/errors)
//this.telegramMeNotify(false);
}
rejectPromise(error);
} else if(error.code === 401 && this.baseDcId && dcId !== this.baseDcId) {
if(this.cachedExportPromise[dcId] === undefined) {
const promise = new Promise((exportResolve, exportReject) => {
this.invokeApi('auth.exportAuthorization', {dc_id: dcId}, {noErrorBox: true}).then((exportedAuth) => {
this.invokeApi('auth.importAuthorization', {
id: exportedAuth.id,
bytes: exportedAuth.bytes
}, {dcId, noErrorBox: true}).then(exportResolve, exportReject);
}, exportReject);
});
this.cachedExportPromise[dcId] = promise;
}
5 years ago
this.cachedExportPromise[dcId].then(() => {
//(cachedNetworker = networker).wrapApiCall(method, params, options).then(deferred.resolve, rejectPromise);
this.invokeApi(method, params, options).then(deferred.resolve, rejectPromise);
}, rejectPromise);
} else if(error.code === 303) {
const newDcId = +error.type.match(/^(PHONE_MIGRATE_|NETWORK_MIGRATE_|USER_MIGRATE_|FILE_MIGRATE_)(\d+)/)[2];
if(newDcId !== dcId) {
if(options.dcId) {
options.dcId = newDcId;
} else {
this.setBaseDcId(newDcId);
5 years ago
}
this.getNetworker(newDcId, options).then((networker) => {
networker.wrapApiCall(method, params, options).then(deferred.resolve, rejectPromise);
5 years ago
}, rejectPromise);
}
} else if(!options.rawError && error.code === 420) {
const waitTime = +error.type.match(/^FLOOD_WAIT_(\d+)/)[1] || 10;
if(waitTime > (options.floodMaxTimeout !== undefined ? options.floodMaxTimeout : 60)) {
return rejectPromise(error);
}
setTimeout(() => {
performRequest(cachedNetworker);
}, waitTime/* (waitTime + 5) */ * 1000); // 03.02.2020
} else if(!options.rawError && error.code === 500) {
if(error.type === 'MSG_WAIT_FAILED') {
afterMessageIdTemp = undefined;
delete options.afterMessageId;
delete this.afterMessageTempIds[options.prepareTempMessageId];
performRequest(cachedNetworker);
return;
}
const now = Date.now();
if(options.stopTime) {
if(now >= options.stopTime) {
5 years ago
return rejectPromise(error);
}
}
options.waitTime = options.waitTime ? Math.min(60, options.waitTime * 1.5) : 1;
setTimeout(() => {
performRequest(cachedNetworker);
}, options.waitTime * 1000);
} else {
rejectPromise(error);
}
});
}
if(dcId = (options.dcId || this.baseDcId)) {
this.getNetworker(dcId, options).then(performRequest, rejectPromise);
} else {
sessionStorage.get('dc').then((baseDcId) => {
this.getNetworker(this.baseDcId = dcId = baseDcId || App.baseDcId, options).then(performRequest, rejectPromise);
});
}
return deferred;
5 years ago
}
}
const apiManager = new ApiManager();
MOUNT_CLASS_TO.apiManager = apiManager;
export default apiManager;