private static async Task AsyncMain()
{
SerializerService serializer = new SerializerService();
typeof(AuthLogonChallengeRequest).Assembly
.GetTypes()
.Where(t => typeof(AuthenticationServerPayload).IsAssignableFrom(t) || typeof(AuthenticationClientPayload).IsAssignableFrom(t))
.ToList()
.ForEach(t =>
{
serializer.RegisterType(t);
});
serializer.Compile();
//The auth server is encryptionless and headerless
IManagedNetworkClient <AuthenticationClientPayload, AuthenticationServerPayload> client = new DotNetTcpClientNetworkClient()
.AddHeaderlessNetworkMessageReading(new FreecraftCoreGladNetSerializerAdapter(serializer))
.For <AuthenticationServerPayload, AuthenticationClientPayload, IAuthenticationPayload>()
.Build()
.AsManaged(new ConsoleOutLogger("ConsoleLogger", LogLevel.All, true, false, false, null));
if (!await client.ConnectAsync("127.0.0.1", 3724))
{
Console.WriteLine("Failed to connect");
}
await client.SendMessage(new AuthLogonChallengeRequest(ProtocolVersion.ProtocolVersionTwo, GameType.WoW, ExpansionType.WrathOfTheLichKing, 3, 5,
ClientBuild.Wotlk_3_3_5a, PlatformType.x86, OperatingSystemType.Win, LocaleType.enUS,
IPAddress.Parse("127.0.0.1"), "Glader"));
while (true)
{
var response = (await client.ReadMessageAsync()).Payload;
Console.WriteLine("Recieved payload");
AuthenticationLogonChallengeResponseMessageHandler handler = new AuthenticationLogonChallengeResponseMessageHandler();
if (response is AuthLogonChallengeResponse challengeResponse)
{
Console.WriteLine($"Response: Valid: {challengeResponse.isValid} Result: {challengeResponse.Result} SRP: {challengeResponse.Challenge}");
await handler.HandleMessage(new DefaultPeerMessageContext <AuthenticationClientPayload>(client, client, new PayloadInterceptMessageSendService <AuthenticationClientPayload>(client, client)), challengeResponse);
}
else
{
Console.WriteLine($"Recieved Payload of Type: {response.GetType().Name}");
}
}
}
static async Task Main(string[] args)
{
ProtobufNetGladNetSerializerAdapter serializer = new ProtobufNetGladNetSerializerAdapter(PrefixStyle.Fixed32);
Unity3DProtobufPayloadRegister payloadRegister = new Unity3DProtobufPayloadRegister();
payloadRegister.RegisterDefaults();
payloadRegister.Register(ZoneServerMetadataMarker.ClientPayloadTypesByOpcode, ZoneServerMetadataMarker.ServerPayloadTypesByOpcode);
var client = new DotNetTcpClientNetworkClient()
.AddHeaderlessNetworkMessageReading(serializer)
.For <GameServerPacketPayload, GameClientPacketPayload, IGamePacketPayload>()
.Build()
.AsManaged(new ConsoleLogger(LogLevel.All));
await client.ConnectAsync(IPAddress.Parse("127.0.0.1"), 5006);
Thread.Sleep(3000);
Console.WriteLine("Enter Character ID for test:");
int characterId = int.Parse(Console.ReadLine());
await client.SendMessage(new ClientSessionClaimRequestPayload("Test", characterId));
int packetCount = 0;
try
{
while (true)
{
NetworkIncomingMessage <GameServerPacketPayload> message = await client.ReadMessageAsync()
.ConfigureAwait(false);
Console.WriteLine($"\n#{packetCount} - Recieved Message Type: {message.Payload.GetType().Name}");
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
private async Task InitializeNetworkingClient()
{
ContainerBuilder builder = new ContainerBuilder();
EncryptionLazyWithoutKeyDecorator <uint> encrypt = new EncryptionLazyWithoutKeyDecorator <uint>(val => new PatchServerCryptoProvider(PatchEncryptionKeyFactory.Create(val)), 4);
EncryptionLazyWithoutKeyDecorator <uint> decrypt = new EncryptionLazyWithoutKeyDecorator <uint>(val => new PatchServerCryptoProvider(PatchEncryptionKeyFactory.Create(val)), 4);
IFullCryptoInitializationService <uint> intializers = new SeperateAggregateCryptoInitializationService <uint>(encrypt, decrypt);
builder.RegisterInstance(intializers)
.As <IFullCryptoInitializationService <uint> >();
INetworkSerializationService serializerService = new FreecraftCoreGladNetSerializerAdapter(CreateSerializerService());
//Configurs and builds the clients without all the
//relevant decorators
IManagedNetworkClient <PSOBBPatchPacketPayloadClient, PSOBBPatchPacketPayloadServer> client = new DotNetTcpClientNetworkClient()
.AddCryptHandling(encrypt, decrypt)
.AddHeaderReading <PSOBBPacketHeader>(serializerService, 2)
.AddNetworkMessageReading(serializerService)
.For <PSOBBPatchPacketPayloadServer, PSOBBPatchPacketPayloadClient, IPacketPayload>(null)
.AddReadBufferClearing()
.Build()
.AsManaged();
builder.RegisterInstance(client)
.As <IManagedNetworkClient <PSOBBPatchPacketPayloadClient, PSOBBPatchPacketPayloadServer> >();
//Patch welcome message
builder.RegisterHandler <PatchWelcomeMessageHandler, PatchingWelcomePayload>();
builder.RegisterHandler <PatchingLoginReadyMessageHandler, PatchingReadyForLoginRequestPayload>();
builder.RegisterHandler <PatchingRedirectionMessageHandler, PatchingRedirectPayload>();
builder.RegisterHandler <PatchingInfoDoneMessageHandler, PatchingInfoRequestDonePayload>(async h =>
{
await Dispatcher.InvokeAsync(() => PlayButton.DataContext = h);
});
builder.RegisterHandler <PatchMessageMessageHandler, PatchingMessagePayload>(async h =>
{
await Dispatcher.InvokeAsync(() => PatchNotesData.DataContext = h);
});
IContainer container = builder.Build();
IEnumerable <IPeerMessageHandler <PSOBBPatchPacketPayloadServer, PSOBBPatchPacketPayloadClient> > Handlers =
container.Resolve <IEnumerable <IPeerMessageHandler <PSOBBPatchPacketPayloadServer, PSOBBPatchPacketPayloadClient> > >();
IPeerMessageContextFactory MessageContextFactory = new DefaultMessageContextFactory();
await client.ConnectAsync("158.69.215.131", 11000);
while (client.isConnected)
{
NetworkIncomingMessage <PSOBBPatchPacketPayloadServer> message = await client.ReadMessageAsync();
Console.WriteLine($"Recieved {message.Payload?.GetType().Name}");
foreach (var h in Handlers)
{
//TODO: Fix this and enable request service
if (await h.TryHandleMessage(MessageContextFactory.Create(client, client, null), message))
{
break;
}
}
}
}
