public AuthenticationResult Authenticate(IUnsafePacketReader credentialsReader, out IAccountSession session, out Account account)
{
session = null;
account = null;
var username = credentialsReader.ReadLengthString();
if (username != "admin")
{
return(AuthenticationResult.NotRegistered);
}
var password = credentialsReader.ReadLengthString();
if (password != "admin")
{
return(AuthenticationResult.IncorrectPassword);
}
session = new StubAccountSession();
account = new Account()
{
AccountId = 1,
UserName = "******",
Password = "******",
Gender = Gender.Male,
GameMasterLevel = GameMasterLevel.GameMaster,
Status = AccountStatus.Active,
AccountPin = "0000",
};
return(AuthenticationResult.Success);
}
private bool CheckPin(IUnsafePacketReader reader)
{
string suggested = reader.ReadLengthString();
string expected = this.Account.AccountPin;
var isValid = suggested == expected;
return isValid;
}
private bool CheckPin(IUnsafePacketReader reader)
{
string suggested = reader.ReadLengthString();
string expected = Account.AccountPin;
var isValid = suggested == expected;
return isValid;
}
public AuthenticationResult Authenticate(IUnsafePacketReader credentialsReader, out IAccountSession session, out Account account)
{
session = null;
account = null;
var username = credentialsReader.ReadLengthString();
if (username != "admin")
{
return AuthenticationResult.NotRegistered;
}
var password = credentialsReader.ReadLengthString();
if (password != "admin")
{
return AuthenticationResult.IncorrectPassword;
}
session = new StubAccountSession();
account = new Account()
{
AccountId = 1,
UserName = "******",
Password = "******",
Gender = Gender.Male,
GameMasterLevel = GameMasterLevel.GameMaster,
Status = AccountStatus.Active,
AccountPin = "0000",
};
return AuthenticationResult.Success;
}
/// <summary>
/// Reads a byte corresponding to a <typeparamref name="TEnum" /> value decorated with <see cref="PacketValueAttribute"/>.
/// </summary>
/// <typeparam name="TEnum">The target <see langword="enum" /> type.</typeparam>
/// <param name="reader">The reader to use.</param>
/// <inheritdoc cref="PacketReader.ReadByte()" select="exception[@cref='PacketReadingException']" />
/// <returns>the corresponding <typeparamref name="TEnum" /> value.</returns>
public static TEnum ReadByte <TEnum>(this IUnsafePacketReader reader)
where TEnum : struct
{
Guard.NotNull(() => reader, reader);
return(reader.ReadByte().ToEnumValue <TEnum>());
}
// You may use these as samples for writing custom readers/writers.
// Just write an extension method to PacketReader or PacketBuilder (or one of their interfaces like below) and it works! Magic!
/// <summary>
/// Reads a <see cref="PointS"/>.
/// </summary>
/// <param name="reader">The <see cref="IUnsafePacketReader">packet reader</see> to use.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="reader"/> is <see langword="null"/>.</exception>
/// <returns>a <see cref="PointS"/> that was read.</returns>
public static PointS ReadVector(this IUnsafePacketReader reader)
{
Guard.NotNull(() => reader, reader);
var x = reader.ReadInt16();
var y = reader.ReadInt16();
return(new PointS(x, y));
}
/// <summary>
/// Reads a flags instance.
/// </summary>
/// <typeparam name="TFlags">The <see cref="Flags"/>-derived type to read into.</typeparam>
/// <param name="reader">The reader to use.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="reader"/> is <see langword="null"/>.</exception>
public static TFlags ReadFlags <TFlags>(this IUnsafePacketReader reader)
where TFlags : Flags, new()
{
Guard.NotNull(() => reader, reader);
var flags = new TFlags();
flags.Read(reader);
return(flags);
}
private void HandleAuthentication(IUnsafePacketReader reader)
{
if (State != AuthClientState.NotLoggedIn)
{
Disconnect("Invalid client authentication state.");
return;
}
// TODO: more stuff to read, later.
IAccountSession accountSession;
Account account;
var result = _authenticator.Authenticate(reader, out accountSession, out account);
if (result == AuthenticationResult.Success)
{
AccountSession = accountSession;
Account = account;
if (!account.Gender.HasValue)
{
State = AuthClientState.SetGender;
}
else
{
// TODO: cover cases where further authentication is not required and this should be set to LoggedIn.
if (account.AccountPin == null)
{
State = AuthClientState.SetPin;
}
else
{
State = AuthClientState.AskPin;
}
}
}
else if (LoginAttempts++ > MaxLoginAttempts)
{
Disconnect("Too many login attempts.");
return;
}
ServerSession.WritePacket(AuthResponse(result, account));
ServerSession.WritePacket(CheckPinResponse());
}
private void HandlePinValidation(IUnsafePacketReader reader)
{
// TODO: Configuring the server to not require PINs.
var action = reader.ReadByte <PinRequestType>();
reader.Skip(5);
switch (action)
{
case PinRequestType.PinNotSet:
State = AuthClientState.AskPin;
ServerSession.WritePacket(SetPinResponse());
break;
case PinRequestType.CheckPin:
if (CheckPin(reader))
{
State = AuthClientState.LoggedIn;
ServerSession.WritePacket(PinAcceptedResponse());
}
else
{
ServerSession.WritePacket(InvalidPinResponse());
}
break;
case PinRequestType.AssignPin:
if (CheckPin(reader))
{
State = AuthClientState.LoggedIn;
ServerSession.WritePacket(SetPinResponse());
}
else
{
ServerSession.WritePacket(InvalidPinResponse());
}
break;
}
}
/// <exception cref="ArgumentNullException">Thrown if <paramref name="reader"/> is <see langword="null"/>.</exception>
/// <inheritdoc />
public override sealed void Read(IUnsafePacketReader reader)
{
Guard.NotNull(() => reader, reader);
int bitCount = this.Bits.Length;
int numberCount = bitCount / LongBitCount;
for (int i = 0; i < numberCount; i++)
{
ulong number = reader.ReadUInt64();
int startIndex = i * LongBitCount;
int endIndex = Math.Min(startIndex + LongBitCount, bitCount);
for (int j = startIndex; j < endIndex; j++)
{
this.Bits[j] = Convert.ToBoolean(number & 1);
number >>= 1;
}
}
}
/// <exception cref="ArgumentNullException">Thrown if <paramref name="reader"/> is <see langword="null"/>.</exception>
/// <inheritdoc />
public sealed override void Read(IUnsafePacketReader reader)
{
Guard.NotNull(() => reader, reader);
int bitCount = Bits.Length;
int numberCount = bitCount / LongBitCount;
for (int i = 0; i < numberCount; i++)
{
ulong number = reader.ReadUInt64();
int startIndex = i * LongBitCount;
int endIndex = Math.Min(startIndex + LongBitCount, bitCount);
for (int j = startIndex; j < endIndex; j++)
{
Bits[j] = Convert.ToBoolean(number & 1);
number >>= 1;
}
}
}
/// <inheritdoc />
public AuthenticationResult Authenticate(IUnsafePacketReader credentialsReader, out IAccountSession session, out Account account)
{
// Default value for failure scenarios:
session = null;
// TODO: user name validation, throw IllegalPacketException if not valid
var userName = credentialsReader.ReadLengthString();
// Attempt to load the account.
account = _accountProvider.LoadByUserName(userName);
if (account == null)
{
// Fail with 'NotRegistered' if no account matches.
return(AuthenticationResult.NotRegistered);
}
// TODO: password validation, throw IllegalPacketException if not valid
var password = credentialsReader.ReadLengthString();
string hash = LoginCrypto.GetMd5HashString(password, true);
if (!string.Equals(hash, account.Password, StringComparison.Ordinal))
{
// Fail with 'IncorrectPassword' if password hash is bad.
return(AuthenticationResult.IncorrectPassword);
}
// TODO: read other stuff from packet
int sessionId;
if (!_accountService.TryRegisterSession(account.AccountId, out sessionId))
{
// Fail with 'AlreadyLoggedIn' if there is another session running on this account.
return(AuthenticationResult.AlreadyLoggedIn);
}
// Create the session.
session = new AccountSession(_accountService, sessionId, account);
return(AuthenticationResult.Success);
}
/// <inheritdoc />
public AuthenticationResult Authenticate(IUnsafePacketReader credentialsReader, out IAccountSession session, out Account account)
{
// Default value for failure scenarios:
session = null;
// TODO: user name validation, throw IllegalPacketException if not valid
var userName = credentialsReader.ReadLengthString();
// Attempt to load the account.
account = this.accountProvider.LoadByUserName(userName);
if (account == null)
{
// Fail with 'NotRegistered' if no account matches.
return AuthenticationResult.NotRegistered;
}
// TODO: password validation, throw IllegalPacketException if not valid
var password = credentialsReader.ReadLengthString();
string hash = LoginCrypto.GetMd5HashString(password, true);
if (!string.Equals(hash, account.Password, StringComparison.Ordinal))
{
// Fail with 'IncorrectPassword' if password hash is bad.
return AuthenticationResult.IncorrectPassword;
}
// TODO: read other stuff from packet
int sessionId;
if (!this.accountService.TryRegisterSession(account.AccountId, out sessionId))
{
// Fail with 'AlreadyLoggedIn' if there is another session running on this account.
return AuthenticationResult.AlreadyLoggedIn;
}
// Create the session.
session = new AccountSession(this.accountService, sessionId, account);
return AuthenticationResult.Success;
}
private static int FailingReturningRead(IUnsafePacketReader reader)
{
reader.Skip(reader.Remaining - 1);
return(reader.ReadInt32());
}
private void HandleWorldListRequest(IUnsafePacketReader reader)
{
ServerSession.WritePacket(WorldListResponse());
}
private void HandleCharacterListRequest(IUnsafePacketReader reader)
{
throw new NotImplementedException();
}
/// <summary> /// Reads the flag bits from the specified <see cref="IUnsafePacketReader"/>. /// </summary> /// <param name="reader">The reader to use.</param> public abstract void Read(IUnsafePacketReader reader);
private void HandleWorldListRequest(IUnsafePacketReader reader)
{
this.ServerSession.WritePacket(this.WorldListResponse());
}
/// <summary> /// Reads the flag bits from the specified <see cref="IUnsafePacketReader"/>. /// </summary> /// <param name="reader">The reader to use.</param> public abstract void Read(IUnsafePacketReader reader);
private void HandlePinAssignment(IUnsafePacketReader reader)
{
throw new NotImplementedException();
}
private void HandleCharacterSelect(IUnsafePacketReader reader)
{
throw new NotImplementedException();
}
private void HandleAuthentication(IUnsafePacketReader reader)
{
if (this.State != AuthClientState.NotLoggedIn)
{
this.Disconnect("Invalid client authentication state.");
return;
}
// TODO: more stuff to read, later.
IAccountSession accountSession;
Account account;
var result = this.authenticator.Authenticate(reader, out accountSession, out account);
if (result == AuthenticationResult.Success)
{
this.AccountSession = accountSession;
this.Account = account;
if (!account.Gender.HasValue)
{
this.State = AuthClientState.SetGender;
}
else
{
// TODO: cover cases where further authentication is not required and this should be set to LoggedIn.
if (account.AccountPin == null)
{
this.State = AuthClientState.SetPin;
}
else
{
this.State = AuthClientState.AskPin;
}
}
}
else if (this.LoginAttempts++ > MaxLoginAttempts)
{
this.Disconnect("Too many login attempts.");
return;
}
this.ServerSession.WritePacket(this.AuthResponse(result, account));
this.ServerSession.WritePacket(this.CheckPinResponse());
}
private static int FailingReturningRead(IUnsafePacketReader reader)
{
reader.Skip(reader.Remaining - 1);
return reader.ReadInt32();
}
private void HandleChannelSelect(IUnsafePacketReader reader)
{
throw new NotImplementedException();
}
private static void FailingRead(IUnsafePacketReader reader)
{
reader.Skip(reader.Remaining - 1);
reader.ReadInt32();
}
private void HandlePinValidation(IUnsafePacketReader reader)
{
// TODO: Configuring the server to not require PINs.
var action = reader.ReadByte<PinRequestType>();
reader.Skip(5);
switch (action)
{
case PinRequestType.PinNotSet:
this.State = AuthClientState.AskPin;
this.ServerSession.WritePacket(this.SetPinResponse());
break;
case PinRequestType.CheckPin:
if (this.CheckPin(reader))
{
this.State = AuthClientState.LoggedIn;
this.ServerSession.WritePacket(this.PinAcceptedResponse());
}
else
{
this.ServerSession.WritePacket(this.InvalidPinResponse());
}
break;
case PinRequestType.AssignPin:
if (this.CheckPin(reader))
{
this.State = AuthClientState.LoggedIn;
this.ServerSession.WritePacket(this.SetPinResponse());
}
else
{
this.ServerSession.WritePacket(this.InvalidPinResponse());
}
break;
}
}
private void HandlePinAssignment(IUnsafePacketReader reader)
{
throw new NotImplementedException();
}
