public NetworkClientPacketPayloadReaderWriterDecorator(TClientType decoratedClient, THeaderReaderWriterType headerReaderWriter, INetworkSerializationService serializer, IPacketHeaderFactory <TPayloadConstraintType> packetHeaderFactory, int payloadBufferSize = 30000)
{
if (decoratedClient == null)
{
throw new ArgumentNullException(nameof(decoratedClient));
}
if (serializer == null)
{
throw new ArgumentNullException(nameof(serializer));
}
if (packetHeaderFactory == null)
{
throw new ArgumentNullException(nameof(packetHeaderFactory));
}
if (payloadBufferSize <= 0)
{
throw new ArgumentOutOfRangeException(nameof(payloadBufferSize));
}
DecoratedClient = decoratedClient;
Serializer = serializer;
PacketHeaderFactory = packetHeaderFactory;
HeaderReaderWriter = headerReaderWriter;
//One of the lobby packets is 14,000 bytes. We may even need bigger.
PacketPayloadReadBuffer = new byte[payloadBufferSize]; //TODO: Do we need a larger buffer for any packets?
}
//We shouldn't expect the deserialize to provide always non-null values.
//That is a serialization implementation detail.
/// <summary>
/// Attempts to deserialize to <typeparamref name="TTypeToDeserializeTo"/> from the provided <see cref="byte[]"/>.
/// </summary>
/// <typeparam name="TTypeToDeserializeTo"></typeparam>
/// <param name="serializer"></param>
/// <param name="data">Byte repsentation of <typeparamref name="TTypeToDeserializeTo"/>.</param>
/// <returns>An instance of <typeparamref name="TTypeToDeserializeTo"/> or null if failed.</returns>
public static TTypeToDeserializeTo Deserialize <TTypeToDeserializeTo>(this INetworkSerializationService serializer, byte[] data)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
return(serializer.Deserialize <TTypeToDeserializeTo>(data, 0, data.Length));
}
public HackyInstanceSharedClientData([NotNull] INetworkSerializationService serializerService,
[JetBrains.Annotations.NotNull] MessageHandlerService <GameServerPacketPayload, GameClientPacketPayload> messageHandler,
[JetBrains.Annotations.NotNull] IPeerMessageContextFactory messageContextFactory,
[JetBrains.Annotations.NotNull] IConnectionService connectionService,
[JetBrains.Annotations.NotNull] IPeerPayloadSendService <GameClientPacketPayload> sendService)
{
SerializerService = serializerService ?? throw new ArgumentNullException(nameof(serializerService));
MessageHandler = messageHandler ?? throw new ArgumentNullException(nameof(messageHandler));
MessageContextFactory = messageContextFactory ?? throw new ArgumentNullException(nameof(messageContextFactory));
ConnectionService = connectionService ?? throw new ArgumentNullException(nameof(connectionService));
SendService = sendService ?? throw new ArgumentNullException(nameof(sendService));
}
public HeaderlessNetworkMessageClientBuilder(INetworkSerializationService serializer, TNetworkType client)
{
if (serializer == null)
{
throw new ArgumentNullException(nameof(serializer));
}
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
Serializer = serializer;
Client = client;
}
public Extended317UnmanagedNetworkClient(TClientType decoratedClient, INetworkSerializationService serializer, ILog logger, int payloadBufferSize = 30000)
{
if (payloadBufferSize <= 0)
{
throw new ArgumentOutOfRangeException(nameof(payloadBufferSize));
}
DecoratedClient = decoratedClient ?? throw new ArgumentNullException(nameof(decoratedClient));
Serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
//One of the lobby packets is 14,000 bytes. We may even need bigger.
PacketPayloadReadBuffer = new byte[payloadBufferSize]; //TODO: Do we need a larger buffer for any packets?
}
/// <inheritdoc />
public AuthRealmListRequestHandler([NotNull] IRepositoryServiceFactory <IAuthenticationRealmRepository> realmListService, [NotNull] ILog logger, INetworkSerializationService serializer)
{
if (realmListService == null)
{
throw new ArgumentNullException(nameof(realmListService));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
RealmListService = realmListService;
Logger = logger;
Serializer = serializer;
}
public NetworkMessageClientBuilder(INetworkSerializationService serializer, TNetworkType client, THeaderReaderWriterType headerReaderWriter)
{
if (serializer == null)
{
throw new ArgumentNullException(nameof(serializer));
}
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
if (headerReaderWriter == null)
{
throw new ArgumentNullException(nameof(headerReaderWriter));
}
Serializer = serializer;
Client = client;
HeaderReaderWriter = headerReaderWriter;
}
/// <summary>
/// </summary>
/// <param name="decoratedClient">The client to decorate.</param>
/// <param name="serializer"></param>
/// <param name="headerSize"></param>
public NetworkClientPacketHeaderReaderWriterDecorator(NetworkClientBase decoratedClient, INetworkSerializationService serializer, int headerSize)
{
if (decoratedClient == null)
{
throw new ArgumentNullException(nameof(decoratedClient));
}
if (serializer == null)
{
throw new ArgumentNullException(nameof(serializer));
}
if (headerSize < 0)
{
throw new ArgumentOutOfRangeException(nameof(headerSize));
}
//We need to support up to the maximum block
PacketHeaderBuffer = new byte[headerSize];
DecoratedClient = decoratedClient;
Serializer = serializer;
}
public WoWClientWriteServerReadProxyPacketPayloadReaderWriterDecorator(TClientType decoratedClient, INetworkSerializationService serializer, ICombinedSessionPacketCryptoService cryptoService, int payloadBufferSize = 30000)
{
if (decoratedClient == null)
{
throw new ArgumentNullException(nameof(decoratedClient));
}
if (serializer == null)
{
throw new ArgumentNullException(nameof(serializer));
}
if (payloadBufferSize <= 0)
{
throw new ArgumentOutOfRangeException(nameof(payloadBufferSize));
}
DecoratedClient = decoratedClient;
Serializer = serializer;
CryptoService = cryptoService;
//One of the lobby packets is 14,000 bytes. We may even need bigger.
PacketPayloadReadBuffer = new byte[payloadBufferSize]; //TODO: Do we need a larger buffer for any packets?
}
/// <inheritdoc />
protected override IManagedNetworkServerClient <AuthenticationServerPayload, AuthenticationClientPayload> BuildIncomingSessionManagedClient(NetworkClientBase clientBase, INetworkSerializationService serializeService)
{
//TODO: Are any details actually valuable here?
if (Logger.IsInfoEnabled)
{
Logger.Info($"Client connected to proxy.");
}
//The auth server is encryptionless and 'headerless' so we do not need to support that on the proxy for the auth server
return(clientBase
.AddHeaderlessNetworkMessageReading(serializeService)
.For <AuthenticationClientPayload, AuthenticationServerPayload, IAuthenticationPayload>()
.Build()
.AsManagedSession(Logger));
}
/// <summary>
/// Enables header reading functionality to a client.
/// </summary>
/// <typeparam name="TNetworkClientType">The client type.</typeparam>
/// <param name="client">The client to add header reading to.</param>
/// <returns>A client that can read headers from the network.</returns>
public static HeaderlessNetworkMessageClientBuilder <TNetworkClientType> AddHeaderlessNetworkMessageReading <TNetworkClientType>(this TNetworkClientType client, INetworkSerializationService serializer)
where TNetworkClientType : NetworkClientBase
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
if (serializer == null)
{
throw new ArgumentNullException(nameof(serializer));
}
//New netmessage client builder
return(new HeaderlessNetworkMessageClientBuilder <TNetworkClientType>(serializer, client));
}
/// <summary>
/// Implementer should build the <see cref="IManagedNetworkClient{TPayloadWriteType,TPayloadReadType}"/>
/// for the outgoing client.
/// </summary>
/// <param name="clientBase">The client base to use.</param>
/// <param name="serializeService">The serializer to use.</param>
/// <returns>The built managed client.</returns>
protected abstract IManagedNetworkClient <TPayloadReadType, TPayloadWriteType> BuildOutgoingSessionManagedClient(NetworkClientBase clientBase, INetworkSerializationService serializeService);
/// <inheritdoc />
public NetworkSerializerServicePair([NotNull] INetworkSerializationService proxiedClientSerializer, [NotNull] INetworkSerializationService proxiedServerSerializer)
{
ProxiedClientSerializer = proxiedClientSerializer ?? throw new ArgumentNullException(nameof(proxiedClientSerializer));
ProxiedServerSerializer = proxiedServerSerializer ?? throw new ArgumentNullException(nameof(proxiedServerSerializer));
}
/// <summary>
/// Enables header reading functionality to a client.
/// </summary>
/// <param name="client">The client to add header reading to.</param>
/// <returns>A client that can read headers from the network.</returns>
public static NetworkClientPacketHeaderReaderWriterDecorator <TPacketHeaderType> AddHeaderReading <TPacketHeaderType>(this NetworkClientBase client, INetworkSerializationService serializer, int headerSize)
where TPacketHeaderType : IPacketHeader
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
if (serializer == null)
{
throw new ArgumentNullException(nameof(serializer));
}
return(new NetworkClientPacketHeaderReaderWriterDecorator <TPacketHeaderType>(client, serializer, headerSize));
}
/// <inheritdoc />
protected override IManagedNetworkServerClient <GamePacketPayload, GamePacketPayload> BuildIncomingSessionManagedClient(NetworkClientBase clientBase, INetworkSerializationService serializeService)
{
//TODO: Are any details actually valuable here?
if (Logger.IsInfoEnabled)
{
Logger.Info($"Client connected to proxy.");
}
SRP6SessionKeyStore keyStore = ServiceContainer.Resolve <SRP6SessionKeyStore>();
ICombinedSessionPacketCryptoService cryptoService = BuildIncomingPacketCryptoService(keyStore);
var wowClientReadServerWrite = new WoWClientReadServerWriteProxyPacketPayloadReaderWriterDecorator <NetworkClientBase, GamePacketPayload, GamePacketPayload, IGamePacketPayload>(clientBase, serializeService, cryptoService, Logger);
return(new ManagedNetworkServerClient <WoWClientReadServerWriteProxyPacketPayloadReaderWriterDecorator <NetworkClientBase, GamePacketPayload, GamePacketPayload, IGamePacketPayload>, GamePacketPayload, GamePacketPayload>(wowClientReadServerWrite, Logger));
}
public Test([NotNull] RsUnityClient client, [NotNull] INetworkSerializationService serializerService)
{
Client = client ?? throw new ArgumentNullException(nameof(client));
SerializerService = serializerService ?? throw new ArgumentNullException(nameof(serializerService));
}
/// <inheritdoc />
protected override IManagedNetworkClient <PSOBBGamePacketPayloadClient, PSOBBGamePacketPayloadServer> BuildOutgoingSessionManagedClient(NetworkClientBase clientBase, INetworkSerializationService serializeService)
{
//Copied from the test client project
IManagedNetworkClient <PSOBBGamePacketPayloadClient, PSOBBGamePacketPayloadServer> client = clientBase
.AddCryptHandling(ServerEncryptionService, ServerDecryptionService)
.AddBufferredWrite(4)
.AddHeaderReading <PSOBBPacketHeader>(serializeService, 2)
.AddNetworkMessageReading(serializeService)
.For <PSOBBGamePacketPayloadServer, PSOBBGamePacketPayloadClient, IPacketPayload>(new PSOBBPacketHeaderFactory())
.AddReadBufferClearing()
.Build()
.AsManagedSession();
return(client);
}
/// <inheritdoc />
protected override IManagedNetworkServerClient <PSOBBGamePacketPayloadServer, PSOBBGamePacketPayloadClient> BuildIncomingSessionManagedClient(NetworkClientBase clientBase, INetworkSerializationService serializeService)
{
ResetCrypto();
Logger.Info($"Client connecting to Proxy App with Listener: {this.ServerAddress.AddressEndpoint}:{this.ServerAddress.Port}");
IManagedNetworkServerClient <PSOBBGamePacketPayloadServer, PSOBBGamePacketPayloadClient> session = clientBase
.AddCryptHandling(ClientEncryptionService, ClientDecryptionService)
.AddBufferredWrite(4)
.AddHeaderReading <PSOBBPacketHeader>(serializeService, 2)
.AddNetworkMessageReading(serializeService)
.For <PSOBBGamePacketPayloadClient, PSOBBGamePacketPayloadServer, IPacketPayload>(new PSOBBPacketHeaderFactory())
.AddReadBufferClearing()
.Build()
.AsManagedSession();
return(session);
}
/// <inheritdoc />
public DefaultManagedSessionFactory([NotNull] INetworkSerializationService serializer, [NotNull] ILog logger)
{
Serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
/// <inheritdoc />
protected override IManagedNetworkClient <GamePacketPayload, GamePacketPayload> BuildOutgoingSessionManagedClient(NetworkClientBase clientBase, INetworkSerializationService serializeService)
{
SRP6SessionKeyStore keyStore = ServiceContainer.Resolve <SRP6SessionKeyStore>();
ICombinedSessionPacketCryptoService cryptoService = BuildOutgoingPacketCryptoService(keyStore);
var wowClientReadServerWrite = new WoWClientWriteServerReadProxyPacketPayloadReaderWriterDecorator <NetworkClientBase, GamePacketPayload, GamePacketPayload, IGamePacketPayload>(clientBase, serializeService, cryptoService);
return(new ManagedNetworkServerClient <WoWClientWriteServerReadProxyPacketPayloadReaderWriterDecorator <NetworkClientBase, GamePacketPayload, GamePacketPayload, IGamePacketPayload>, GamePacketPayload, GamePacketPayload>(wowClientReadServerWrite, Logger));
}
/// <inheritdoc />
public VanillaWoWClientReadServerWriteProxyPacketPayloadReaderWriterDecorator(TClientType decoratedClient, INetworkSerializationService serializer, ICombinedSessionPacketCryptoService cryptoService, int payloadBufferSize = 30000)
: base(decoratedClient, serializer, cryptoService, payloadBufferSize)
{
}
/// <inheritdoc />
protected override IManagedNetworkClient <AuthenticationClientPayload, AuthenticationServerPayload> BuildOutgoingSessionManagedClient(NetworkClientBase clientBase, INetworkSerializationService serializeService)
{
//We need to create an actual client to the server too.
return(clientBase
.AddHeaderlessNetworkMessageReading(serializeService)
.For <AuthenticationServerPayload, AuthenticationClientPayload, IAuthenticationPayload>()
.Build()
.AsManagedSession(Logger));
}
