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.

319 lines
11 KiB

5 years ago
import AppStorage from '../storage';
import { MTPNetworker } from './networker';
import { bytesFromHex, bytesToHex, isObject } from '../bin_utils';
5 years ago
import networkerFactory from './networkerFactory';
import { telegramMeWebService } from './mtproto';
import authorizer from './authorizer';
import {App, Modes} from './mtproto_config';
5 years ago
import dcConfigurator from './dcConfigurator';
import HTTP from './transports/http';
4 years ago
import { logger } from '../logger';
/// #if !MTPROTO_WORKER
import { $rootScope } from '../utils';
import { InvokeApiOptions } from '../../types';
/// #endif
//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
}>;
5 years ago
export class ApiManager {
public cachedNetworkers: {[x: number]: MTPNetworker} = {};
public cachedUploadNetworkers: {[x: number]: MTPNetworker} = {};
public cachedExportPromise: {[x: number]: Promise<unknown>} = {};
private gettingNetworkers: {[dcIDAndType: string]: Promise<MTPNetworker>} = {};
public baseDcID = 0;
public telegramMeNotified = false;
private log: ReturnType<typeof logger> = logger('API');
constructor() {
//MtpSingleInstanceService.start();
/* AppStorage.get<number>('dc').then((dcID) => {
if(dcID) {
this.baseDcID = dcID;
}
}); */
}
public telegramMeNotify(newValue: boolean) {
if(this.telegramMeNotified !== newValue) {
this.telegramMeNotified = newValue;
telegramMeWebService.setAuthorized(this.telegramMeNotified);
}
}
// mtpSetUserAuth
public setUserAuth(userAuth: {id: number}) {
var fullUserAuth = Object.assign({dcID: this.baseDcID}, userAuth);
AppStorage.set({
dc: this.baseDcID,
user_auth: fullUserAuth
});
this.telegramMeNotify(true);
/// #if !MTPROTO_WORKER
5 years ago
$rootScope.$broadcast('user_auth', fullUserAuth);
/// #endif
5 years ago
}
public setBaseDcID(dcID: number) {
this.baseDcID = dcID;
}
5 years ago
// mtpLogOut
public async logOut() {
let storageKeys: Array<string> = [];
let prefix = Modes.test ? 't_dc' : 'dc';
5 years ago
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
let storageResult = await AppStorage.get<string[]|boolean[]>(storageKeys);
let logoutPromises = [];
for(let i = 0; i < storageResult.length; i++) {
if(storageResult[i]) {
logoutPromises.push(this.invokeApi('auth.logOut', {}, {dcID: i + 1, ignoreErrors: true}));
}
}
return Promise.all(logoutPromises).then(() => {
}, (error) => {
error.handled = true;
}).finally(() => {
this.baseDcID = 0;
5 years ago
this.telegramMeNotify(false);
AppStorage.clear();
})/* .then(() => {
location.pathname = '/';
}) */;
5 years ago
}
// mtpGetNetworker
public async getNetworker(dcID: number, options: InvokeApiOptions): Promise<MTPNetworker> {
const upload = (options.fileUpload || options.fileDownload)
&& (dcConfigurator.chooseServer(dcID, true) instanceof HTTP || Modes.multipleConnections);
const cache = upload ? this.cachedUploadNetworkers : this.cachedNetworkers;
5 years ago
if(!dcID) {
throw new Error('get Networker without dcID');
}
if(cache[dcID] !== undefined) {
return cache[dcID];
}
const getKey = dcID + '-' + +upload;
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] = AppStorage.get<string[]/* |boolean[] */>([ak, akID, ss])
.then(async([authKeyHex, authKeyIDHex, serverSaltHex]) => {
/* if(authKeyHex && !authKeyIDHex && serverSaltHex) {
5 years ago
this.log.warn('Updating to new version (+akID)');
await AppStorage.remove(ak, akID, ss);
authKeyHex = serverSaltHex = '';
} */
5 years ago
let networker: MTPNetworker;
5 years ago
if(authKeyHex && authKeyHex.length == 512) {
if(!serverSaltHex || serverSaltHex.length != 16) {
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, 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)
};
AppStorage.set(storeObj);
networker = networkerFactory.getNetworker(dcID, auth.authKey, auth.authKeyID, auth.serverSalt, options);
} catch(error) {
this.log('Get networker error', error, error.stack);
delete this.gettingNetworkers[getKey];
throw error;
}
5 years ago
}
delete this.gettingNetworkers[getKey];
return cache[dcID] = networker;
5 years ago
});
}
// mtpInvokeApi
public invokeApi(method: string, params: any = {}, options: InvokeApiOptions = {}) {
5 years ago
///////this.log('Invoke api', method, params, options);
5 years ago
return new Promise((resolve, reject) => {
let rejectPromise = (error: ApiError) => {
5 years ago
if(!error) {
error = {type: 'ERROR_EMPTY'};
} else if(!isObject(error)) {
5 years ago
error = {message: error};
}
reject(error);
if(error.code == 401 && error.type == 'SESSION_REVOKED') {
this.logOut();
}
5 years ago
if(options.ignoreErrors) {
return;
}
if(error.code == 406) {
error.handled = true;
}
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();
5 years ago
} else {
// ErrorService.show({error: error}); // WARNING
}
error.handled = true;
}
}, 100);
}
};
var dcID: number;
var cachedNetworker: MTPNetworker;
var stack = (new Error()).stack || 'empty stack';
var performRequest = (networker: MTPNetworker) => {
return (cachedNetworker = networker)
.wrapApiCall(method, params, options)
.then(resolve, (error: ApiError) => {
//if(!options.ignoreErrors) {
if(error.type != 'FILE_REFERENCE_EXPIRED') {
this.log.error('Error', error.code, error.type, this.baseDcID, dcID);
}
5 years ago
if(error.code == 401 && this.baseDcID == dcID) {
AppStorage.remove('dc', 'user_auth');
this.telegramMeNotify(false);
rejectPromise(error);
} else if(error.code == 401 && this.baseDcID && dcID != this.baseDcID) {
if(this.cachedExportPromise[dcID] === undefined) {
let promise = new Promise((exportResolve, exportReject) => {
this.invokeApi('auth.exportAuthorization', {dc_id: dcID}, {noErrorBox: true}).then((exportedAuth: any) => {
this.invokeApi('auth.importAuthorization', {
id: exportedAuth.id,
bytes: exportedAuth.bytes
}, {dcID: dcID, noErrorBox: true}).then(exportResolve, exportReject);
}, exportReject);
});
this.cachedExportPromise[dcID] = promise;
}
this.cachedExportPromise[dcID].then(() => {
(cachedNetworker = networker).wrapApiCall(method, params, options).then(resolve, rejectPromise);
}, rejectPromise);
} else if(error.code == 303) {
var newDcID = +error.type.match(/^(PHONE_MIGRATE_|NETWORK_MIGRATE_|USER_MIGRATE_)(\d+)/)[2];
5 years ago
if(newDcID != dcID) {
if(options.dcID) {
options.dcID = newDcID;
} else {
AppStorage.set({dc: this.baseDcID = newDcID});
}
this.getNetworker(newDcID, options).then((networker) => {
networker.wrapApiCall(method, params, options).then(resolve, rejectPromise);
}, rejectPromise);
}
} else if(!options.rawError && error.code == 420) {
var waitTime = +error.type.match(/^FLOOD_WAIT_(\d+)/)[1] || 10;
5 years ago
if(waitTime > (options.timeout !== undefined ? options.timeout : 60)) {
5 years ago
return rejectPromise(error);
}
setTimeout(() => {
performRequest(cachedNetworker);
}, waitTime/* (waitTime + 5) */ * 1000); // 03.02.2020
5 years ago
} else if(!options.rawError && (error.code == 500 || error.type == 'MSG_WAIT_FAILED')) {
var now = Date.now();
5 years ago
if(options.stopTime) {
if(now >= options.stopTime) {
return rejectPromise(error);
}
} else {
options.stopTime = now + (options.timeout !== undefined ? options.timeout : 10) * 1000;
}
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 {
AppStorage.get<number>('dc').then((baseDcID) => {
this.getNetworker(this.baseDcID = dcID = baseDcID || App.baseDcID, options).then(performRequest, rejectPromise);
5 years ago
});
}
});
}
// mtpGetUserID
public getUserID(): Promise<number> {
return AppStorage.get<any>('user_auth').then((auth) => {
this.telegramMeNotify(auth && auth.id > 0 || false);
return auth.id || 0;
});
}
}
export default new ApiManager();