MGislv/NekoX
1
0
Fork 0
mirror of https://github.com/MGislv/NekoX.git synced 2024-07-02 10:33:36 +00:00
Code Releases Activity

Remove custom server

Browse Source
This commit is contained in:
世界 2021-01-12 10:57:16 +08:00
parent 7af2afc456
commit 60e0b895f6
No known key found for this signature in database
GPG Key ID: CD109927C34A63C4
11 changed files with 293 additions and 782 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

377
TMessagesProj/jni/TgNetWrapper.cpp
View File

@ -65,15 +65,16 @@ jobject getJavaByteBuffer(JNIEnv *env, jclass c, jlong address) {
static const char *NativeByteBufferClassPathName = "org/telegram/tgnet/NativeByteBuffer";
static JNINativeMethod NativeByteBufferMethods[] = {
{"native_getFreeBuffer", "(I)J", (void *) getFreeBuffer},
{"native_limit", "(J)I", (void *) limit},
{"native_position", "(J)I", (void *) position},
{"native_reuse", "(J)V", (void *) reuse},
{"native_getFreeBuffer", "(I)J", (void *) getFreeBuffer},
{"native_limit", "(J)I", (void *) limit},
{"native_position", "(J)I", (void *) position},
{"native_reuse", "(J)V", (void *) reuse},
{"native_getJavaByteBuffer", "(J)Ljava/nio/ByteBuffer;", (void *) getJavaByteBuffer}
};
jlong getCurrentTimeMillis(JNIEnv *env, jclass c, jint instanceNum) {
return ConnectionsManager::getInstance(instanceNum).getCurrentTimeMillis() + ((jlong) ConnectionsManager::getInstance(instanceNum).getTimeDifference()) * 1000;
return ConnectionsManager::getInstance(instanceNum).getCurrentTimeMillis() +
((jlong) ConnectionsManager::getInstance(instanceNum).getTimeDifference()) * 1000;
}
jint getCurrentTime(JNIEnv *env, jclass c, jint instanceNum) {
@ -92,7 +93,9 @@ jint getTimeDifference(JNIEnv *env, jclass c, jint instanceNum) {
return ConnectionsManager::getInstance(instanceNum).getTimeDifference();
}
void sendRequest(JNIEnv *env, jclass c, jint instanceNum, jlong object, jobject onComplete, jobject onQuickAck, jobject onWriteToSocket, jint flags, jint datacenterId, jint connetionType, jboolean immediate, jint token) {
void sendRequest(JNIEnv *env, jclass c, jint instanceNum, jlong object, jobject onComplete,
jobject onQuickAck, jobject onWriteToSocket, jint flags, jint datacenterId,
jint connetionType, jboolean immediate, jint token) {
TL_api_request *request = new TL_api_request();
request->request = (NativeByteBuffer *) (intptr_t) object;
if (onComplete != nullptr) {
@ -104,38 +107,42 @@ void sendRequest(JNIEnv *env, jclass c, jint instanceNum, jlong object, jobject
if (onWriteToSocket != nullptr) {
onWriteToSocket = env->NewGlobalRef(onWriteToSocket);
}
ConnectionsManager::getInstance(instanceNum).sendRequest(request, ([onComplete, instanceNum](TLObject *response, TL_error *error, int32_t networkType) {
TL_api_response *resp = (TL_api_response *) response;
jlong ptr = 0;
jint errorCode = 0;
jstring errorText = nullptr;
if (resp != nullptr) {
ptr = (jlong) resp->response.get();
} else if (error != nullptr) {
errorCode = error->code;
const char *text = error->text.c_str();
size_t size = error->text.size();
if (check_utf8(text, size)) {
errorText = jniEnv[instanceNum]->NewStringUTF(text);
} else {
errorText = jniEnv[instanceNum]->NewStringUTF("UTF-8 ERROR");
}
}
if (onComplete != nullptr) {
jniEnv[instanceNum]->CallVoidMethod(onComplete, jclass_RequestDelegateInternal_run, ptr, errorCode, errorText, networkType);
}
if (errorText != nullptr) {
jniEnv[instanceNum]->DeleteLocalRef(errorText);
}
}), ([onQuickAck, instanceNum] {
if (onQuickAck != nullptr) {
jniEnv[instanceNum]->CallVoidMethod(onQuickAck, jclass_QuickAckDelegate_run);
}
}), ([onWriteToSocket, instanceNum] {
if (onWriteToSocket != nullptr) {
jniEnv[instanceNum]->CallVoidMethod(onWriteToSocket, jclass_WriteToSocketDelegate_run);
}
}), (uint32_t) flags, (uint32_t) datacenterId, (ConnectionType) connetionType, immediate, token, onComplete, onQuickAck, onWriteToSocket);
ConnectionsManager::getInstance(instanceNum).sendRequest(request, ([onComplete, instanceNum](
TLObject *response, TL_error *error, int32_t networkType) {
TL_api_response *resp = (TL_api_response *) response;
jlong ptr = 0;
jint errorCode = 0;
jstring errorText = nullptr;
if (resp != nullptr) {
ptr = (jlong) resp->response.get();
} else if (error != nullptr) {
errorCode = error->code;
const char *text = error->text.c_str();
size_t size = error->text.size();
if (check_utf8(text, size)) {
errorText = jniEnv[instanceNum]->NewStringUTF(text);
} else {
errorText = jniEnv[instanceNum]->NewStringUTF("UTF-8 ERROR");
}
}
if (onComplete != nullptr) {
jniEnv[instanceNum]->CallVoidMethod(onComplete, jclass_RequestDelegateInternal_run, ptr,
errorCode, errorText, networkType);
}
if (errorText != nullptr) {
jniEnv[instanceNum]->DeleteLocalRef(errorText);
}
}), ([onQuickAck, instanceNum] {
if (onQuickAck != nullptr) {
jniEnv[instanceNum]->CallVoidMethod(onQuickAck, jclass_QuickAckDelegate_run);
}
}), ([onWriteToSocket, instanceNum] {
if (onWriteToSocket != nullptr) {
jniEnv[instanceNum]->CallVoidMethod(onWriteToSocket, jclass_WriteToSocketDelegate_run);
}
}), (uint32_t) flags, (uint32_t) datacenterId, (ConnectionType) connetionType, immediate, token,
onComplete, onQuickAck,
onWriteToSocket);
}
void cancelRequest(JNIEnv *env, jclass c, jint instanceNum, jint token, jboolean notifyServer) {
@ -154,66 +161,35 @@ void bindRequestToGuid(JNIEnv *env, jclass c, jint instanceNum, jint requestToke
return ConnectionsManager::getInstance(instanceNum).bindRequestToGuid(requestToken, guid);
}
void applyDatacenterAddress(JNIEnv *env, jclass c, jint instanceNum, jint datacenterId, jstring ipAddress, jint port) {
void applyDatacenterAddress(JNIEnv *env, jclass c, jint instanceNum, jint datacenterId,
jstring ipAddress, jint port) {
const char *valueStr = env->GetStringUTFChars(ipAddress, 0);
ConnectionsManager::getInstance(instanceNum).applyDatacenterAddress((uint32_t) datacenterId, std::string(valueStr), (uint32_t) port);
ConnectionsManager::getInstance(instanceNum).applyDatacenterAddress((uint32_t) datacenterId,
std::string(valueStr),
(uint32_t) port);
if (valueStr != 0) {
env->ReleaseStringUTFChars(ipAddress, valueStr);
}
}
void setDatacenterPublicKey(JNIEnv *env, jclass c, jint instanceNum, jint dataCenterId, jstring publicKey, jlong fingerprint) {
const char *publicKeyStr = env->GetStringUTFChars(publicKey, nullptr);
ConnectionsManager::getInstance(instanceNum).setDatacenterPublicKey(dataCenterId, publicKeyStr,fingerprint);
if (publicKeyStr != nullptr) {
env->ReleaseStringUTFChars(publicKey, publicKeyStr);
}
}
void setDatacenterAddress(JNIEnv *env, jclass c, jint instanceNum, jint datacenterId, jstring ipv4Address, jstring ipv6Address, jint port) {
const char *v4Str = env->GetStringUTFChars(ipv4Address, nullptr);
const char *v6Str = env->GetStringUTFChars(ipv4Address, nullptr);
ConnectionsManager::getInstance(instanceNum).setDatacenterAddress((uint32_t) datacenterId, std::string(v4Str), std::string(v6Str), (uint32_t) port);
if (v4Str != nullptr) {
env->ReleaseStringUTFChars(ipv4Address, v4Str);
}
if (v6Str != nullptr) {
env->ReleaseStringUTFChars(ipv6Address, v6Str);
}
}
void setLayer(JNIEnv *env, jclass c, jint instanceNum, jint layer) {
ConnectionsManager::getInstance(instanceNum).setLayer((uint32_t) layer);
}
void moveToDatacenter(JNIEnv *env, jclass c, jint instanceNum, jint datacenterId) {
ConnectionsManager::getInstance(instanceNum).moveToDatacenter((uint32_t) datacenterId);
}
void saveDatacenters(JNIEnv *env, jclass c,jint instanceNum) {
ConnectionsManager::getInstance(instanceNum).saveDatacenters();
}
void setProxySettings(JNIEnv *env, jclass c, jint instanceNum, jstring address, jint port, jstring username, jstring password, jstring secret) {
void setProxySettings(JNIEnv *env, jclass c, jint instanceNum, jstring address, jint port,
jstring username, jstring password, jstring secret) {
const char *addressStr = env->GetStringUTFChars(address, 0);
const char *usernameStr = env->GetStringUTFChars(username, 0);
const char *passwordStr = env->GetStringUTFChars(password, 0);
const char *secretStr = env->GetStringUTFChars(secret, 0);
ConnectionsManager::getInstance(instanceNum).setProxySettings(addressStr, (uint16_t) port, usernameStr, passwordStr, secretStr);
ConnectionsManager::getInstance(instanceNum).setProxySettings(addressStr, (uint16_t) port,
usernameStr, passwordStr,
secretStr);
if (addressStr != 0) {
env->ReleaseStringUTFChars(address, addressStr);
@ -257,7 +233,8 @@ void setUseIpv6(JNIEnv *env, jclass c, jint instanceNum, jboolean value) {
ConnectionsManager::getInstance(instanceNum).setUseIpv6(value);
}
void setNetworkAvailable(JNIEnv *env, jclass c, jint instanceNum, jboolean value, jint networkType, jboolean slow) {
void setNetworkAvailable(JNIEnv *env, jclass c, jint instanceNum, jboolean value, jint networkType,
jboolean slow) {
ConnectionsManager::getInstance(instanceNum).setNetworkAvailable(value, networkType, slow);
}
@ -265,16 +242,20 @@ void setPushConnectionEnabled(JNIEnv *env, jclass c, jint instanceNum, jboolean
ConnectionsManager::getInstance(instanceNum).setPushConnectionEnabled(value);
}
void applyDnsConfig(JNIEnv *env, jclass c, jint instanceNum, jlong address, jstring phone, jint date) {
void
applyDnsConfig(JNIEnv *env, jclass c, jint instanceNum, jlong address, jstring phone, jint date) {
const char *phoneStr = env->GetStringUTFChars(phone, 0);
ConnectionsManager::getInstance(instanceNum).applyDnsConfig((NativeByteBuffer *) (intptr_t) address, phoneStr, date);
ConnectionsManager::getInstance(instanceNum).applyDnsConfig(
(NativeByteBuffer *) (intptr_t) address, phoneStr, date);
if (phoneStr != 0) {
env->ReleaseStringUTFChars(phone, phoneStr);
}
}
jlong checkProxy(JNIEnv *env, jclass c, jint instanceNum, jstring address, jint port, jstring username, jstring password, jstring secret, jobject requestTimeFunc) {
jlong
checkProxy(JNIEnv *env, jclass c, jint instanceNum, jstring address, jint port, jstring username,
jstring password, jstring secret, jobject requestTimeFunc) {
const char *addressStr = env->GetStringUTFChars(address, 0);
const char *usernameStr = env->GetStringUTFChars(username, 0);
const char *passwordStr = env->GetStringUTFChars(password, 0);
@ -284,11 +265,20 @@ jlong checkProxy(JNIEnv *env, jclass c, jint instanceNum, jstring address, jint
requestTimeFunc = env->NewGlobalRef(requestTimeFunc);
}
jlong result = ConnectionsManager::getInstance(instanceNum).checkProxy(addressStr, (uint16_t) port, usernameStr, passwordStr, secretStr, [instanceNum, requestTimeFunc](int64_t time) {
if (requestTimeFunc != nullptr) {
jniEnv[instanceNum]->CallVoidMethod(requestTimeFunc, jclass_RequestTimeDelegate_run, time);
}
}, requestTimeFunc);
jlong result = ConnectionsManager::getInstance(instanceNum).checkProxy(addressStr,
(uint16_t) port,
usernameStr, passwordStr,
secretStr,
[instanceNum, requestTimeFunc](
int64_t time) {
if (requestTimeFunc !=
nullptr) {
jniEnv[instanceNum]->CallVoidMethod(
requestTimeFunc,
jclass_RequestTimeDelegate_run,
time);
}
}, requestTimeFunc);
if (addressStr != 0) {
env->ReleaseStringUTFChars(address, addressStr);
@ -309,67 +299,93 @@ jlong checkProxy(JNIEnv *env, jclass c, jint instanceNum, jstring address, jint
class Delegate : public ConnectiosManagerDelegate {
void onUpdate(int32_t instanceNum) {
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager, jclass_ConnectionsManager_onUpdate, instanceNum);
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager,
jclass_ConnectionsManager_onUpdate, instanceNum);
}
void onSessionCreated(int32_t instanceNum) {
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager, jclass_ConnectionsManager_onSessionCreated, instanceNum);
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager,
jclass_ConnectionsManager_onSessionCreated,
instanceNum);
}
void onConnectionStateChanged(ConnectionState state, int32_t instanceNum) {
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager, jclass_ConnectionsManager_onConnectionStateChanged, state, instanceNum);
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager,
jclass_ConnectionsManager_onConnectionStateChanged,
state, instanceNum);
}
void onUnparsedMessageReceived(int64_t reqMessageId, NativeByteBuffer *buffer, ConnectionType connectionType, int32_t instanceNum) {
void onUnparsedMessageReceived(int64_t reqMessageId, NativeByteBuffer *buffer,
ConnectionType connectionType, int32_t instanceNum) {
if (connectionType == ConnectionTypeGeneric) {
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager, jclass_ConnectionsManager_onUnparsedMessageReceived, (jlong) (intptr_t) buffer, instanceNum);
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager,
jclass_ConnectionsManager_onUnparsedMessageReceived,
(jlong) (intptr_t) buffer, instanceNum);
}
}
void onLogout(int32_t instanceNum) {
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager, jclass_ConnectionsManager_onLogout, instanceNum);
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager,
jclass_ConnectionsManager_onLogout, instanceNum);
}
void onUpdateConfig(TL_config *config, int32_t instanceNum) {
NativeByteBuffer *buffer = BuffersStorage::getInstance().getFreeBuffer(config->getObjectSize());
NativeByteBuffer *buffer = BuffersStorage::getInstance().getFreeBuffer(
config->getObjectSize());
config->serializeToStream(buffer);
buffer->position(0);
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager, jclass_ConnectionsManager_onUpdateConfig, (jlong) (intptr_t) buffer, instanceNum);
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager,
jclass_ConnectionsManager_onUpdateConfig,
(jlong) (intptr_t) buffer, instanceNum);
buffer->reuse();
}
void onInternalPushReceived(int32_t instanceNum) {
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager, jclass_ConnectionsManager_onInternalPushReceived, instanceNum);
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager,
jclass_ConnectionsManager_onInternalPushReceived,
instanceNum);
}
void onBytesReceived(int32_t amount, int32_t networkType, int32_t instanceNum) {
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager, jclass_ConnectionsManager_onBytesReceived, amount, networkType, instanceNum);
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager,
jclass_ConnectionsManager_onBytesReceived, amount,
networkType, instanceNum);
}
void onBytesSent(int32_t amount, int32_t networkType, int32_t instanceNum) {
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager, jclass_ConnectionsManager_onBytesSent, amount, networkType, instanceNum);
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager,
jclass_ConnectionsManager_onBytesSent, amount,
networkType, instanceNum);
}
void onRequestNewServerIpAndPort(int32_t second, int32_t instanceNum) {
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager, jclass_ConnectionsManager_onRequestNewServerIpAndPort, second, instanceNum);
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager,
jclass_ConnectionsManager_onRequestNewServerIpAndPort,
second, instanceNum);
}
void onProxyError(int32_t instanceNum) {
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager, jclass_ConnectionsManager_onProxyError, instanceNum);
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager,
jclass_ConnectionsManager_onProxyError,
instanceNum);
}
void getHostByName(std::string domain, int32_t instanceNum, ConnectionSocket *socket) {
jstring domainName = jniEnv[instanceNum]->NewStringUTF(domain.c_str());
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager, jclass_ConnectionsManager_getHostByName, domainName, (jlong) (intptr_t) socket);
jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager,
jclass_ConnectionsManager_getHostByName,
domainName, (jlong) (intptr_t) socket);
jniEnv[instanceNum]->DeleteLocalRef(domainName);
}
int32_t getInitFlags(int32_t instanceNum) {
return (int32_t) jniEnv[instanceNum]->CallStaticIntMethod(jclass_ConnectionsManager, jclass_ConnectionsManager_getInitFlags);
return (int32_t) jniEnv[instanceNum]->CallStaticIntMethod(jclass_ConnectionsManager,
jclass_ConnectionsManager_getInitFlags);
}
};
void onHostNameResolved(JNIEnv *env, jclass c, jstring host, jlong address, jstring ip,jboolean ipv6) {
void
onHostNameResolved(JNIEnv *env, jclass c, jstring host, jlong address, jstring ip, jboolean ipv6) {
const char *ipStr = env->GetStringUTFChars(ip, 0);
const char *hostStr = env->GetStringUTFChars(host, 0);
std::string i = std::string(ipStr);
@ -414,7 +430,11 @@ void setSystemLangCode(JNIEnv *env, jclass c, jint instanceNum, jstring langCode
}
}
void init(JNIEnv *env, jclass c, jint instanceNum, jint version, jint layer, jint apiId, jstring deviceModel, jstring systemVersion, jstring appVersion, jstring langCode, jstring systemLangCode, jstring configPath, jstring logPath, jstring regId, jstring cFingerprint, jstring installerId, jint timezoneOffset, jint userId, jboolean enablePushConnection, jboolean hasNetwork, jint networkType) {
void init(JNIEnv *env, jclass c, jint instanceNum, jint version, jint layer, jint apiId,
jstring deviceModel, jstring systemVersion, jstring appVersion, jstring langCode,
jstring systemLangCode, jstring configPath, jstring logPath, jstring regId,
jstring cFingerprint, jstring installerId, jint timezoneOffset, jint userId,
jboolean enablePushConnection, jboolean hasNetwork, jint networkType) {
const char *deviceModelStr = env->GetStringUTFChars(deviceModel, 0);
const char *systemVersionStr = env->GetStringUTFChars(systemVersion, 0);
const char *appVersionStr = env->GetStringUTFChars(appVersion, 0);
@ -426,7 +446,19 @@ void init(JNIEnv *env, jclass c, jint instanceNum, jint version, jint layer, jin
const char *cFingerprintStr = env->GetStringUTFChars(cFingerprint, 0);
const char *installerIdStr = env->GetStringUTFChars(installerId, 0);
ConnectionsManager::getInstance(instanceNum).init((uint32_t) version, layer, apiId, std::string(deviceModelStr), std::string(systemVersionStr), std::string(appVersionStr), std::string(langCodeStr), std::string(systemLangCodeStr), std::string(configPathStr), std::string(logPathStr), std::string(regIdStr), std::string(cFingerprintStr), std::string(installerIdStr), timezoneOffset, userId, true, enablePushConnection, hasNetwork, networkType);
ConnectionsManager::getInstance(instanceNum).init((uint32_t) version, layer, apiId,
std::string(deviceModelStr),
std::string(systemVersionStr),
std::string(appVersionStr),
std::string(langCodeStr),
std::string(systemLangCodeStr),
std::string(configPathStr),
std::string(logPathStr),
std::string(regIdStr),
std::string(cFingerprintStr),
std::string(installerIdStr), timezoneOffset,
userId, true, enablePushConnection,
hasNetwork, networkType);
if (deviceModelStr != 0) {
env->ReleaseStringUTFChars(deviceModel, deviceModelStr);
@ -469,43 +501,40 @@ void setJava(JNIEnv *env, jclass c, jboolean useJavaByteBuffers) {
static const char *ConnectionsManagerClassPathName = "org/telegram/tgnet/ConnectionsManager";
static JNINativeMethod ConnectionsManagerMethods[] = {
{"native_getCurrentTimeMillis", "(I)J", (void *) getCurrentTimeMillis},
{"native_getCurrentTime", "(I)I", (void *) getCurrentTime},
{"native_getCurrentDatacenterId", "(I)I", (void *) getCurrentDatacenterId},
{"native_isTestBackend", "(I)I", (void *) isTestBackend},
{"native_getTimeDifference", "(I)I", (void *) getTimeDifference},
{"native_sendRequest", "(IJLorg/telegram/tgnet/RequestDelegateInternal;Lorg/telegram/tgnet/QuickAckDelegate;Lorg/telegram/tgnet/WriteToSocketDelegate;IIIZI)V", (void *) sendRequest},
{"native_cancelRequest", "(IIZ)V", (void *) cancelRequest},
{"native_cleanUp", "(IZ)V", (void *) cleanUp},
{"native_cancelRequestsForGuid", "(II)V", (void *) cancelRequestsForGuid},
{"native_bindRequestToGuid", "(III)V", (void *) bindRequestToGuid},
{"native_applyDatacenterAddress", "(IILjava/lang/String;I)V", (void *) applyDatacenterAddress},
{"native_setDatacenterPublicKey", "(IILjava/lang/String;J)V", (void *) setDatacenterPublicKey},
{"native_setDatacenterAddress", "(IILjava/lang/String;Ljava/lang/String;I)V", (void *) setDatacenterAddress},
{"native_saveDatacenters", "(I)V", (void *) saveDatacenters},
{"native_setLayer", "(II)V", (void *) setLayer},
{"native_moveToDatacenter", "(II)V", (void *) moveToDatacenter},
{"native_setProxySettings", "(ILjava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V", (void *) setProxySettings},
{"native_getConnectionState", "(I)I", (void *) getConnectionState},
{"native_setUserId", "(II)V", (void *) setUserId},
{"native_init", "(IIIILjava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;IIZZI)V", (void *) init},
{"native_setLangCode", "(ILjava/lang/String;)V", (void *) setLangCode},
{"native_setRegId", "(ILjava/lang/String;)V", (void *) setRegId},
{"native_setSystemLangCode", "(ILjava/lang/String;)V", (void *) setSystemLangCode},
{"native_switchBackend", "(I)V", (void *) switchBackend},
{"native_pauseNetwork", "(I)V", (void *) pauseNetwork},
{"native_resumeNetwork", "(IZ)V", (void *) resumeNetwork},
{"native_updateDcSettings", "(I)V", (void *) updateDcSettings},
{"native_setUseIpv6", "(IZ)V", (void *) setUseIpv6},
{"native_setNetworkAvailable", "(IZIZ)V", (void *) setNetworkAvailable},
{"native_setPushConnectionEnabled", "(IZ)V", (void *) setPushConnectionEnabled},
{"native_setJava", "(Z)V", (void *) setJava},
{"native_applyDnsConfig", "(IJLjava/lang/String;I)V", (void *) applyDnsConfig},
{"native_checkProxy", "(ILjava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;Lorg/telegram/tgnet/RequestTimeDelegate;)J", (void *) checkProxy},
{"native_onHostNameResolved", "(Ljava/lang/String;JLjava/lang/String;Z)V", (void *) onHostNameResolved}
{"native_getCurrentTimeMillis", "(I)J", (void *) getCurrentTimeMillis},
{"native_getCurrentTime", "(I)I", (void *) getCurrentTime},
{"native_getCurrentDatacenterId", "(I)I", (void *) getCurrentDatacenterId},
{"native_isTestBackend", "(I)I", (void *) isTestBackend},
{"native_getTimeDifference", "(I)I", (void *) getTimeDifference},
{"native_sendRequest", "(IJLorg/telegram/tgnet/RequestDelegateInternal;Lorg/telegram/tgnet/QuickAckDelegate;Lorg/telegram/tgnet/WriteToSocketDelegate;IIIZI)V", (void *) sendRequest},
{"native_cancelRequest", "(IIZ)V", (void *) cancelRequest},
{"native_cleanUp", "(IZ)V", (void *) cleanUp},
{"native_cancelRequestsForGuid", "(II)V", (void *) cancelRequestsForGuid},
{"native_bindRequestToGuid", "(III)V", (void *) bindRequestToGuid},
{"native_applyDatacenterAddress", "(IILjava/lang/String;I)V", (void *) applyDatacenterAddress},
{"native_moveToDatacenter", "(II)V", (void *) moveToDatacenter},
{"native_setProxySettings", "(ILjava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V", (void *) setProxySettings},
{"native_getConnectionState", "(I)I", (void *) getConnectionState},
{"native_setUserId", "(II)V", (void *) setUserId},
{"native_init", "(IIIILjava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;IIZZI)V", (void *) init},
{"native_setLangCode", "(ILjava/lang/String;)V", (void *) setLangCode},
{"native_setRegId", "(ILjava/lang/String;)V", (void *) setRegId},
{"native_setSystemLangCode", "(ILjava/lang/String;)V", (void *) setSystemLangCode},
{"native_switchBackend", "(I)V", (void *) switchBackend},
{"native_pauseNetwork", "(I)V", (void *) pauseNetwork},
{"native_resumeNetwork", "(IZ)V", (void *) resumeNetwork},
{"native_updateDcSettings", "(I)V", (void *) updateDcSettings},
{"native_setUseIpv6", "(IZ)V", (void *) setUseIpv6},
{"native_setNetworkAvailable", "(IZIZ)V", (void *) setNetworkAvailable},
{"native_setPushConnectionEnabled", "(IZ)V", (void *) setPushConnectionEnabled},
{"native_setJava", "(Z)V", (void *) setJava},
{"native_applyDnsConfig", "(IJLjava/lang/String;I)V", (void *) applyDnsConfig},
{"native_checkProxy", "(ILjava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;Lorg/telegram/tgnet/RequestTimeDelegate;)J", (void *) checkProxy},
{"native_onHostNameResolved", "(Ljava/lang/String;JLjava/lang/String;Z)V", (void *) onHostNameResolved}
};
inline int registerNativeMethods(JNIEnv *env, const char *className, JNINativeMethod *methods, int methodsCount) {
inline int registerNativeMethods(JNIEnv *env, const char *className, JNINativeMethod *methods,
int methodsCount) {
jclass clazz;
clazz = env->FindClass(className);
if (clazz == NULL) {
@ -520,24 +549,31 @@ inline int registerNativeMethods(JNIEnv *env, const char *className, JNINativeMe
extern "C" int registerNativeTgNetFunctions(JavaVM *vm, JNIEnv *env) {
java = vm;
if (!registerNativeMethods(env, NativeByteBufferClassPathName, NativeByteBufferMethods, sizeof(NativeByteBufferMethods) / sizeof(NativeByteBufferMethods[0]))) {
if (!registerNativeMethods(env, NativeByteBufferClassPathName, NativeByteBufferMethods,
sizeof(NativeByteBufferMethods) /
sizeof(NativeByteBufferMethods[0]))) {
return JNI_FALSE;
}
if (!registerNativeMethods(env, ConnectionsManagerClassPathName, ConnectionsManagerMethods, sizeof(ConnectionsManagerMethods) / sizeof(ConnectionsManagerMethods[0]))) {
if (!registerNativeMethods(env, ConnectionsManagerClassPathName, ConnectionsManagerMethods,
sizeof(ConnectionsManagerMethods) /
sizeof(ConnectionsManagerMethods[0]))) {
return JNI_FALSE;
}
jclass_RequestDelegateInternal = (jclass) env->NewGlobalRef(env->FindClass("org/telegram/tgnet/RequestDelegateInternal"));
jclass_RequestDelegateInternal = (jclass) env->NewGlobalRef(
env->FindClass("org/telegram/tgnet/RequestDelegateInternal"));
if (jclass_RequestDelegateInternal == 0) {
return JNI_FALSE;
}
jclass_RequestDelegateInternal_run = env->GetMethodID(jclass_RequestDelegateInternal, "run", "(JILjava/lang/String;I)V");
jclass_RequestDelegateInternal_run = env->GetMethodID(jclass_RequestDelegateInternal, "run",
"(JILjava/lang/String;I)V");
if (jclass_RequestDelegateInternal_run == 0) {
return JNI_FALSE;
}
jclass_RequestTimeDelegate = (jclass) env->NewGlobalRef(env->FindClass("org/telegram/tgnet/RequestTimeDelegate"));
jclass_RequestTimeDelegate = (jclass) env->NewGlobalRef(
env->FindClass("org/telegram/tgnet/RequestTimeDelegate"));
if (jclass_RequestTimeDelegate == 0) {
return JNI_FALSE;
}
@ -546,7 +582,8 @@ extern "C" int registerNativeTgNetFunctions(JavaVM *vm, JNIEnv *env) {
return JNI_FALSE;
}
jclass_QuickAckDelegate = (jclass) env->NewGlobalRef(env->FindClass("org/telegram/tgnet/QuickAckDelegate"));
jclass_QuickAckDelegate = (jclass) env->NewGlobalRef(
env->FindClass("org/telegram/tgnet/QuickAckDelegate"));
if (jclass_RequestDelegateInternal == 0) {
return JNI_FALSE;
}
@ -555,7 +592,8 @@ extern "C" int registerNativeTgNetFunctions(JavaVM *vm, JNIEnv *env) {
return JNI_FALSE;
}
jclass_WriteToSocketDelegate = (jclass) env->NewGlobalRef(env->FindClass("org/telegram/tgnet/WriteToSocketDelegate"));
jclass_WriteToSocketDelegate = (jclass) env->NewGlobalRef(
env->FindClass("org/telegram/tgnet/WriteToSocketDelegate"));
if (jclass_WriteToSocketDelegate == 0) {
return JNI_FALSE;
}
@ -563,59 +601,74 @@ extern "C" int registerNativeTgNetFunctions(JavaVM *vm, JNIEnv *env) {
if (jclass_WriteToSocketDelegate_run == 0) {
return JNI_FALSE;
}
jclass_ConnectionsManager = (jclass) env->NewGlobalRef(env->FindClass("org/telegram/tgnet/ConnectionsManager"));
jclass_ConnectionsManager = (jclass) env->NewGlobalRef(
env->FindClass("org/telegram/tgnet/ConnectionsManager"));
if (jclass_ConnectionsManager == 0) {
return JNI_FALSE;
}
jclass_ConnectionsManager_onUnparsedMessageReceived = env->GetStaticMethodID(jclass_ConnectionsManager, "onUnparsedMessageReceived", "(JI)V");
jclass_ConnectionsManager_onUnparsedMessageReceived = env->GetStaticMethodID(
jclass_ConnectionsManager, "onUnparsedMessageReceived", "(JI)V");
if (jclass_ConnectionsManager_onUnparsedMessageReceived == 0) {
return JNI_FALSE;
}
jclass_ConnectionsManager_onUpdate = env->GetStaticMethodID(jclass_ConnectionsManager, "onUpdate", "(I)V");
jclass_ConnectionsManager_onUpdate = env->GetStaticMethodID(jclass_ConnectionsManager,
"onUpdate", "(I)V");
if (jclass_ConnectionsManager_onUpdate == 0) {
return JNI_FALSE;
}
jclass_ConnectionsManager_onSessionCreated = env->GetStaticMethodID(jclass_ConnectionsManager, "onSessionCreated", "(I)V");
jclass_ConnectionsManager_onSessionCreated = env->GetStaticMethodID(jclass_ConnectionsManager,
"onSessionCreated", "(I)V");
if (jclass_ConnectionsManager_onSessionCreated == 0) {
return JNI_FALSE;
}
jclass_ConnectionsManager_onLogout = env->GetStaticMethodID(jclass_ConnectionsManager, "onLogout", "(I)V");
jclass_ConnectionsManager_onLogout = env->GetStaticMethodID(jclass_ConnectionsManager,
"onLogout", "(I)V");
if (jclass_ConnectionsManager_onLogout == 0) {
return JNI_FALSE;
}
jclass_ConnectionsManager_onConnectionStateChanged = env->GetStaticMethodID(jclass_ConnectionsManager, "onConnectionStateChanged", "(II)V");
jclass_ConnectionsManager_onConnectionStateChanged = env->GetStaticMethodID(
jclass_ConnectionsManager, "onConnectionStateChanged", "(II)V");
if (jclass_ConnectionsManager_onConnectionStateChanged == 0) {
return JNI_FALSE;
}
jclass_ConnectionsManager_onInternalPushReceived = env->GetStaticMethodID(jclass_ConnectionsManager, "onInternalPushReceived", "(I)V");
jclass_ConnectionsManager_onInternalPushReceived = env->GetStaticMethodID(
jclass_ConnectionsManager, "onInternalPushReceived", "(I)V");
if (jclass_ConnectionsManager_onInternalPushReceived == 0) {
return JNI_FALSE;
}
jclass_ConnectionsManager_onUpdateConfig = env->GetStaticMethodID(jclass_ConnectionsManager, "onUpdateConfig", "(JI)V");
jclass_ConnectionsManager_onUpdateConfig = env->GetStaticMethodID(jclass_ConnectionsManager,
"onUpdateConfig", "(JI)V");
if (jclass_ConnectionsManager_onUpdateConfig == 0) {
return JNI_FALSE;
}
jclass_ConnectionsManager_onBytesSent = env->GetStaticMethodID(jclass_ConnectionsManager, "onBytesSent", "(III)V");
jclass_ConnectionsManager_onBytesSent = env->GetStaticMethodID(jclass_ConnectionsManager,
"onBytesSent", "(III)V");
if (jclass_ConnectionsManager_onBytesSent == 0) {
return JNI_FALSE;
}
jclass_ConnectionsManager_onBytesReceived = env->GetStaticMethodID(jclass_ConnectionsManager, "onBytesReceived", "(III)V");
jclass_ConnectionsManager_onBytesReceived = env->GetStaticMethodID(jclass_ConnectionsManager,
"onBytesReceived", "(III)V");
if (jclass_ConnectionsManager_onBytesReceived == 0) {
return JNI_FALSE;
}
jclass_ConnectionsManager_onRequestNewServerIpAndPort = env->GetStaticMethodID(jclass_ConnectionsManager, "onRequestNewServerIpAndPort", "(II)V");
jclass_ConnectionsManager_onRequestNewServerIpAndPort = env->GetStaticMethodID(
jclass_ConnectionsManager, "onRequestNewServerIpAndPort", "(II)V");
if (jclass_ConnectionsManager_onRequestNewServerIpAndPort == 0) {
return JNI_FALSE;
}
jclass_ConnectionsManager_onProxyError = env->GetStaticMethodID(jclass_ConnectionsManager, "onProxyError", "(I)V");
jclass_ConnectionsManager_onProxyError = env->GetStaticMethodID(jclass_ConnectionsManager,
"onProxyError", "(I)V");
if (jclass_ConnectionsManager_onProxyError == 0) {
return JNI_FALSE;
}
jclass_ConnectionsManager_getHostByName = env->GetStaticMethodID(jclass_ConnectionsManager, "getHostByName", "(Ljava/lang/String;J)V");
jclass_ConnectionsManager_getHostByName = env->GetStaticMethodID(jclass_ConnectionsManager,
"getHostByName",
"(Ljava/lang/String;J)V");
if (jclass_ConnectionsManager_getHostByName == 0) {
return JNI_FALSE;
}
jclass_ConnectionsManager_getInitFlags = env->GetStaticMethodID(jclass_ConnectionsManager, "getInitFlags", "()I");
jclass_ConnectionsManager_getInitFlags = env->GetStaticMethodID(jclass_ConnectionsManager,
"getInitFlags", "()I");
if (jclass_ConnectionsManager_getInitFlags == 0) {
return JNI_FALSE;
}

91
TMessagesProj/jni/tgnet/ConnectionsManager.cpp
View File

@ -433,9 +433,7 @@ void ConnectionsManager::loadConfig() {
}
}
if (datacenters.empty()) {
initDatacenters();
}
initDatacenters();
if ((datacenters.size() != 0 && currentDatacenterId == 0) || pushSessionId == 0) {
if (pushSessionId == 0) {
@ -707,9 +705,7 @@ void ConnectionsManager::onConnectionClosed(Connection *connection, int reason)
} else {
requestingSecondAddress = 0;
}
if (datacenter->keyFingerprint == 0) {
delegate->onRequestNewServerIpAndPort(requestingSecondAddress,instanceNum);
}
delegate->onRequestNewServerIpAndPort(requestingSecondAddress, instanceNum);
} else {
if (LOGS_ENABLED) DEBUG_D("connection has usefull data, don't request anything");
}
@ -3110,77 +3106,6 @@ void ConnectionsManager::applyDatacenterAddress(uint32_t datacenterId, std::stri
});
}
void ConnectionsManager::setDatacenterAddress(uint32_t datacenterId, std::string ipv4Address,std::string ipv6Address, uint32_t port) {
scheduleTask([&, datacenterId, ipv4Address,ipv6Address, port] {
Datacenter *datacenter = getDatacenterWithId(datacenterId);
if (datacenter != nullptr) {
datacenter->suspendConnections(true);
datacenter->resetAddressAndPortNum();
datacenter->addressesIpv4Download.clear();
datacenter->addressesIpv6Download.clear();
datacenter->addressesIpv4Temp.clear();
if (ipv4Address.empty()) {
datacenter->addressesIpv4.clear();
} else {
std::vector<TcpAddress> v4Addresses;
v4Addresses.push_back(TcpAddress(ipv4Address, port, 0, ""));
datacenter->replaceAddresses(v4Addresses, 0);
}
if (ipv6Address.empty()) {
datacenter->addressesIpv6.clear();
} else {
std::vector<TcpAddress> v6Addresses;
v6Addresses.push_back(TcpAddress(ipv4Address, port, 1, ""));
datacenter->replaceAddresses(v6Addresses, 1);
}
}
});
}
void ConnectionsManager::setLayer(uint32_t layer) {
scheduleTask([&, layer] {
currentLayer = layer;
});
}
void ConnectionsManager::saveDatacenters() {
scheduleTask([&] {
saveConfig();
for (std::map<uint32_t, Datacenter *>::iterator iter = datacenters.begin(); iter != datacenters.end(); iter++) {
iter->second->clearAuthKey(HandshakeTypeAll);
iter->second->recreateSessions(HandshakeTypeAll);
iter->second->authorized = false;
if (iter->second->isHandshakingAny()) {
iter->second->beginHandshake(HandshakeTypeCurrent, true);
}
}
});
}
void ConnectionsManager::setDatacenterPublicKey(uint32_t datacenterId, std::string publicKey, uint64_t fingerprint) {
scheduleTask([&, datacenterId, publicKey, fingerprint] {
Datacenter *datacenter = getDatacenterWithId(datacenterId);
if (datacenter != nullptr) {
datacenter->publicKey = publicKey;
datacenter->keyFingerprint = fingerprint;
datacenter->storePermConfig();
}
});
}
ConnectionState ConnectionsManager::getConnectionState() {
return connectionState;
}
@ -3285,19 +3210,13 @@ void ConnectionsManager::applyDnsConfig(NativeByteBuffer *buffer, std::string ph
}
if (requestingSecondAddress == 2) {
requestingSecondAddress = 3;
if (getDatacenterWithId(currentDatacenterId)->keyFingerprint == 0) {
delegate->onRequestNewServerIpAndPort(requestingSecondAddress, instanceNum);
}
delegate->onRequestNewServerIpAndPort(requestingSecondAddress, instanceNum);
} else if (requestingSecondAddress == 1) {
requestingSecondAddress = 2;
if (getDatacenterWithId(currentDatacenterId)->keyFingerprint == 0) {
delegate->onRequestNewServerIpAndPort(requestingSecondAddress, instanceNum);
}
delegate->onRequestNewServerIpAndPort(requestingSecondAddress, instanceNum);
} else if (requestingSecondAddress == 0) {
requestingSecondAddress = 1;
if (getDatacenterWithId(currentDatacenterId)->keyFingerprint == 0) {
delegate->onRequestNewServerIpAndPort(requestingSecondAddress, instanceNum);
}
delegate->onRequestNewServerIpAndPort(requestingSecondAddress, instanceNum);
} else {
requestingSecondAddress = 0;
}

4
TMessagesProj/jni/tgnet/ConnectionsManager.h
View File

@ -55,10 +55,6 @@ public:
void cancelRequestsForGuid(int32_t guid);
void bindRequestToGuid(int32_t requestToken, int32_t guid);
void applyDatacenterAddress(uint32_t datacenterId, std::string ipAddress, uint32_t port);
void setDatacenterPublicKey(uint32_t datacenterId, std::string publicKey, uint64_t fingerprint);
void setDatacenterAddress(uint32_t datacenterId, std::string ipv4Address, std::string ipv6Address,uint32_t port);
void setLayer(uint32_t layer);
void saveDatacenters();
void setDelegate(ConnectiosManagerDelegate *connectiosManagerDelegate);
ConnectionState getConnectionState();
void setUserId(int32_t userId);

42
TMessagesProj/jni/tgnet/Datacenter.cpp
View File

@ -191,17 +191,6 @@ Datacenter::Datacenter(int32_t instance, NativeByteBuffer *data) {
currentPortNumIpv6Download = 0;
currentAddressNumIpv6Download = 0;
}
if (permConfig == nullptr) {
permConfig = new Config(instanceNum, "dc" + to_string_int32(datacenterId) + "perm.dat");
}
NativeByteBuffer *permBuffer = permConfig->readConfig();
if (permBuffer != nullptr) {
publicKey = permBuffer->readString(nullptr);
keyFingerprint = permBuffer->readUint64(nullptr);
permBuffer->reuse();
} else {
publicKey = "";
}
}
TcpAddress *Datacenter::getCurrentAddress(uint32_t flags) {
@ -492,37 +481,6 @@ void Datacenter::storeCurrentAddressAndPortNum() {
buffer->reuse();
}
void Datacenter::storePermConfig() {
if (permConfig == nullptr) {
permConfig = new Config(instanceNum, "dc" + to_string_int32(datacenterId) + "perm.dat");
}
if (sizeCalculator == nullptr) {
sizeCalculator = new NativeByteBuffer(true);
}
sizeCalculator->clearCapacity();
sizeCalculator->writeString(publicKey);
sizeCalculator->writeInt64(keyFingerprint);
NativeByteBuffer *buffer = BuffersStorage::getInstance().getFreeBuffer(sizeCalculator->capacity());
sizeCalculator->clearCapacity();
buffer->writeString(publicKey);
buffer->writeInt64(keyFingerprint);
permConfig->writeConfig(buffer);
buffer->reuse();
for (std::vector<std::unique_ptr<Handshake>>::iterator iter = handshakes.begin(); iter != handshakes.end(); iter++) {
Handshake *handshake = iter->get();
handshake->clearServerPublicKey();
}
}
void Datacenter::resetAddressAndPortNum() {
currentPortNumIpv4 = 0;
currentAddressNumIpv4 = 0;

6
TMessagesProj/jni/tgnet/Datacenter.h
View File

@ -96,8 +96,6 @@ private:
uint32_t lastInitMediaVersion = 0;
bool authorized = false;
std::string publicKey;
uint64_t keyFingerprint = 0;
std::vector<TcpAddress> addressesIpv4;
std::vector<TcpAddress> addressesIpv6;
std::vector<TcpAddress> addressesIpv4Download;
@ -122,7 +120,6 @@ private:
ByteArray *authKeyMediaTemp = nullptr;
int64_t authKeyMediaTempId = 0;
Config *config = nullptr;
Config *permConfig = nullptr;
bool isCdnDatacenter = false;
std::vector<std::unique_ptr<Handshake>> handshakes;
@ -150,9 +147,6 @@ private:
friend class Connection;
friend class Handshake;
friend class Request;
NativeByteBuffer *sizeCalculator;
void storePermConfig();
};
#endif

165
TMessagesProj/jni/tgnet/Handshake.cpp
View File

@ -108,13 +108,6 @@ void Handshake::cleanupHandshake() {
authKeyTempPendingId = 0;
}
void Handshake::clearServerPublicKey() {
serverPublicKeys.clear();
clearServerPublicKey();
}
inline Connection *Handshake::getConnection() {
return handshakeType == HandshakeTypeMediaTemp ? currentDatacenter->createGenericMediaConnection() : currentDatacenter->createGenericConnection();
}
@ -360,99 +353,87 @@ void Handshake::processHandshakeResponse(TLObject *message, int64_t messageId) {
}
} else {
if (serverPublicKeys.empty()) {
if (!currentDatacenter->publicKey.empty()) {
serverPublicKeys.push_back(currentDatacenter->publicKey);
serverPublicKeysFingerprints.push_back(currentDatacenter->keyFingerprint);
} else {
#ifdef USE_OLD_KEYS
serverPublicKeys.push_back("-----BEGIN RSA PUBLIC KEY-----\n"
"MIIBCgKCAQEAwVACPi9w23mF3tBkdZz+zwrzKOaaQdr01vAbU4E1pvkfj4sqDsm6\n"
"lyDONS789sVoD/xCS9Y0hkkC3gtL1tSfTlgCMOOul9lcixlEKzwKENj1Yz/s7daS\n"
"an9tqw3bfUV/nqgbhGX81v/+7RFAEd+RwFnK7a+XYl9sluzHRyVVaTTveB2GazTw\n"
"Efzk2DWgkBluml8OREmvfraX3bkHZJTKX4EQSjBbbdJ2ZXIsRrYOXfaA+xayEGB+\n"
"8hdlLmAjbCVfaigxX0CDqWeR1yFL9kwd9P0NsZRPsmoqVwMbMu7mStFai6aIhc3n\n"
"Slv8kg9qv1m6XHVQY3PnEw+QQtqSIXklHwIDAQAB\n"
"-----END RSA PUBLIC KEY-----");
serverPublicKeysFingerprints.push_back(0xc3b42b026ce86b21LL);
serverPublicKeys.push_back("-----BEGIN RSA PUBLIC KEY-----\n"
"MIIBCgKCAQEAwVACPi9w23mF3tBkdZz+zwrzKOaaQdr01vAbU4E1pvkfj4sqDsm6\n"
"lyDONS789sVoD/xCS9Y0hkkC3gtL1tSfTlgCMOOul9lcixlEKzwKENj1Yz/s7daS\n"
"an9tqw3bfUV/nqgbhGX81v/+7RFAEd+RwFnK7a+XYl9sluzHRyVVaTTveB2GazTw\n"
"Efzk2DWgkBluml8OREmvfraX3bkHZJTKX4EQSjBbbdJ2ZXIsRrYOXfaA+xayEGB+\n"
"8hdlLmAjbCVfaigxX0CDqWeR1yFL9kwd9P0NsZRPsmoqVwMbMu7mStFai6aIhc3n\n"
"Slv8kg9qv1m6XHVQY3PnEw+QQtqSIXklHwIDAQAB\n"
"-----END RSA PUBLIC KEY-----");
serverPublicKeysFingerprints.push_back(0xc3b42b026ce86b21LL);
serverPublicKeys.push_back("-----BEGIN RSA PUBLIC KEY-----\n"
"MIIBCgKCAQEAxq7aeLAqJR20tkQQMfRn+ocfrtMlJsQ2Uksfs7Xcoo77jAid0bRt\n"
"ksiVmT2HEIJUlRxfABoPBV8wY9zRTUMaMA654pUX41mhyVN+XoerGxFvrs9dF1Ru\n"
"vCHbI02dM2ppPvyytvvMoefRoL5BTcpAihFgm5xCaakgsJ/tH5oVl74CdhQw8J5L\n"
"xI/K++KJBUyZ26Uba1632cOiq05JBUW0Z2vWIOk4BLysk7+U9z+SxynKiZR3/xdi\n"
"XvFKk01R3BHV+GUKM2RYazpS/P8v7eyKhAbKxOdRcFpHLlVwfjyM1VlDQrEZxsMp\n"
"NTLYXb6Sce1Uov0YtNx5wEowlREH1WOTlwIDAQAB\n"
"-----END RSA PUBLIC KEY-----");
serverPublicKeysFingerprints.push_back(0x9a996a1db11c729bLL);
serverPublicKeys.push_back("-----BEGIN RSA PUBLIC KEY-----\n"
"MIIBCgKCAQEAxq7aeLAqJR20tkQQMfRn+ocfrtMlJsQ2Uksfs7Xcoo77jAid0bRt\n"
"ksiVmT2HEIJUlRxfABoPBV8wY9zRTUMaMA654pUX41mhyVN+XoerGxFvrs9dF1Ru\n"
"vCHbI02dM2ppPvyytvvMoefRoL5BTcpAihFgm5xCaakgsJ/tH5oVl74CdhQw8J5L\n"
"xI/K++KJBUyZ26Uba1632cOiq05JBUW0Z2vWIOk4BLysk7+U9z+SxynKiZR3/xdi\n"
"XvFKk01R3BHV+GUKM2RYazpS/P8v7eyKhAbKxOdRcFpHLlVwfjyM1VlDQrEZxsMp\n"
"NTLYXb6Sce1Uov0YtNx5wEowlREH1WOTlwIDAQAB\n"
"-----END RSA PUBLIC KEY-----");
serverPublicKeysFingerprints.push_back(0x9a996a1db11c729bLL);
serverPublicKeys.push_back("-----BEGIN RSA PUBLIC KEY-----\n"
"MIIBCgKCAQEAsQZnSWVZNfClk29RcDTJQ76n8zZaiTGuUsi8sUhW8AS4PSbPKDm+\n"
"DyJgdHDWdIF3HBzl7DHeFrILuqTs0vfS7Pa2NW8nUBwiaYQmPtwEa4n7bTmBVGsB\n"
"1700/tz8wQWOLUlL2nMv+BPlDhxq4kmJCyJfgrIrHlX8sGPcPA4Y6Rwo0MSqYn3s\n"
"g1Pu5gOKlaT9HKmE6wn5Sut6IiBjWozrRQ6n5h2RXNtO7O2qCDqjgB2vBxhV7B+z\n"
"hRbLbCmW0tYMDsvPpX5M8fsO05svN+lKtCAuz1leFns8piZpptpSCFn7bWxiA9/f\n"
"x5x17D7pfah3Sy2pA+NDXyzSlGcKdaUmwQIDAQAB\n"
"-----END RSA PUBLIC KEY-----");
serverPublicKeysFingerprints.push_back(0xb05b2a6f70cdea78LL);
serverPublicKeys.push_back("-----BEGIN RSA PUBLIC KEY-----\n"
"MIIBCgKCAQEAsQZnSWVZNfClk29RcDTJQ76n8zZaiTGuUsi8sUhW8AS4PSbPKDm+\n"
"DyJgdHDWdIF3HBzl7DHeFrILuqTs0vfS7Pa2NW8nUBwiaYQmPtwEa4n7bTmBVGsB\n"
"1700/tz8wQWOLUlL2nMv+BPlDhxq4kmJCyJfgrIrHlX8sGPcPA4Y6Rwo0MSqYn3s\n"
"g1Pu5gOKlaT9HKmE6wn5Sut6IiBjWozrRQ6n5h2RXNtO7O2qCDqjgB2vBxhV7B+z\n"
"hRbLbCmW0tYMDsvPpX5M8fsO05svN+lKtCAuz1leFns8piZpptpSCFn7bWxiA9/f\n"
"x5x17D7pfah3Sy2pA+NDXyzSlGcKdaUmwQIDAQAB\n"
"-----END RSA PUBLIC KEY-----");
serverPublicKeysFingerprints.push_back(0xb05b2a6f70cdea78LL);
serverPublicKeys.push_back("-----BEGIN RSA PUBLIC KEY-----\n"
"MIIBCgKCAQEAwqjFW0pi4reKGbkc9pK83Eunwj/k0G8ZTioMMPbZmW99GivMibwa\n"
"xDM9RDWabEMyUtGoQC2ZcDeLWRK3W8jMP6dnEKAlvLkDLfC4fXYHzFO5KHEqF06i\n"
"qAqBdmI1iBGdQv/OQCBcbXIWCGDY2AsiqLhlGQfPOI7/vvKc188rTriocgUtoTUc\n"
"/n/sIUzkgwTqRyvWYynWARWzQg0I9olLBBC2q5RQJJlnYXZwyTL3y9tdb7zOHkks\n"
"WV9IMQmZmyZh/N7sMbGWQpt4NMchGpPGeJ2e5gHBjDnlIf2p1yZOYeUYrdbwcS0t\n"
"UiggS4UeE8TzIuXFQxw7fzEIlmhIaq3FnwIDAQAB\n"
"-----END RSA PUBLIC KEY-----");
serverPublicKeysFingerprints.push_back(0x71e025b6c76033e3LL);
serverPublicKeys.push_back("-----BEGIN RSA PUBLIC KEY-----\n"
"MIIBCgKCAQEAwqjFW0pi4reKGbkc9pK83Eunwj/k0G8ZTioMMPbZmW99GivMibwa\n"
"xDM9RDWabEMyUtGoQC2ZcDeLWRK3W8jMP6dnEKAlvLkDLfC4fXYHzFO5KHEqF06i\n"
"qAqBdmI1iBGdQv/OQCBcbXIWCGDY2AsiqLhlGQfPOI7/vvKc188rTriocgUtoTUc\n"
"/n/sIUzkgwTqRyvWYynWARWzQg0I9olLBBC2q5RQJJlnYXZwyTL3y9tdb7zOHkks\n"
"WV9IMQmZmyZh/N7sMbGWQpt4NMchGpPGeJ2e5gHBjDnlIf2p1yZOYeUYrdbwcS0t\n"
"UiggS4UeE8TzIuXFQxw7fzEIlmhIaq3FnwIDAQAB\n"
"-----END RSA PUBLIC KEY-----");
serverPublicKeysFingerprints.push_back(0x71e025b6c76033e3LL);
#endif
serverPublicKeys.push_back("-----BEGIN RSA PUBLIC KEY-----\n"
"MIIBCgKCAQEAruw2yP/BCcsJliRoW5eBVBVle9dtjJw+OYED160Wybum9SXtBBLX\n"
"riwt4rROd9csv0t0OHCaTmRqBcQ0J8fxhN6/cpR1GWgOZRUAiQxoMnlt0R93LCX/\n"
"j1dnVa/gVbCjdSxpbrfY2g2L4frzjJvdl84Kd9ORYjDEAyFnEA7dD556OptgLQQ2\n"
"e2iVNq8NZLYTzLp5YpOdO1doK+ttrltggTCy5SrKeLoCPPbOgGsdxJxyz5KKcZnS\n"
"Lj16yE5HvJQn0CNpRdENvRUXe6tBP78O39oJ8BTHp9oIjd6XWXAsp2CvK45Ol8wF\n"
"XGF710w9lwCGNbmNxNYhtIkdqfsEcwR5JwIDAQAB\n"
"-----END RSA PUBLIC KEY-----");
serverPublicKeysFingerprints.push_back(0xbc35f3509f7b7a5LL);
serverPublicKeys.push_back("-----BEGIN RSA PUBLIC KEY-----\n"
"MIIBCgKCAQEAruw2yP/BCcsJliRoW5eBVBVle9dtjJw+OYED160Wybum9SXtBBLX\n"
"riwt4rROd9csv0t0OHCaTmRqBcQ0J8fxhN6/cpR1GWgOZRUAiQxoMnlt0R93LCX/\n"
"j1dnVa/gVbCjdSxpbrfY2g2L4frzjJvdl84Kd9ORYjDEAyFnEA7dD556OptgLQQ2\n"
"e2iVNq8NZLYTzLp5YpOdO1doK+ttrltggTCy5SrKeLoCPPbOgGsdxJxyz5KKcZnS\n"
"Lj16yE5HvJQn0CNpRdENvRUXe6tBP78O39oJ8BTHp9oIjd6XWXAsp2CvK45Ol8wF\n"
"XGF710w9lwCGNbmNxNYhtIkdqfsEcwR5JwIDAQAB\n"
"-----END RSA PUBLIC KEY-----");
serverPublicKeysFingerprints.push_back(0xbc35f3509f7b7a5LL);
serverPublicKeys.push_back("-----BEGIN RSA PUBLIC KEY-----\n"
"MIIBCgKCAQEAvfLHfYH2r9R70w8prHblWt/nDkh+XkgpflqQVcnAfSuTtO05lNPs\n"
"pQmL8Y2XjVT4t8cT6xAkdgfmmvnvRPOOKPi0OfJXoRVylFzAQG/j83u5K3kRLbae\n"
"7fLccVhKZhY46lvsueI1hQdLgNV9n1cQ3TDS2pQOCtovG4eDl9wacrXOJTG2990V\n"
"jgnIKNA0UMoP+KF03qzryqIt3oTvZq03DyWdGK+AZjgBLaDKSnC6qD2cFY81UryR\n"
"WOab8zKkWAnhw2kFpcqhI0jdV5QaSCExvnsjVaX0Y1N0870931/5Jb9ICe4nweZ9\n"
"kSDF/gip3kWLG0o8XQpChDfyvsqB9OLV/wIDAQAB\n"
"-----END RSA PUBLIC KEY-----");
serverPublicKeysFingerprints.push_back(0x15ae5fa8b5529542LL);
serverPublicKeys.push_back("-----BEGIN RSA PUBLIC KEY-----\n"
"MIIBCgKCAQEAvfLHfYH2r9R70w8prHblWt/nDkh+XkgpflqQVcnAfSuTtO05lNPs\n"
"pQmL8Y2XjVT4t8cT6xAkdgfmmvnvRPOOKPi0OfJXoRVylFzAQG/j83u5K3kRLbae\n"
"7fLccVhKZhY46lvsueI1hQdLgNV9n1cQ3TDS2pQOCtovG4eDl9wacrXOJTG2990V\n"
"jgnIKNA0UMoP+KF03qzryqIt3oTvZq03DyWdGK+AZjgBLaDKSnC6qD2cFY81UryR\n"
"WOab8zKkWAnhw2kFpcqhI0jdV5QaSCExvnsjVaX0Y1N0870931/5Jb9ICe4nweZ9\n"
"kSDF/gip3kWLG0o8XQpChDfyvsqB9OLV/wIDAQAB\n"
"-----END RSA PUBLIC KEY-----");
serverPublicKeysFingerprints.push_back(0x15ae5fa8b5529542LL);
serverPublicKeys.push_back("-----BEGIN RSA PUBLIC KEY-----\n"
"MIIBCgKCAQEAs/ditzm+mPND6xkhzwFIz6J/968CtkcSE/7Z2qAJiXbmZ3UDJPGr\n"
"zqTDHkO30R8VeRM/Kz2f4nR05GIFiITl4bEjvpy7xqRDspJcCFIOcyXm8abVDhF+\n"
"th6knSU0yLtNKuQVP6voMrnt9MV1X92LGZQLgdHZbPQz0Z5qIpaKhdyA8DEvWWvS\n"
"Uwwc+yi1/gGaybwlzZwqXYoPOhwMebzKUk0xW14htcJrRrq+PXXQbRzTMynseCoP\n"
"Ioke0dtCodbA3qQxQovE16q9zz4Otv2k4j63cz53J+mhkVWAeWxVGI0lltJmWtEY\n"
"K6er8VqqWot3nqmWMXogrgRLggv/NbbooQIDAQAB\n"
"-----END RSA PUBLIC KEY-----");
serverPublicKeysFingerprints.push_back(0xaeae98e13cd7f94fLL);
serverPublicKeys.push_back("-----BEGIN RSA PUBLIC KEY-----\n"
"MIIBCgKCAQEAvmpxVY7ld/8DAjz6F6q05shjg8/4p6047bn6/m8yPy1RBsvIyvuD\n"
"uGnP/RzPEhzXQ9UJ5Ynmh2XJZgHoE9xbnfxL5BXHplJhMtADXKM9bWB11PU1Eioc\n"
"3+AXBB8QiNFBn2XI5UkO5hPhbb9mJpjA9Uhw8EdfqJP8QetVsI/xrCEbwEXe0xvi\n"
"fRLJbY08/Gp66KpQvy7g8w7VB8wlgePexW3pT13Ap6vuC+mQuJPyiHvSxjEKHgqe\n"
"Pji9NP3tJUFQjcECqcm0yV7/2d0t/pbCm+ZH1sadZspQCEPPrtbkQBlvHb4OLiIW\n"
"PGHKSMeRFvp3IWcmdJqXahxLCUS1Eh6MAQIDAQAB\n"
"-----END RSA PUBLIC KEY-----");
serverPublicKeysFingerprints.push_back(0x5a181b2235057d98LL);
}
serverPublicKeys.push_back("-----BEGIN RSA PUBLIC KEY-----\n"
"MIIBCgKCAQEAs/ditzm+mPND6xkhzwFIz6J/968CtkcSE/7Z2qAJiXbmZ3UDJPGr\n"
"zqTDHkO30R8VeRM/Kz2f4nR05GIFiITl4bEjvpy7xqRDspJcCFIOcyXm8abVDhF+\n"
"th6knSU0yLtNKuQVP6voMrnt9MV1X92LGZQLgdHZbPQz0Z5qIpaKhdyA8DEvWWvS\n"
"Uwwc+yi1/gGaybwlzZwqXYoPOhwMebzKUk0xW14htcJrRrq+PXXQbRzTMynseCoP\n"
"Ioke0dtCodbA3qQxQovE16q9zz4Otv2k4j63cz53J+mhkVWAeWxVGI0lltJmWtEY\n"
"K6er8VqqWot3nqmWMXogrgRLggv/NbbooQIDAQAB\n"
"-----END RSA PUBLIC KEY-----");
serverPublicKeysFingerprints.push_back(0xaeae98e13cd7f94fLL);
serverPublicKeys.push_back("-----BEGIN RSA PUBLIC KEY-----\n"
"MIIBCgKCAQEAvmpxVY7ld/8DAjz6F6q05shjg8/4p6047bn6/m8yPy1RBsvIyvuD\n"
"uGnP/RzPEhzXQ9UJ5Ynmh2XJZgHoE9xbnfxL5BXHplJhMtADXKM9bWB11PU1Eioc\n"
"3+AXBB8QiNFBn2XI5UkO5hPhbb9mJpjA9Uhw8EdfqJP8QetVsI/xrCEbwEXe0xvi\n"
"fRLJbY08/Gp66KpQvy7g8w7VB8wlgePexW3pT13Ap6vuC+mQuJPyiHvSxjEKHgqe\n"
"Pji9NP3tJUFQjcECqcm0yV7/2d0t/pbCm+ZH1sadZspQCEPPrtbkQBlvHb4OLiIW\n"
"PGHKSMeRFvp3IWcmdJqXahxLCUS1Eh6MAQIDAQAB\n"
"-----END RSA PUBLIC KEY-----");
serverPublicKeysFingerprints.push_back(0x5a181b2235057d98LL);
}
size_t count2 = serverPublicKeysFingerprints.size();
@ -481,8 +462,6 @@ void Handshake::processHandshakeResponse(TLObject *message, int64_t messageId) {
return;
}
if (LOGS_ENABLED) DEBUG_D("publicKey: %s, fingerprint: %lld",key.c_str(),keyFingerprint);
authServerNonce = new ByteArray(result->server_nonce.get());
uint64_t pq = ((uint64_t) (result->pq->bytes[0] & 0xff) << 56) |

2
TMessagesProj/jni/tgnet/Handshake.h
View File

@ -33,7 +33,6 @@ public:
ByteArray *getPendingAuthKey();
int64_t getPendingAuthKeyId();
TLObject *getCurrentHandshakeRequest();
void clearServerPublicKey();
private:
@ -63,7 +62,6 @@ private:
static void loadCdnConfig(Datacenter *datacenter);
inline Connection *getConnection();
};
#endif

11
TMessagesProj/src/main/java/org/telegram/tgnet/ConnectionsManager.java
View File

@ -15,6 +15,7 @@ import org.telegram.messenger.AccountInstance;
import org.telegram.messenger.AndroidUtilities;
import org.telegram.messenger.ApplicationLoader;
import org.telegram.messenger.BaseController;
import org.telegram.messenger.BuildConfig;
import org.telegram.messenger.BuildVars;
import org.telegram.messenger.EmuDetector;
import org.telegram.messenger.FileLog;
@ -26,7 +27,6 @@ import org.telegram.messenger.SharedConfig;
import org.telegram.messenger.StatsController;
import org.telegram.messenger.UserConfig;
import org.telegram.messenger.Utilities;
import org.telegram.messenger.BuildConfig;
import java.io.File;
import java.net.Inet4Address;
@ -51,7 +51,6 @@ import java.util.concurrent.atomic.AtomicInteger;
import tw.nekomimi.nekogram.NekoConfig;
import tw.nekomimi.nekogram.parts.ProxySwitcher;
import tw.nekomimi.nekogram.utils.DnsFactory;
import tw.nekomimi.nekogram.utils.UIUtil;
//import org.telegram.messenger.BuildConfig;
@ -684,14 +683,6 @@ public class ConnectionsManager extends BaseController {
public static native void native_applyDatacenterAddress(int currentAccount, int datacenterId, String ipAddress, int port);
public static native void native_setDatacenterAddress(int currentAccount, int datacenterId, String ipv4Address, String ipv6Address, int port);
public static native void native_setDatacenterPublicKey(int currentAccount, int datacenterId, String publicKey, long fingerprint);
public static native void native_saveDatacenters(int currentAccount);
public static native void native_setLayer(int currentAccount, int layer);
public static native void native_moveToDatacenter(int currentAccount, int datacenterId);
public static native int native_getConnectionState(int currentAccount);

293
TMessagesProj/src/main/java/org/telegram/ui/LoginActivity.java
View File

@ -67,8 +67,6 @@ import android.widget.Toast;
import androidx.core.os.ConfigurationCompat;
import com.v2ray.ang.util.Utils;
import org.telegram.PhoneFormat.PhoneFormat;
import org.telegram.messenger.AccountInstance;
import org.telegram.messenger.AndroidUtilities;
@ -114,7 +112,6 @@ import org.telegram.ui.Components.VerticalPositionAutoAnimator;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
@ -133,7 +130,6 @@ import tw.nekomimi.nekogram.BottomBuilder;
import tw.nekomimi.nekogram.DataCenter;
import tw.nekomimi.nekogram.EditTextAutoFill;
import tw.nekomimi.nekogram.NekoXConfig;
import tw.nekomimi.nekogram.parts.PKCS1Pub;
import tw.nekomimi.nekogram.utils.AlertUtil;
import tw.nekomimi.nekogram.utils.ProxyUtil;
import tw.nekomimi.nekogram.utils.VibrateUtil;
@ -549,8 +545,6 @@ public class LoginActivity extends BaseFragment implements NotificationCenter.No
BottomBuilder builder = new BottomBuilder(getParentActivity());
EditText[] inputs = new EditText[6];
builder.addTitle(LocaleController.getString("CustomBackend", R.string.CustomBackend),
true,
LocaleController.getString("CustomBackendNotice", R.string.CustomBackendNotice));
@ -559,8 +553,6 @@ public class LoginActivity extends BaseFragment implements NotificationCenter.No
if (ConnectionsManager.native_isTestBackend(currentAccount) != 0) {
dcType = 1;
} else if (MessagesController.getMainSettings(currentAccount).getBoolean("custom_dc", false)) {
dcType = 2;
} else {
dcType = 0;
}
@ -571,8 +563,6 @@ public class LoginActivity extends BaseFragment implements NotificationCenter.No
builder.doRadioCheck(cell);
for (EditText input : inputs) input.setVisibility(View.GONE);
return Unit.INSTANCE;
});
@ -583,8 +573,6 @@ public class LoginActivity extends BaseFragment implements NotificationCenter.No
builder.doRadioCheck(cell);
for (EditText input : inputs) input.setVisibility(View.GONE);
return Unit.INSTANCE;
});
@ -595,285 +583,16 @@ public class LoginActivity extends BaseFragment implements NotificationCenter.No
builder.doRadioCheck(cell);
for (EditText input : inputs) input.setVisibility(View.VISIBLE);
return Unit.INSTANCE;
});
inputs[0] = builder.addEditText(LocaleController.getString("CustomBackendIpv4", R.string.CustomBackendIpv4));
inputs[0].setFilters(new InputFilter[]{new InputFilter.LengthFilter(15)});
if (StrUtil.isNotBlank(NekoXConfig.customDcIpv4)) {
inputs[0].setText(NekoXConfig.customDcIpv4);
}
inputs[0].addTextChangedListener(new TextWatcher() {
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
if (StrUtil.isBlank(s) || Utils.isIpv4Address(s.toString())) {
inputs[0].setError(null);
NekoXConfig.customDcIpv4 = s.toString();
} else {
inputs[0].setError("Invalid Ipv4 Address");
}
}
@Override
public void afterTextChanged(Editable s) {
}
});
inputs[1] = builder.addEditText(LocaleController.getString("CustomBackendIpv6", R.string.CustomBackendIpv6));
if (StrUtil.isNotBlank(NekoXConfig.customDcIpv6)) {
inputs[1].setText(NekoXConfig.customDcIpv6);
}
inputs[1].addTextChangedListener(new TextWatcher() {
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
if (StrUtil.isBlank(s) || Utils.isIpv6Address(s.toString())) {
inputs[1].setError(null);
NekoXConfig.customDcIpv6 = s.toString();
} else {
inputs[1].setError("Invalid Ipv6 Address");
}
}
@Override
public void afterTextChanged(Editable s) {
}
});
inputs[2] = builder.addEditText(LocaleController.getString("UseProxyPort", R.string.UseProxyPort));
inputs[2].setInputType(InputType.TYPE_CLASS_NUMBER);
if (NekoXConfig.customDcPort != 0) {
inputs[2].setText(NekoXConfig.customDcPort + "");
}
inputs[2].setFilters(new InputFilter[]{new InputFilter.LengthFilter(5)});
inputs[2].addTextChangedListener(new TextWatcher() {
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
if (StrUtil.isBlank(s.toString())) {
NekoXConfig.customDcPort = 0;
} else {
NekoXConfig.customDcPort = NumberUtil.parseInt(s.toString());
if (NekoXConfig.customDcPort <= 0 || NekoXConfig.customDcPort > 65535) {
NekoXConfig.customDcPort = 0;
inputs[2].setError("Invalid Port");
} else {
inputs[2].setError(null);
}
}
}
@Override
public void afterTextChanged(Editable s) {
}
});
inputs[3] = builder.addEditText(LocaleController.getString("CustomBackendLayer", R.string.CustomBackendLayer));
inputs[3].setInputType(InputType.TYPE_CLASS_NUMBER);
if (NekoXConfig.customDcLayer != 0) {
inputs[3].setText(NekoXConfig.customDcLayer + "");
}
inputs[3].setFilters(new InputFilter[]{new InputFilter.LengthFilter(3)});
inputs[3].addTextChangedListener(new TextWatcher() {
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
if (StrUtil.isBlank(s.toString())) {
NekoXConfig.customDcLayer = 0;
} else {
NekoXConfig.customDcLayer = NumberUtil.parseInt(s.toString());
if (NekoXConfig.customDcLayer > TLRPC.LAYER || NekoXConfig.customDcLayer < 85) {
NekoXConfig.customDcLayer = 0;
inputs[3].setError("Layer not supported");
} else {
inputs[3].setError(null);
}
}
}
@Override
public void afterTextChanged(Editable s) {
}
});
inputs[4] = builder.addEditText(LocaleController.getString("CustomBackendPublicKey", R.string.CustomBackendPublicKey));
inputs[4].setInputType(InputType.TYPE_CLASS_TEXT);
inputs[4].setGravity(Gravity.TOP | LocaleController.generateFlagStart());
inputs[4].setSingleLine(false);
inputs[4].setMinLines(6);
if (StrUtil.isNotBlank(NekoXConfig.customDcPublicKey)) {
inputs[4].setText(NekoXConfig.customDcPublicKey);
}
inputs[4].addTextChangedListener(new TextWatcher() {
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
if (StrUtil.isBlank(s.toString())) {
NekoXConfig.customDcPublicKey = "";
inputs[5].setText("");
} else {
try {
String publicKeyBase64 = s.toString()
.replace("-----BEGIN RSA PUBLIC KEY-----", "")
.replace("-----END RSA PUBLIC KEY-----", "");
PKCS1Pub.decodePKCS1PublicKey(Base64.decode(publicKeyBase64));
NekoXConfig.customDcPublicKey = s.toString();
inputs[4].setError(null);
} catch (Exception e) {
inputs[4].setError("Invalid PKCS1 Key");
NekoXConfig.customDcPublicKey = "";
}
}
}
@Override
public void afterTextChanged(Editable s) {
}
});
inputs[5] = builder.addEditText(LocaleController.getString("CustomBackendFingerprint", R.string.CustomBackendFingerprint));
if (NekoXConfig.customDcFingerprint != 0) {
inputs[5].setText("0x" + Long.toString(NekoXConfig.customDcFingerprint, 16));
}
inputs[5].addTextChangedListener(new TextWatcher() {
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
if (StrUtil.isBlank(s.toString())) {
NekoXConfig.customDcFingerprint = 0;
inputs[5].setError(null);
} else {
String f = s.toString();
int r = 10;
if (f.startsWith("0x")) {
f = f.substring(2);
r = 16;
}
try {
NekoXConfig.customDcFingerprint = new BigInteger(f, r).longValue();
inputs[5].setError(null);
} catch (NumberFormatException e) {
NekoXConfig.customDcFingerprint = 0;
inputs[5].setError("Invalid Fingerprint");
}
}
}
@Override
public void afterTextChanged(Editable s) {
}
});
if (dcType < 2) {
for (EditText input : inputs) input.setVisibility(View.GONE);
}
builder.addCancelButton();
builder.addButton(LocaleController.getString("Set", R.string.Set), (it) -> {
int target = targetDc.get();
if (target >= 2) {
if (inputs[0].getError() != null) {
inputs[0].requestFocus();
AndroidUtilities.showKeyboard(inputs[0]);
return Unit.INSTANCE;
} else if (inputs[1].getError() != null) {
inputs[1].requestFocus();
AndroidUtilities.showKeyboard(inputs[1]);
return Unit.INSTANCE;
} else if (NekoXConfig.customDcPort == 0) {
AlertUtil.showToast("Input Port");
inputs[2].setError("Port required");
inputs[2].requestFocus();
AndroidUtilities.showKeyboard(inputs[2]);
return Unit.INSTANCE;
} else if (NekoXConfig.customDcLayer == 0) {
AlertUtil.showToast("Input Layer");
inputs[3].setError("Layer required");
inputs[3].requestFocus();
AndroidUtilities.showKeyboard(inputs[3]);
return Unit.INSTANCE;
} else if (StrUtil.isBlank(NekoXConfig.customDcPublicKey)) {
AlertUtil.showToast("Input PublicKey");
inputs[4].setError("PublicKey required");
inputs[4].requestFocus();
AndroidUtilities.showKeyboard(inputs[5]);
return Unit.INSTANCE;
} else if (NekoXConfig.customDcFingerprint == 0L) {
AlertUtil.showToast("Input Fingerprint");
inputs[5].setError("Fingerprint required");
inputs[5].requestFocus();
AndroidUtilities.showKeyboard(inputs[5]);
return Unit.INSTANCE;
} else if (StrUtil.isBlank(NekoXConfig.customDcIpv4) && StrUtil.isBlank(NekoXConfig.customDcIpv6)) {
AlertUtil.showToast("Input Address");
inputs[0].requestFocus();
AndroidUtilities.showKeyboard(inputs[0]);
return Unit.INSTANCE;
} else {
builder.dismiss();
}
}
if (target == dcType) {
// do nothing
@ -886,18 +605,6 @@ public class LoginActivity extends BaseFragment implements NotificationCenter.No
DataCenter.applyTestDataCenter(currentAccount);
} else {
DataCenter.applyCustomDataCenter(currentAccount,
NekoXConfig.customDcIpv4,
NekoXConfig.customDcIpv6,
NekoXConfig.customDcPort,
NekoXConfig.customDcLayer,
NekoXConfig.customDcPublicKey,
NekoXConfig.customDcFingerprint);
NekoXConfig.saveCustomDc();
}
return Unit.INSTANCE;

78
TMessagesProj/src/main/java/tw/nekomimi/nekogram/DataCenter.kt
View File

@ -1,109 +1,31 @@
package tw.nekomimi.nekogram
import cn.hutool.crypto.digest.DigestUtil
import org.telegram.messenger.MessagesController
import org.telegram.tgnet.ConnectionsManager
import org.telegram.tgnet.SerializedData
import org.telegram.tgnet.TLRPC
import java.math.BigInteger
import java.nio.ByteBuffer
import java.security.interfaces.RSAPublicKey
object DataCenter {
// func calcAuthKeyId(keyData []byte) int64 {
// sha1 := Sha1Digest(keyData)
// // Lower 64 bits = 8 bytes of 20 byte SHA1 hash.
// return int64(binary.LittleEndian.Uint64(sha1[12:]))
// }
@JvmStatic
fun calcAuthKeyId(publicKey: RSAPublicKey): Long {
val key = SerializedData()
key.writeByteArray(publicKey.modulus.toByteArray())
key.writeByteArray(publicKey.publicExponent.toByteArray())
return BigInteger(DigestUtil.sha1(key.toByteArray()).slice(12 until 20).toByteArray()).toLong()
}
@JvmStatic
fun applyOfficalDataCanter(account: Int) {
MessagesController.getMainSettings(account).edit().remove("layer").remove("custom_dc").apply()
if (ConnectionsManager.native_isTestBackend(account) != 0) {
ConnectionsManager.getInstance(account).switchBackend()
}
applyDataCanter(account, 1, "149.154.175.50", "2001:b28:f23d:f001:0000:0000:0000:000a")
applyDataCanter(account, 2, "149.154.167.51", "2001:67c:4e8:f002:0000:0000:0000:000a")
applyDataCanter(account, 3, "149.154.175.100", "2001:b28:f23d:f003:0000:0000:0000:000a")
applyDataCanter(account, 4, "149.154.167.91", "2001:67c:4e8:f004:0000:0000:0000:000a")
applyDataCanter(account, 5, "149.154.171.5", "2001:67c:4e8:f005:0000:0000:0000:000a")
ConnectionsManager.native_cleanUp(account, true)
ConnectionsManager.native_setLayer(account, TLRPC.LAYER)
repeat(5) {
ConnectionsManager.native_setDatacenterPublicKey(account, it + 1, "", 0)
}
}
@JvmStatic
fun applyTestDataCenter(account: Int) {
MessagesController.getMainSettings(account).edit().remove("layer").remove("custom_dc").apply()
if (ConnectionsManager.native_isTestBackend(account) == 0) {
ConnectionsManager.getInstance(account).switchBackend()
}
ConnectionsManager.native_setLayer(account, TLRPC.LAYER)
}
@JvmStatic
fun applyCustomDataCenter(account: Int, ipv4Address: String = "", ipv6Address: String = "", port: Int, layer: Int, publicKey: String, fingerprint: Long) {
MessagesController.getMainSettings(account).edit().putInt("layer", layer).putBoolean("custom_dc", true).apply()
if (ConnectionsManager.native_isTestBackend(account) != 0) {
ConnectionsManager.getInstance(account).switchBackend()
}
repeat(5) {
ConnectionsManager.native_setDatacenterAddress(account, it + 1, ipv4Address, ipv6Address, port)
}
ConnectionsManager.native_saveDatacenters(account)
ConnectionsManager.native_setLayer(account, layer)
repeat(5) {
ConnectionsManager.native_setDatacenterPublicKey(account, it + 1, publicKey, fingerprint);
}
}
private fun applyDataCanter(account: Int, dataCenterId: Int, ipv4Address: String, ipv6Address: String, port: Int = 443) {
ConnectionsManager.native_setDatacenterAddress(account, dataCenterId, ipv4Address, ipv4Address, port)
}
}

6
TMessagesProj/src/main/res/values/strings_nekox.xml
View File

@ -47,12 +47,6 @@
<string name="CustomBackendNotice">This function is only provided for expert users, if you don\'t know what the following options represent, just ignore it.</string>
<string name="CustomBackendProduction">Official Production DataCenter</string>
<string name="CustomBackendTestDC">Official Test DataCenter</string>
<string name="CustomBackendIpv4">Ipv4 Address</string>
<string name="CustomBackendIpv6">Ipv6 Address</string>
<string name="CustomBackendLayer">Layer</string>
<string name="CustomBackendPublicKey">Public Key</string>
<string name="CustomBackendFingerprint">Key Fingerprint</string>
<string name="AllowFlashCall">Allow flash call</string>
<string name="ChangeTranslateProvider">Change Provider</string>