203 lines
7.1 KiB
C++
203 lines
7.1 KiB
C++
#include "network/network.h"
|
|
#include <iostream>
|
|
#include <cassert>
|
|
#include <cstring>
|
|
|
|
using namespace metin2::network;
|
|
|
|
void TestPhaseStateMachine() {
|
|
std::cout << "[Test] Phase State Machine...\n";
|
|
PhaseStateMachine fsm;
|
|
assert(fsm.GetCurrentPhase() == ConnectionPhase::Disconnected);
|
|
assert(!fsm.IsConnected());
|
|
|
|
// Invalid transition
|
|
assert(!fsm.CanTransitionTo(ConnectionPhase::InGame));
|
|
|
|
// Valid flow: Disconnected -> Handshake -> Auth -> CharacterSelect -> GameLoading -> InGame
|
|
assert(fsm.TransitionTo(ConnectionPhase::Handshake));
|
|
assert(fsm.GetCurrentPhase() == ConnectionPhase::Handshake);
|
|
assert(fsm.IsConnected());
|
|
|
|
assert(fsm.TransitionTo(ConnectionPhase::Auth));
|
|
assert(fsm.TransitionTo(ConnectionPhase::CharacterSelect));
|
|
assert(fsm.TransitionTo(ConnectionPhase::GameLoading));
|
|
assert(fsm.TransitionTo(ConnectionPhase::InGame));
|
|
assert(fsm.IsInGame());
|
|
|
|
// Disconnect from anywhere
|
|
assert(fsm.TransitionTo(ConnectionPhase::Disconnected));
|
|
assert(!fsm.IsConnected());
|
|
std::cout << " -> Phase transitions passed!\n";
|
|
}
|
|
|
|
void TestCipher() {
|
|
std::cout << "[Test] TEA & Rolling XOR Cipher...\n";
|
|
TeaKey key = { 0x12345678, 0x9ABCDEF0, 0x0FEDCBA9, 0x87654321 };
|
|
TeaCipher tea(key);
|
|
|
|
std::string text = "Metin2 cross-platform network packet payload encryption!";
|
|
std::vector<uint8_t> plain(text.begin(), text.end());
|
|
|
|
auto encrypted = tea.Encrypt(plain);
|
|
assert(encrypted.size() >= plain.size());
|
|
assert(encrypted.size() % 8 == 0);
|
|
|
|
auto decrypted = tea.Decrypt(encrypted);
|
|
assert(std::memcmp(plain.data(), decrypted.data(), plain.size()) == 0);
|
|
|
|
// Rolling XOR
|
|
RollingXorCipher xor_cipher1(0xA5A55A5A);
|
|
RollingXorCipher xor_cipher2(0xA5A55A5A);
|
|
std::vector<uint8_t> xor_buf(plain.begin(), plain.end());
|
|
|
|
xor_cipher1.Process(xor_buf.data(), xor_buf.size());
|
|
assert(std::memcmp(plain.data(), xor_buf.data(), plain.size()) != 0);
|
|
|
|
xor_cipher2.Process(xor_buf.data(), xor_buf.size());
|
|
assert(std::memcmp(plain.data(), xor_buf.data(), plain.size()) == 0);
|
|
|
|
std::cout << " -> Cipher encryption and decryption passed!\n";
|
|
}
|
|
|
|
void TestPacketSegmentationAndReassembly() {
|
|
std::cout << "[Test] Packet Buffer Fragmentation & Reassembly...\n";
|
|
PacketRegistry registry;
|
|
PacketBuffer buffer;
|
|
|
|
// 1. Pack multiple packets into one stream (Sticky packets / 粘包)
|
|
// Packet A: HEADER_GC_PING (header=253, 4 bytes payload)
|
|
// Packet B: HEADER_CG_CHARACTER_SELECT (header=6, 1 byte payload)
|
|
uint32_t ping_id = 9999;
|
|
uint8_t char_slot = 2;
|
|
|
|
std::vector<uint8_t> sticky_stream;
|
|
sticky_stream.push_back(HEADER_GC_PING);
|
|
const uint8_t* p_ping = reinterpret_cast<const uint8_t*>(&ping_id);
|
|
sticky_stream.insert(sticky_stream.end(), p_ping, p_ping + 4);
|
|
|
|
sticky_stream.push_back(HEADER_CG_CHARACTER_SELECT);
|
|
sticky_stream.push_back(char_slot);
|
|
|
|
buffer.Append(sticky_stream);
|
|
auto packets = buffer.ExtractPackets(registry);
|
|
assert(packets.size() == 2);
|
|
assert(packets[0].header == HEADER_GC_PING);
|
|
assert(packets[0].payload.size() == 4);
|
|
assert(*reinterpret_cast<const uint32_t*>(packets[0].payload.data()) == 9999);
|
|
assert(packets[1].header == HEADER_CG_CHARACTER_SELECT);
|
|
assert(packets[1].payload[0] == 2);
|
|
|
|
// 2. Partial packets (半包)
|
|
// Send 1st half of a packet
|
|
std::vector<uint8_t> half1;
|
|
half1.push_back(HEADER_GC_PING);
|
|
half1.push_back(0x11);
|
|
half1.push_back(0x22);
|
|
buffer.Append(half1);
|
|
|
|
auto partial = buffer.ExtractPackets(registry);
|
|
assert(partial.empty()); // Not complete yet
|
|
|
|
// Send 2nd half
|
|
std::vector<uint8_t> half2;
|
|
half2.push_back(0x33);
|
|
half2.push_back(0x44);
|
|
buffer.Append(half2);
|
|
|
|
auto completed = buffer.ExtractPackets(registry);
|
|
assert(completed.size() == 1);
|
|
assert(completed[0].header == HEADER_GC_PING);
|
|
assert(completed[0].payload[0] == 0x11 && completed[0].payload[3] == 0x44);
|
|
|
|
std::cout << " -> Packet segmentation and reassembly passed!\n";
|
|
}
|
|
|
|
void TestNetworkClientEndToEnd() {
|
|
std::cout << "[Test] NetworkClient Full Protocol Pipeline...\n";
|
|
NetworkClient client;
|
|
|
|
bool handshake_called = false;
|
|
bool auth_called = false;
|
|
std::string received_chat;
|
|
|
|
client.SetOnHandshake([&](uint32_t s_time) {
|
|
handshake_called = true;
|
|
assert(s_time == 12345678);
|
|
});
|
|
|
|
client.SetOnAuthResult([&](bool success, uint32_t err, const std::string& msg) {
|
|
auth_called = true;
|
|
assert(success);
|
|
});
|
|
|
|
client.SetOnChat([&](uint32_t sender, uint8_t type, const std::string& msg) {
|
|
received_chat = msg;
|
|
});
|
|
|
|
// Client connects -> Handshake phase
|
|
client.SetPhase(ConnectionPhase::Handshake);
|
|
assert(client.GetPhase() == ConnectionPhase::Handshake);
|
|
|
|
// Server sends GC_HANDSHAKE (header 255, 8 bytes: time=12345678, delta=0)
|
|
std::vector<uint8_t> server_handshake;
|
|
server_handshake.push_back(HEADER_GC_HANDSHAKE);
|
|
uint32_t s_time = 12345678;
|
|
uint32_t delta = 0;
|
|
const uint8_t* p_st = reinterpret_cast<const uint8_t*>(&s_time);
|
|
const uint8_t* p_dt = reinterpret_cast<const uint8_t*>(&delta);
|
|
server_handshake.insert(server_handshake.end(), p_st, p_st + 4);
|
|
server_handshake.insert(server_handshake.end(), p_dt, p_dt + 4);
|
|
|
|
client.PushReceivedData(server_handshake.data(), server_handshake.size());
|
|
assert(handshake_called);
|
|
|
|
// Client responds with Handshake Ack
|
|
client.SendHandshakeAck(87654321);
|
|
assert(client.HasPendingSendData());
|
|
auto out_data = client.PopSendData();
|
|
assert(!out_data.empty());
|
|
assert(out_data[0] == HEADER_CG_HANDSHAKE);
|
|
|
|
// Move to Auth phase & authenticate
|
|
client.SetPhase(ConnectionPhase::Auth);
|
|
client.SendLogin("player_tester", "secret_pass");
|
|
auto login_send = client.PopSendData();
|
|
assert(login_send[0] == HEADER_CG_LOGIN);
|
|
|
|
// Server sends Auth success (HEADER_GC_AUTH_SUCCESS: header 101, account_id 42)
|
|
std::vector<uint8_t> auth_resp;
|
|
auth_resp.push_back(HEADER_GC_AUTH_SUCCESS);
|
|
uint32_t account_id = 42;
|
|
const uint8_t* p_acc = reinterpret_cast<const uint8_t*>(&account_id);
|
|
auth_resp.insert(auth_resp.end(), p_acc, p_acc + 4);
|
|
client.PushReceivedData(auth_resp.data(), auth_resp.size());
|
|
assert(auth_called);
|
|
assert(client.GetPhase() == ConnectionPhase::CharacterSelect);
|
|
|
|
// Server sends Chat dynamic packet
|
|
std::string test_msg = "Welcome to Metin2 World!";
|
|
std::vector<uint8_t> chat_pkt;
|
|
chat_pkt.push_back(HEADER_GC_CHAT);
|
|
uint16_t chat_len = static_cast<uint16_t>(1 + test_msg.size());
|
|
chat_pkt.push_back(chat_len & 0xFF);
|
|
chat_pkt.push_back((chat_len >> 8) & 0xFF);
|
|
chat_pkt.push_back(1); // chat type
|
|
chat_pkt.insert(chat_pkt.end(), test_msg.begin(), test_msg.end());
|
|
|
|
client.PushReceivedData(chat_pkt.data(), chat_pkt.size());
|
|
assert(received_chat == test_msg);
|
|
|
|
std::cout << " -> NetworkClient pipeline passed!\n";
|
|
}
|
|
|
|
int main() {
|
|
std::cout << "=== Running Metin2 Network SDK Tests ===\n";
|
|
TestPhaseStateMachine();
|
|
TestCipher();
|
|
TestPacketSegmentationAndReassembly();
|
|
TestNetworkClientEndToEnd();
|
|
std::cout << "All Network SDK Tests PASSED!\n";
|
|
return 0;
|
|
}
|