public bool SendToClient(ref LoginSocketState state, byte[] data)
{
if (data == null || state == null || state.Socket == null)
return false;
try {
if (state.SendCallback == null)
state.SendCallback = OnSent;
state.Socket.BeginSend(data, 0, data.Length, SocketFlags.None, state.SendCallback, state);
return true;
} catch (NullReferenceException) {
if (state != null)
state.Dispose();
state = null;
return false;
} catch (SocketException e) {
if (e.SocketErrorCode != SocketError.ConnectionAborted &&
e.SocketErrorCode != SocketError.ConnectionReset) {
LogError(Category, "Error sending data");
LogError(Category, String.Format("{0} {1}", e.SocketErrorCode, e));
}
if (state != null)
state.Dispose();
state = null;
return false;
}
}
public static void Logout(ref LoginSocketState state, Dictionary<string, string> keyValues)
{
// we're not doing anything about session, so no need to reset it back to 0...
// maybe one day though...
/*Dictionary<string, object> clientData = new Dictionary<string, object>() {
{ "session", (Int64)0 }
};
LoginDatabase.Instance.SetData(state.Name, clientData);*/
state.Dispose();
}
public static byte[] NewUser(ref LoginSocketState state, Dictionary <string, string> keyValues)
{
string message = String.Empty;
if (keyValues.ContainsKey("nick"))
{
state.Name = keyValues["nick"];
}
else
{
return(DataFunctions.StringToBytes(@"\error\\err\0\fatal\\errmsg\Invalid Query!\id\1\final\"));
}
if (keyValues.ContainsKey("email"))
{
state.Email = keyValues["email"];
}
else
{
return(DataFunctions.StringToBytes(@"\error\\err\0\fatal\\errmsg\Invalid Query!\id\1\final\"));
}
if (keyValues.ContainsKey("passwordenc"))
{
state.PasswordEncrypted = keyValues["passwordenc"];
}
else
{
return(DataFunctions.StringToBytes(@"\error\\err\0\fatal\\errmsg\Invalid Query!\id\1\final\"));
}
if (LoginDatabase.Instance.UserExists(state.Name))
{
return(DataFunctions.StringToBytes(@"\error\\err\516\fatal\\errmsg\This account name is already in use!\id\1\final\"));
}
else
{
string password = DecryptPassword(state.PasswordEncrypted);
LoginDatabase.Instance.CreateUser(state.Name, password.ToMD5(), state.Email, "??", ((IPEndPoint)state.Socket.RemoteEndPoint).Address);
var clientData = LoginDatabase.Instance.GetData(state.Name);
if (clientData == null)
{
return(DataFunctions.StringToBytes(@"\error\\err\0\fatal\\errmsg\Error creating account!\id\1\final\"));
}
message = String.Format(@"\nur\\userid\{0}\profileid\{1}\id\1\final\", clientData["userid"], clientData["profileid"]);
}
return(DataFunctions.StringToBytes(message));
}
private static string GenerateResponseValue(ref LoginSocketState state)
{
string value = state.PasswordEncrypted;
value += new String(' ', 48);
value += state.Name;
value += state.ClientChallenge;
value += state.ServerChallenge;
value += state.PasswordEncrypted;
return(value.ToMD5());
}
private void HandleClientManager(ref LoginSocketState state, string query, Dictionary <string, string> keyValues)
{
if (state == null || String.IsNullOrWhiteSpace(query) || keyValues == null)
{
return;
}
if (state.State == 1)
{
if (query.Equals("login", StringComparison.InvariantCultureIgnoreCase))
{
SendToClient(ref state, LoginServerMessages.SendProof(ref state, keyValues));
state.StartKeepAlive(this);
}
else if (query.Equals("newuser", StringComparison.InvariantCultureIgnoreCase))
{
SendToClient(ref state, LoginServerMessages.NewUser(ref state, keyValues));
}
}
else if (state.State == 2)
{
if (query.Equals("status", StringComparison.InvariantCultureIgnoreCase))
{
//LogError("STATUS NOT RESPONDED","1");
//SendToClient(ref state, LoginServerMessages.StatusResponse(ref state, keyValues));
}
else if (query.Equals("getprofile", StringComparison.InvariantCultureIgnoreCase))
{
SendToClient(ref state, LoginServerMessages.SendProfile(ref state, keyValues, false));
}
else if (query.Equals("updatepro", StringComparison.InvariantCultureIgnoreCase))
{
LoginServerMessages.UpdateProfile(ref state, keyValues);
}
}
else if (state.State == 3)
{
if (query.Equals("logout", StringComparison.InvariantCultureIgnoreCase))
{
LoginServerMessages.Logout(ref state, keyValues);
}
else if (query.Equals("getprofile", StringComparison.InvariantCultureIgnoreCase))
{
SendToClient(ref state, LoginServerMessages.SendProfile(ref state, keyValues, true));
}
}
else if (state.State >= 4)
{
state.Dispose();
}
}
private void WaitForData(ref LoginSocketState state)
{
Thread.Sleep(10);
try {
if (state.DataReceivedCallback == null)
{
state.DataReceivedCallback = OnDataReceived;
}
state.Socket.BeginReceive(state.Buffer, 0, state.Buffer.Length, SocketFlags.None, state.DataReceivedCallback, state);
} catch (NullReferenceException) {
if (state != null)
{
state.Dispose();
}
state = null;
} catch (ObjectDisposedException) {
if (state != null)
{
state.Dispose();
}
state = null;
} catch (SocketException e) {
if (e.SocketErrorCode == SocketError.NotConnected)
{
if (state != null)
{
state.Dispose();
}
state = null;
return;
}
if (e.SocketErrorCode != SocketError.ConnectionAborted &&
e.SocketErrorCode != SocketError.ConnectionReset)
{
LogError(Category, "Error receiving data");
LogError(Category, String.Format("{0} {1}", e.SocketErrorCode, e));
}
if (state != null)
{
state.Dispose();
}
state = null;
return;
}
}
internal static byte[] SendCheck(ref LoginSocketState state, Dictionary <string, string> keyValues)
{
string name = String.Empty;
if (String.IsNullOrWhiteSpace(name))
{
if (keyValues.ContainsKey("uniquenick"))
{
name = keyValues["uniquenick"];
}
}
if (String.IsNullOrWhiteSpace(name))
{
if (keyValues.ContainsKey("nick"))
{
name = keyValues["nick"];
}
}
if (String.IsNullOrWhiteSpace(name))
{
return(DataFunctions.StringToBytes(@"\error\\err\0\fatal\\errmsg\Invalid Query!\id\1\final\"));
}
var clientData = LoginDatabase.Instance.GetData(name);
//GP_CHECK_BAD_EMAIL = 3585, // 0xE01, No account exists with the provided e-mail address.
//GP_CHECK_BAD_NICK = 3586, // 0xE02, No such profile exists for the provided e-mail address.
//GP_CHECK_BAD_PASSWORD = 3587, // 0xE03, The password is incorrect.
if (clientData == null)
{
return(DataFunctions.StringToBytes(String.Format(@"\error\\err\265\fatal\\errmsg\Username [{0}] doesn't exist!\id\1\final\", name)));
}
string message;
string password = PasswordFromKeyValues(keyValues);
if (LoginDatabase.Instance.CheckPasswordIsCorrect((Int64)clientData["id"], password))
{
message = String.Format(@"\cur\0\pid\{0}\final\", clientData["profileid"]);
}
else
{
message = String.Format(@"\cur\3587\pid\{0}\final\", clientData["profileid"]);
}
return(DataFunctions.StringToBytes(message));
}
public static void UpdateProfile(ref LoginSocketState state, Dictionary <string, string> keyValues)
{
string country = "??";
if (keyValues.ContainsKey("countrycode"))
{
country = keyValues["countrycode"].ToUpperInvariant();
}
Dictionary <string, object> clientData = new Dictionary <string, object>()
{
{ "country", country }
};
LoginDatabase.Instance.SetData(state.Name, clientData);
state.State++;
}
private void StartServerClientManager(object parameter)
{
AddressInfo info = (AddressInfo)parameter;
Log(Category, "Starting Login Server ClientManager");
try {
_clientManagerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
SendTimeout = 6000, //was 30000 originally
ReceiveTimeout = 6000, //was 30000 originally
SendBufferSize = 8192,
ReceiveBufferSize = 8192,
Blocking = false
};
_clientManagerSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ExclusiveAddressUse, true);
_clientManagerSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true);
_clientManagerSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, false);
_clientManagerSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
_clientManagerSocket.Bind(new IPEndPoint(info.Address, info.Port));
_clientManagerSocket.Listen(10);
} catch (Exception e) {
LogError(Category, String.Format("Unable to bind Login Server ClientManager to {0}:{1}", info.Address, info.Port));
LogError(Category, e.ToString());
return;
}
while (true)
{
_clientManagerReset.Reset();
LoginSocketState state = new LoginSocketState()
{
Type = LoginSocketState.SocketType.Client,
Socket = _clientManagerSocket
};
_clientManagerSocket.BeginAccept(AcceptCallback, state);
_clientManagerReset.WaitOne();
}
}
public static byte[] StatusResponse(ref LoginSocketState state, Dictionary <string, string> keyValues)
{
//string cat ="\xff\xff\xff\xff\x67\x65\x74\x73\x65\x72\x76\x65\x72\x73\x52\x65\x73\x70\x6f\x6e\x73\x65\x5c\x45\x4f\x54";//"\x63\x61\x74";
//string dog = "\xff\xff\xff\xff"+@"getserversResponse\tttttt\t5!.m8\EOT";//@"\status\1\\final\";
//string god = @"\getprofile\\sesskey\" + keyValues["sesskey"].ToUpperInvariant() + @"\profileid\81246737\id\2\\final\";
/*string pot = @"\gamename\civ4\gamever\3.19\location\1\hostname\GameMaster Arena Server\hostpo
* rt\25000\mapname\gmtmap1\gametype\arena\numplayers\12\maxplayers\32\gamemode\ope
* nplaying\timelimit\40\fraglimit\0\teamplay\1\rankedserver\1\player_0\Joe Player\
* score_0\22\deaths_0\21\skill_0\339\ping_0\23\team_0\\player_1\L33t 0n3\score_1\1
* 5\deaths_1\7\skill_1\762\ping_1\0\team_1\\player_2\Raptor\score_2\26\deaths_2\11
* \skill_2\564\ping_2\372\team_2\Red\final\\queryid\1.1";*/
string pot = "";
//IS WRONG SHIT
// PROPPER STATUS RESPONSE NEEDED
//should ther even be response to that?
return(DataFunctions.StringToBytes(pot));//@"\ka\\final\");
}
internal static byte[] SendNicks(ref LoginSocketState state, Dictionary <string, string> keyValues)
{
if (!keyValues.ContainsKey("email") || (!keyValues.ContainsKey("passenc") && !keyValues.ContainsKey("pass")))
{
return(DataFunctions.StringToBytes(@"\error\\err\0\fatal\\errmsg\Invalid Query!\id\1\final\"));
}
string password = String.Empty;
if (keyValues.ContainsKey("passenc"))
{
password = DecryptPassword(keyValues["passenc"]);
}
else if (keyValues.ContainsKey("pass"))
{
password = keyValues["pass"];
}
password = password.ToMD5();
var clientData = LoginDatabase.Instance.GetData(keyValues["email"], password);
if (clientData == null)
{
return(DataFunctions.StringToBytes(@"\error\\err\551\fatal\\errmsg\Unable to get any associated profiles.\id\1\final\"));
}
List <string> nicks = new List <string>();
foreach (var client in clientData)
{
nicks.Add((string)client["name"]);
}
if (nicks.Count == 0)
{
return(DataFunctions.StringToBytes(@"\nr\0\ndone\\final\"));
}
state.State++;
return(DataFunctions.StringToBytes(GenerateNicks(nicks.ToArray())));
}
private void OnSent(IAsyncResult async)
{
LoginSocketState state = (LoginSocketState)async.AsyncState;
if (state == null || state.Socket == null)
{
return;
}
try {
int sent = state.Socket.EndSend(async);
Log(Category, String.Format("[{0}] Sent {1} byte response to: {2}:{3}", state.Type, sent, ((IPEndPoint)state.Socket.RemoteEndPoint).Address, ((IPEndPoint)state.Socket.RemoteEndPoint).Port));
} catch (NullReferenceException) {
if (state != null)
{
state.Dispose();
}
state = null;
} catch (SocketException e) {
switch (e.SocketErrorCode)
{
case SocketError.ConnectionReset:
case SocketError.Disconnecting:
if (state != null)
{
state.Dispose();
}
state = null;
return;
default:
LogError(Category, "Error sending data");
LogError(Category, String.Format("{0} {1}", e.SocketErrorCode, e));
if (state != null)
{
state.Dispose();
}
state = null;
return;
}
}
}
public static byte[] NewUser(ref LoginSocketState state, Dictionary<string, string> keyValues)
{
string message = String.Empty;
if (keyValues.ContainsKey("nick")) {
state.Name = keyValues["nick"];
} else {
return DataFunctions.StringToBytes(@"\error\\err\0\fatal\\errmsg\Invalid Query!\id\1\final\");
}
if (keyValues.ContainsKey("email")) {
state.Email = keyValues["email"];
} else {
return DataFunctions.StringToBytes(@"\error\\err\0\fatal\\errmsg\Invalid Query!\id\1\final\");
}
if (keyValues.ContainsKey("passwordenc")) {
state.PasswordEncrypted = keyValues["passwordenc"];
} else {
return DataFunctions.StringToBytes(@"\error\\err\0\fatal\\errmsg\Invalid Query!\id\1\final\");
}
if (LoginDatabase.Instance.UserExists(state.Name)) {
return DataFunctions.StringToBytes(@"\error\\err\516\fatal\\errmsg\This account name is already in use!\id\1\final\");
} else {
string password = DecryptPassword(state.PasswordEncrypted);
LoginDatabase.Instance.CreateUser(state.Name, password.ToMD5(), state.Email, "??", ((IPEndPoint)state.Socket.RemoteEndPoint).Address);
var clientData = LoginDatabase.Instance.GetData(state.Name);
if (clientData == null) {
return DataFunctions.StringToBytes(@"\error\\err\0\fatal\\errmsg\Error creating account!\id\1\final\");
}
message = String.Format(@"\nur\\userid\{0}\profileid\{1}\id\1\final\", clientData["userid"], clientData["profileid"]);
}
return DataFunctions.StringToBytes(message);
}
private void HandleSearchManager(ref LoginSocketState state, string query, Dictionary <string, string> keyValues)
{
if (state.State == 0)
{
if (query.Equals("nicks", StringComparison.InvariantCultureIgnoreCase))
{
SendToClient(ref state, LoginServerMessages.SendNicks(ref state, keyValues));
}
else if (query.Equals("check", StringComparison.InvariantCultureIgnoreCase))
{
SendToClient(ref state, LoginServerMessages.SendCheck(ref state, keyValues));
}
}
else if (state.State == 1)
{
state.State++;
}
else if (state.State >= 2)
{
state.Dispose();
}
}
public bool SendToClient(ref LoginSocketState state, byte[] data)
{
if (data == null || state == null || state.Socket == null)
{
return(false);
}
try {
if (state.SendCallback == null)
{
state.SendCallback = OnSent;
}
state.Socket.BeginSend(data, 0, data.Length, SocketFlags.None, state.SendCallback, state);
//LogError("data sent:", System.Text.Encoding.Default.GetString(data));
return(true);
} catch (NullReferenceException) {
if (state != null)
{
state.Dispose();
}
state = null;
return(false);
} catch (SocketException e) {
if (e.SocketErrorCode != SocketError.ConnectionAborted &&
e.SocketErrorCode != SocketError.ConnectionReset)
{
LogError(Category, "Error sending data");
LogError(Category, String.Format("{0} {1}", e.SocketErrorCode, e));
}
if (state != null)
{
state.Dispose();
}
state = null;
return(false);
}
}
private void KeepAliveCallback(object s)
{
LoginServer server = (LoginServer)s;
try {
if (_keepAliveTimer == null)
{
Dispose();
return;
}
LoginSocketState state = this;
HeartbeatState++;
Console.WriteLine("keep alive callback");
if (!server.SendToClient(ref state, LoginServerMessages.SendKeepAlive()))
{
Dispose();
return;
}
// every 2nd keep alive request, we send an additional heartbeat
if (HeartbeatState % 2 == 0)
{
//Console.WriteLine("sending heartbeat");
if (!server.SendToClient(ref state, LoginServerMessages.SendHeartbeat()))
{
Dispose();
return;
}
}
// ServerListRetrieve.
} catch (Exception e) {
server.LogError(LoginServer.Category, "Error running keep alive: " + e);
Dispose();
}
}
internal static byte[] SendSearch(ref LoginSocketState state, Dictionary <string, string> keyValues)
{
string message = "";
if (keyValues.ContainsKey("uniquenick"))
{
Console.WriteLine("Search for uniquenick: {0}", keyValues["uniquenick"]);
message = GenerateSearchResultsNick(LoginDatabase.Instance.GetData(keyValues["uniquenick"]));
}
else if (keyValues.ContainsKey("email"))
{
Console.WriteLine("Search for email: {0}", keyValues["email"]);
List <Dictionary <string, object> > matchedUsers;
matchedUsers = LoginDatabase.Instance.GetUserByEmail(keyValues["email"]);
message = GenerateSearchResultsEmail(matchedUsers);
}
else
{
return(DataFunctions.StringToBytes(@"\error\\err\0\fatal\\errmsg\Invalid Query!\id\1\final\"));
}
return(DataFunctions.StringToBytes(message));
}
private static string GenerateResponseValue(ref LoginSocketState state)
{
string value = state.PasswordEncrypted;
value += new String(' ', 48);
value += state.Name;
value += state.ClientChallenge;
value += state.ServerChallenge;
value += state.PasswordEncrypted;
return value.ToMD5();
}
internal static byte[] SendNicks(ref LoginSocketState state, Dictionary<string, string> keyValues)
{
if (!keyValues.ContainsKey("email") || (!keyValues.ContainsKey("passenc") && !keyValues.ContainsKey("pass"))) {
return DataFunctions.StringToBytes(@"\error\\err\0\fatal\\errmsg\Invalid Query!\id\1\final\");
}
string password = String.Empty;
if (keyValues.ContainsKey("passenc")) {
password = DecryptPassword(keyValues["passenc"]);
} else if (keyValues.ContainsKey("pass")) {
password = keyValues["pass"];
}
password = password.ToMD5();
var clientData = LoginDatabase.Instance.GetData(keyValues["email"], password);
if (clientData == null) {
return DataFunctions.StringToBytes(@"\error\\err\551\fatal\\errmsg\Unable to get any associated profiles.\id\1\final\");
}
List<string> nicks = new List<string>();
foreach (var client in clientData) {
nicks.Add((string)client["name"]);
}
if (nicks.Count == 0) {
return DataFunctions.StringToBytes(@"\nr\0\ndone\\final\");
}
state.State++;
return DataFunctions.StringToBytes(GenerateNicks(nicks.ToArray()));
}
internal static byte[] SendCheck(ref LoginSocketState state, Dictionary<string, string> keyValues)
{
string name = String.Empty;
if (String.IsNullOrWhiteSpace(name)) {
if (keyValues.ContainsKey("uniquenick")) {
name = keyValues["uniquenick"];
}
}
if (String.IsNullOrWhiteSpace(name)) {
if (keyValues.ContainsKey("nick")) {
name = keyValues["nick"];
}
}
if (String.IsNullOrWhiteSpace(name)) {
return DataFunctions.StringToBytes(@"\error\\err\0\fatal\\errmsg\Invalid Query!\id\1\final\");
}
var clientData = LoginDatabase.Instance.GetData(name);
if (clientData == null) {
return DataFunctions.StringToBytes(String.Format(@"\error\\err\265\fatal\\errmsg\Username [{0}] doesn't exist!\id\1\final\", name));
}
string message = String.Format(@"\cur\0\pid\{0}\final\", clientData["profileid"]);
return DataFunctions.StringToBytes(message);
}
public static byte[] GenerateServerChallenge(ref LoginSocketState state)
{
state.ServerChallenge = _random.GetString(10);
string message = String.Format(@"\lc\1\challenge\{0}\id\1\final\", state.ServerChallenge);
return DataFunctions.StringToBytes(message);
}
public static void UpdateProfile(ref LoginSocketState state, Dictionary<string, string> keyValues)
{
string country = "??";
if (keyValues.ContainsKey("countrycode")) {
country = keyValues["countrycode"].ToUpperInvariant();
}
Dictionary<string, object> clientData = new Dictionary<string, object>() {
{ "country", country }
};
LoginDatabase.Instance.SetData(state.Name, clientData);
state.State++;
}
public static byte[] SendProof(ref LoginSocketState state, Dictionary<string, string> keyValues)
{
string response = String.Empty;
int requiredValues = 0;
state.Name = String.Empty;
if (keyValues.ContainsKey("uniquenick")) {
state.Name = keyValues["uniquenick"];
requiredValues++;
}
if (keyValues.ContainsKey("challenge")) {
state.ClientChallenge = keyValues["challenge"];
requiredValues++;
}
if (keyValues.ContainsKey("response")) {
response = keyValues["response"];
requiredValues++;
}
if (requiredValues != 3)
return DataFunctions.StringToBytes(@"\error\\err\0\fatal\\errmsg\Invalid Query!\id\1\final\");
var clientData = LoginDatabase.Instance.GetData(state.Name);
if (clientData != null) {
state.PasswordEncrypted = (string)clientData["passwordenc"];
if (response == GenerateResponseValue(ref state)) {
ushort session = GenerateSession(state.Name);
string proof = String.Format(@"\lc\2\sesskey\{0}\proof\{1}\userid\{2}\profileid\{3}\uniquenick\{4}\lt\{5}\id\1\final\",
session,
GenerateProofValue(state),
clientData["userid"],
clientData["profileid"],
state.Name,
_random.GetString(22, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ][") + "__");
/*state.Session = session.ToString();
Dictionary<string, object> updateClientData = new Dictionary<string, object>() {
{ "session", session }
};
LoginDatabase.Instance.SetData(state.Name, updateClientData);*/
LoginDatabase.Instance.LogLogin(state.Name, ((IPEndPoint)state.Socket.RemoteEndPoint).Address);
state.State++;
return DataFunctions.StringToBytes(proof);
} else {
return DataFunctions.StringToBytes(@"\error\\err\260\fatal\\errmsg\The password provided is incorrect.\id\1\final\");
}
} else {
return DataFunctions.StringToBytes(String.Format(@"\error\\err\265\fatal\\errmsg\Username [{0}] doesn't exist!\id\1\final\", state.Name));
}
}
public static byte[] SendProfile(ref LoginSocketState state, Dictionary<string, string> keyValues, bool retrieve)
{
var clientData = LoginDatabase.Instance.GetData(state.Name);
if (clientData == null) {
return DataFunctions.StringToBytes(String.Format(@"\error\\err\265\fatal\\errmsg\Username [{0}] doesn't exist!\id\1\final\", state.Name));
}
string message = String.Format(
@"\pi\\profileid\{0}\nick\{1}\userid\{2}\email\{3}\sig\{4}\uniquenick\{5}\pid\{6}" +
@"\firstname\lastname\countrycode\{7}\birthday\{8}\lon\{9}\lat\{10}\loc\id\{11}\final\",
clientData["profileid"],
state.Name,
clientData["userid"],
clientData["email"],
_random.GetString(32, "0123456789abcdef"),
state.Name,
0,
clientData["country"],
16844722,
"0.000000",
"0.000000",
retrieve ? 5 : 2
);
if (!retrieve)
state.State++;
return DataFunctions.StringToBytes(message);
}
private void WaitForData(ref LoginSocketState state)
{
Thread.Sleep(10);
try {
if (state.DataReceivedCallback == null)
state.DataReceivedCallback = OnDataReceived;
state.Socket.BeginReceive(state.Buffer, 0, state.Buffer.Length, SocketFlags.None, state.DataReceivedCallback, state);
} catch (NullReferenceException) {
if (state != null)
state.Dispose();
state = null;
} catch (ObjectDisposedException) {
if (state != null)
state.Dispose();
state = null;
} catch (SocketException e) {
if (e.SocketErrorCode == SocketError.NotConnected) {
if (state != null)
state.Dispose();
state = null;
return;
}
if (e.SocketErrorCode != SocketError.ConnectionAborted &&
e.SocketErrorCode != SocketError.ConnectionReset) {
LogError(Category, "Error receiving data");
LogError(Category, String.Format("{0} {1}", e.SocketErrorCode, e));
}
if (state != null)
state.Dispose();
state = null;
return;
}
}
private void ParseMessage(ref LoginSocketState state, string message)
{
string query;
var keyValues = GetKeyValue(message, out query);
if (keyValues == null || String.IsNullOrWhiteSpace(query)) {
return;
}
Log(Category, String.Format("[{0}] Received {1} query from: {2}:{3}", state.Type, query, ((IPEndPoint)state.Socket.RemoteEndPoint).Address, ((IPEndPoint)state.Socket.RemoteEndPoint).Port));
if (keyValues.ContainsKey("gamename") && !keyValues["gamename"].Equals("battlefield2", StringComparison.InvariantCultureIgnoreCase)) {
// say no to those not using bf2... Begone evil demon, bf2 for life!
return;
}
switch (state.Type) {
case LoginSocketState.SocketType.Client:
HandleClientManager(ref state, query, keyValues);
break;
case LoginSocketState.SocketType.Search:
HandleSearchManager(ref state, query, keyValues);
break;
}
}
public static byte[] SendProof(ref LoginSocketState state, Dictionary <string, string> keyValues)
{
string response = String.Empty;
int requiredValues = 0;
state.Name = String.Empty;
if (keyValues.ContainsKey("uniquenick"))
{
state.Name = keyValues["uniquenick"];
requiredValues++;
}
if (keyValues.ContainsKey("challenge"))
{
state.ClientChallenge = keyValues["challenge"];
requiredValues++;
}
if (keyValues.ContainsKey("response"))
{
response = keyValues["response"];
requiredValues++;
}
if (requiredValues != 3)
{
return(DataFunctions.StringToBytes(@"\error\\err\0\fatal\\errmsg\Invalid Query!\id\1\final\"));
}
var clientData = LoginDatabase.Instance.GetData(state.Name);
if (clientData != null)
{
state.PasswordEncrypted = (string)clientData["passwordenc"];
if (response == GenerateResponseValue(ref state))
{
ushort session = GenerateSession(state.Name);
string proof = String.Format(@"\lc\2\sesskey\{0}\proof\{1}\userid\{2}\profileid\{3}\uniquenick\{4}\lt\{5}\id\1\final\",
session,
GenerateProofValue(state),
clientData["userid"],
clientData["profileid"],
state.Name,
_random.GetString(22, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ][") + "__");
/*state.Session = session.ToString();
* Dictionary<string, object> updateClientData = new Dictionary<string, object>() {
* { "session", session }
* };
* LoginDatabase.Instance.SetData(state.Name, updateClientData);*/
LoginDatabase.Instance.LogLogin(state.Name, ((IPEndPoint)state.Socket.RemoteEndPoint).Address);
state.State++;
return(DataFunctions.StringToBytes(proof));
}
else
{
return(DataFunctions.StringToBytes(@"\error\\err\260\fatal\\errmsg\The password provided is incorrect.\id\1\final\"));
}
}
else
{
return(DataFunctions.StringToBytes(String.Format(@"\error\\err\265\fatal\\errmsg\Username [{0}] doesn't exist!\id\1\final\", state.Name)));
}
}
private void OnDataReceived(IAsyncResult async)
{
LoginSocketState state = (LoginSocketState)async.AsyncState;
if (state == null || state.Socket == null)
{
return;
}
try {
// receive data from the socket
int received = state.Socket.EndReceive(async);
if (received == 0)
{
// when EndReceive returns 0, it means the socket on the other end has been shut down.
return;
}
// take what we received, and append it to the received data buffer
state.ReceivedData.Append(Encoding.UTF8.GetString(state.Buffer, 0, received));
string receivedData = state.ReceivedData.ToString();
// does what we received contain the \final\ delimiter?
if (receivedData.LastIndexOf(@"\final\") > -1)
{
state.ReceivedData.Clear();
//Log("data received:", receivedData);
int lame = state.State;
//Log("state.state:", lame.ToString() );//
// lets split up the message based on the delimiter
string[] messages = receivedData.Split(new string[] { @"\final\" }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < messages.Length; i++)
{
ParseMessage(ref state, messages[i]);
}
}
} catch (ObjectDisposedException) {
if (state != null)
{
state.Dispose();
}
state = null;
return;
} catch (SocketException e) {
switch (e.SocketErrorCode)
{
case SocketError.ConnectionReset:
case SocketError.Disconnecting:
case SocketError.NotConnected:
case SocketError.TimedOut:
if (state != null)
{
state.Dispose();
}
state = null;
return;
default:
LogError(Category, "Error receiving data");
LogError(Category, String.Format("{0} {1}", e.SocketErrorCode, e));
if (state != null)
{
state.Dispose();
}
state = null;
return;
}
} catch (Exception e) {
LogError(Category, "Error receiving data");
LogError(Category, e.ToString());
}
// and we wait for more data...
WaitForData(ref state);
}
private void HandleClientManager(ref LoginSocketState state, string query, Dictionary<string, string> keyValues)
{
if (state == null || String.IsNullOrWhiteSpace(query) || keyValues == null) {
return;
}
if (state.State == 1) {
if (query.Equals("login", StringComparison.InvariantCultureIgnoreCase)) {
SendToClient(ref state, LoginServerMessages.SendProof(ref state, keyValues));
state.StartKeepAlive(this);
} else if (query.Equals("newuser", StringComparison.InvariantCultureIgnoreCase)) {
SendToClient(ref state, LoginServerMessages.NewUser(ref state, keyValues));
}
} else if (state.State == 2) {
if (query.Equals("getprofile", StringComparison.InvariantCultureIgnoreCase)) {
SendToClient(ref state, LoginServerMessages.SendProfile(ref state, keyValues, false));
} else if (query.Equals("updatepro", StringComparison.InvariantCultureIgnoreCase)) {
LoginServerMessages.UpdateProfile(ref state, keyValues);
}
} else if (state.State == 3) {
if (query.Equals("logout", StringComparison.InvariantCultureIgnoreCase)) {
LoginServerMessages.Logout(ref state, keyValues);
} else if (query.Equals("getprofile", StringComparison.InvariantCultureIgnoreCase)) {
SendToClient(ref state, LoginServerMessages.SendProfile(ref state, keyValues, true));
}
} else if (state.State >= 4) {
state.Dispose();
}
}
private void HandleSearchManager(ref LoginSocketState state, string query, Dictionary<string, string> keyValues)
{
if (state.State == 0) {
if (query.Equals("nicks", StringComparison.InvariantCultureIgnoreCase)) {
SendToClient(ref state, LoginServerMessages.SendNicks(ref state, keyValues));
} else if (query.Equals("check", StringComparison.InvariantCultureIgnoreCase)) {
SendToClient(ref state, LoginServerMessages.SendCheck(ref state, keyValues));
}
} else if (state.State == 1) {
state.State++;
} else if (state.State >= 2) {
state.Dispose();
}
}
private void ParseMessage(ref LoginSocketState state, string message)
{
string query;
var keyValues = GetKeyValue(message, out query);
if (keyValues == null || String.IsNullOrWhiteSpace(query)) {
return;
}
Log(Category, String.Format("[{0}] Received {1} query from: {2}:{3}", state.Type, query, ((IPEndPoint)state.Socket.RemoteEndPoint).Address, ((IPEndPoint)state.Socket.RemoteEndPoint).Port));
switch (state.Type) {
case LoginSocketState.SocketType.Client:
HandleClientManager(ref state, query, keyValues);
break;
case LoginSocketState.SocketType.Search:
HandleSearchManager(ref state, query, keyValues);
break;
}
}
private void StartServerSearchManager(object parameter)
{
AddressInfo info = (AddressInfo)parameter;
Log(Category, "Starting Login Server SearchManager");
try {
_searchManagerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp) {
SendTimeout = 5000,
ReceiveTimeout = 5000,
SendBufferSize = 8192,
ReceiveBufferSize = 8192,
Blocking = false
};
_searchManagerSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ExclusiveAddressUse, true);
_searchManagerSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true);
_searchManagerSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, false);
_searchManagerSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
_searchManagerSocket.Bind(new IPEndPoint(info.Address, info.Port));
_searchManagerSocket.Listen(10);
} catch (Exception e) {
LogError(Category, String.Format("Unable to bind Login Server SearchManager to {0}:{1}", info.Address, info.Port));
LogError(Category, e.ToString());
return;
}
while (true) {
_searchManagerReset.Reset();
LoginSocketState state = new LoginSocketState() {
Type = LoginSocketState.SocketType.Search,
Socket = _searchManagerSocket
};
_searchManagerSocket.BeginAccept(AcceptCallback, state);
_searchManagerReset.WaitOne();
}
}
