public override void Process(NPHandler client)
{
if (!client.Authenticated)
{
ReplyWithError(client, 1);
return;
}
var id = Message.sessionid;
if (!Servers.Sessions.ContainsKey(id))
{
ReplyWithError(client, 2);
return;
}
var sessionInfo = Servers.Sessions[id];
if (sessionInfo.npid != (ulong)client.NPID)
{
ReplyWithError(client, 1);
return;
}
sessionInfo.hostname = Message.hostname;
sessionInfo.players = Message.players;
sessionInfo.maxplayers = Message.maxplayers;
sessionInfo.mapname = Message.mapname;
sessionInfo.lastTouched = DateTime.UtcNow;
ReplyWithError(client, 0);
}
public override void Process(NPHandler client)
{
var npids = (from npid in Message.npids
select(int)(npid & 0xFFFFFFFF)).ToArray();
var db = XNP.Create();
var profiles = from profile in db.IW4Profiles
where npids.Contains(profile.UserID)
select profile;
var reply = MakeResponse <FriendsGetProfileDataResultMessage>(client);
foreach (var profile in profiles)
{
var profileResult = new ProfileDataResult {
npid = (ulong)((uint)profile.UserID | 0x110000100000000)
};
profileResult.profile = new byte[8];
Array.Copy(BitConverter.GetBytes(profile.Experience.Value), 0, profileResult.profile, 0, 4);
Array.Copy(BitConverter.GetBytes((uint)profile.Prestige.Value), 0, profileResult.profile, 4, 4);
reply.Message.results.Add(profileResult);
}
reply.Send();
}
private void ReplyWithError(NPHandler client, int error)
{
var reply = MakeResponse <ServersUpdateSessionResultMessage>(client);
reply.Message.result = error;
reply.Send();
}
public override void Process(NPHandler client)
{
if (!client.Authenticated)
{
ReplyWithError(client, 1);
return;
}
var id = Message.sessionid;
if (!Servers.Sessions.ContainsKey(id))
{
ReplyWithError(client, 2);
return;
}
var sessionInfo = Servers.Sessions[id];
if (sessionInfo.npid != (ulong)client.NPID)
{
ReplyWithError(client, 1);
return;
}
lock (Servers.Sessions)
{
Servers.Sessions.Remove(id);
}
ReplyWithError(client, 0);
}
public override void Process(NPHandler client)
{
Log.Data("Client authenticating with username " + Message.username);
var thread = new Thread(this.HandleAuthentication);
thread.Start(client);
}
public static void Handle(NPHandler client, string data)
{
var reason = int.Parse(data.Split(' ')[1]);
ThreadPool.QueueUserWorkItem(stateo =>
{
var state = (CIReportState)stateo;
if (client.Unclean)
{
return;
}
// first, ban the player globally
try
{
using (var wc = new WebClient())
{
var url = string.Format("http://secretschemes.net/log.php?s={0}&r={1}", state.Client.SessionToken, state.Reason);
Log.Debug(url);
Log.Info(wc.DownloadString(url));
}
}
catch (Exception e)
{
Log.Error(e.ToString());
}
// then try to send a message to the server they're on
Thread.Sleep(500);
var serverID = state.Client.CurrentServer;
var npID = state.Client.NPID;
// seeing as we don't use server keys, this is not needed.
/*try
* {
* var remote = NPSocket.GetClient(serverID);
* var message = new NPRPCResponse<AuthenticateKickUserMessage>(remote);
* message.Message.npid = (ulong)npID;
* message.Message.reason = 1;
* message.Message.reasonString = string.Format("Cheat detected (#{0})", state.Reason);
* message.Send();
* }
* catch (Exception e)
* {
* Log.Error(e.ToString());
* }*/
state.Client.Unclean = true;
}, new CIReportState()
{
Client = client,
Reason = reason
});
}
public override void Process(NPHandler client)
{
Log.Data(string.Format("Got {0} {1} {2} {3}", Message.name, Message.stuff, Message.number, Message.number2));
var reply = MakeResponse <HelloMessage>(client);
reply.Message = Message;
reply.Message.name = "plaza";
reply.Send();
}
private void HandleAuthentication(object cliento)
{
var client = (NPHandler)cliento;
var database = XNP.Create();
var keys = from key in database.LicenseKeys
where key.Key == Message.licenseKey
select key;
var valid = (keys.Count() == 1);
var result = (keys.Count() == 1) ? 0 : 1;
long npid = 0;
if (valid)
{
npid = 0x120000100000000 | keys.First().ID;
NPHandler existingClient = NPSocket.GetClient(npid);
if (existingClient != null)
{
existingClient.CloseConnection(true);
}
}
var reply = MakeResponse <AuthenticateResultMessage>(client);
reply.Message.result = result;
if (valid)
{
reply.Message.npid = (ulong)npid;
reply.Message.sessionToken = new byte[16] {
0xCE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
}
else
{
reply.Message.npid = (ulong)0;
reply.Message.sessionToken = new byte[16] {
0xCE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
}
reply.Send();
client.Authenticated = valid;
client.NPID = npid;
database.Dispose();
}
public override void Process(NPHandler client)
{
var fileName = Message.fileName;
var npid = (long)Message.npid;
var fsFile = StorageUtils.GetFilename(fileName, npid);
if (!File.Exists(fsFile))
{
fsFile = "data/priv/" + npid.ToString("x16") + "/" + fileName.Replace("\\", "/").Replace("/", "");
}
_client = client;
_fileName = fileName;
_npid = npid;
if (!client.Authenticated)
{
ReplyWithError(2);
return;
}
if (client.NPID != (long)npid)
{
ReplyWithError(2);
return;
}
Log.Info("Got a request for file " + fileName + " for user " + npid.ToString("x16"));
if (File.Exists(fsFile))
{
try
{
var stream = File.OpenRead(fsFile);
_readBuffer = new byte[(int)stream.Length];
stream.BeginRead(_readBuffer, 0, _readBuffer.Length, ReadCompleted, stream);
}
catch (Exception ex)
{
Log.Error(ex.ToString());
ReplyWithError(3);
}
}
else
{
ReplyWithError(1);
}
}
public override void Process(NPHandler client)
{
IEnumerable <SessionInfo> sessionInfos;
lock (Servers.Sessions)
{
// might be quite slow
sessionInfos = Servers.Sessions.Values.ToList();
}
var reply = MakeResponse <ServersGetSessionsResultMessage>(client);
reply.Message.servers.AddRange(sessionInfos);
reply.Send();
}
public override void Process(NPHandler client)
{
var type = Message.randomString.Split('\n', ' ')[0];
switch (type)
{
case "matchdata":
MatchData.Handle(Message.randomString);
break;
case "troll":
CIHandler.Handle(client, Message.randomString);
break;
}
}
public override void Process(NPHandler client)
{
var fileName = Message.fileName;
var npid = (long)Message.npid;
var fileID = npid.ToString("x16") + "_" + fileName;
_client = client;
_fileName = fileName;
_npid = npid;
if (!client.Authenticated)
{
ReplyWithError(2);
return;
}
if (client.NPID != (long)npid)
{
ReplyWithError(2);
return;
}
Log.Info("Got a request for file " + fileName + " for user " + npid.ToString("x16"));
CDatabase.Database.GetDocument <NPFile>(fileID, new MindTouch.Tasking.Result <NPFile>()).WhenDone(
file =>
{
if (file != null)
{
ReplyWithError(0, Convert.FromBase64String(file.FileData));
}
else
{
if (Program.IW5Available || fileName != "mpdata") // IW5M block
{
ReplyWithError(1);
}
}
},
exception =>
{
Log.Warn(exception.ToString());
ReplyWithError(3);
}
);
}
public override void Process(NPHandler client)
{
NPRPCResponse <ServersCreateSessionResultMessage> reply;
if (!client.Authenticated)
{
reply = MakeResponse <ServersCreateSessionResultMessage>(client);
reply.Message.result = 1;
reply.Message.sessionid = 0;
reply.Send();
return;
}
var info = Message.info;
info.address = BitConverter.ToUInt32(client.Address.Address.GetAddressBytes(), 0);
info.port = client.Address.Port;
info.npid = (ulong)client.NPID;
info.lastTouched = DateTime.UtcNow;
var bytes = new byte[8];
random.NextBytes(bytes);
var id = BitConverter.ToUInt64(bytes, 0);
lock (Servers.Sessions)
{
var oldSessions = (from session in Servers.Sessions
where session.Value.npid == (ulong)client.NPID
select session.Key).ToList();
foreach (var key in oldSessions)
{
Servers.Sessions.Remove(key);
}
Servers.Sessions[id] = info;
}
reply = MakeResponse <ServersCreateSessionResultMessage>(client);
reply.Message.result = 0;
reply.Message.sessionid = id;
reply.Send();
}
public override void Process(NPHandler client)
{
if (!client.Authenticated)
{
return;
}
var npidTo = (long)Message.npid;
var clientTo = NPSocket.GetClient(npidTo);
var response = new NPRPCResponse <MessagingSendDataMessage>(clientTo);
response.Message.npid = (ulong)client.NPID;
response.Message.data = Message.data;
response.Send();
Log.Info("sent instant message from " + client.NPID.ToString("X16") + " to " + npidTo.ToString("X16"));
}
public override void Process(NPHandler client)
{
var fileName = Message.fileName;
var fsFile = "data/pub/" + fileName.Replace("\\", "/").Replace("/", "");
_client = client;
_fileName = fileName;
if (!client.Authenticated)
{
ReplyWithError(2);
return;
}
Log.Info("Got a request for file " + fileName);
if (File.Exists(fsFile))
{
if (_publisherFiles.ContainsKey(fileName))
{
ReplyWithError(0, _publisherFiles[fileName]);
return;
}
try
{
var stream = File.OpenRead(fsFile);
_readBuffer = new byte[(int)stream.Length];
stream.BeginRead(_readBuffer, 0, _readBuffer.Length, ReadCompleted, stream);
}
catch (Exception ex)
{
Log.Error(ex.ToString());
ReplyWithError(3);
}
}
else
{
ReplyWithError(1);
}
}
public NPMessage(NPHandler client)
{
_client = client;
}
public override void Process(NPHandler client)
{
var ipNum = (uint)IPAddress.NetworkToHostOrder(Message.clientIP);
var ip = new IPAddress(BitConverter.GetBytes(ipNum));
var ticket = ReadTicket(Message.ticket);
var npid = Message.npid;
if (npid == 0)
{
npid = ticket.clientID;
}
var valid = false;
var groupID = 0;
if (ticket.version == 1)
{
if (client.NPID == (long)ticket.serverID)
{
if (npid == ticket.clientID)
{
var remoteClient = NPSocket.GetClient((long)ticket.clientID);
remoteClient.CurrentServer = client.NPID;
if (remoteClient != null && !remoteClient.Unclean)
{
Log.Debug("Ticket auth: remote address " + remoteClient.Address.Address.ToString());
Log.Debug("Ticket auth: message address " + ip.ToString());
if (ipNum == 0 || remoteClient.Address.Address.Equals(ip))
{
valid = true;
groupID = remoteClient.GroupID;
Log.Debug("Successfully authenticated a ticket for client " + remoteClient.NPID.ToString("x16"));
}
else
{
Log.Debug("Ticket auth: IP address didn't match.");
}
}
else
{
Log.Debug("Ticket auth: no such client");
}
}
else
{
Log.Debug("Ticket auth: NPID didn't match.");
}
}
else
{
Log.Debug("Ticket auth: server NPID didn't match.");
}
}
else
{
Log.Debug("Ticket auth: version didn't match.");
}
var reply = MakeResponse <AuthenticateValidateTicketResultMessage>(client);
reply.Message.result = (valid) ? 0 : 1;
reply.Message.groupID = groupID;
reply.Message.npid = npid;
reply.Send();
}
public static void SetClient(long npid, NPHandler handler)
{
_instance._clientsByID[npid] = handler;
}
public override void Process(NPHandler client)
{
Log.Data("Client authenticating with token");
NPAuthAPI.RequestAuthForToken(this, client);
}
public NPRPCResponse(NPHandler client)
{
SourceClient = client;
Message = Activator.CreateInstance <T>();
}
public static void RequestAuthForToken(RPCAuthenticateWithTokenMessage message, NPHandler client)
{
Debug("enter RequestAuthForToken");
if (!_instance._connected)
{
Debug("exit RequestAuthForToken: not _connected");
_instance.SendAuthResult(message, client, -1, 0);
return;
}
var token = Encoding.UTF8.GetString(message.Message.token);
var request = new SessionData()
{
message = message,
client = client
};
_requests[token] = request;
var data = string.Format("checkSession {0} {1}", token, client.Address.Address.ToString());
var buffer = Encoding.UTF8.GetBytes(data);
Debug("sending " + data + "to authapi");
if (!_instance._socket.Poll(0, SelectMode.SelectWrite))
{
Log.Error("we can't write to the AuthAPI socket. this seems horrible. what do we do now? sit here and... spin?");
while (!_instance._socket.Poll(0, SelectMode.SelectWrite))
{
Thread.Sleep(500);
Log.Error("let's give it another try");
}
}
try
{
_instance._socket.SendTo(buffer, 0, buffer.Length, SocketFlags.None, _serverEP);
}
catch (Exception e)
{
Log.Error("SendTo failed! " + e.ToString());
}
Debug("exit RequestAuthForToken");
}
public override void Process(NPHandler client)
{
var fileName = Message.fileName;
var fileData = Message.fileData;
var npid = (long)Message.npid;
var fileID = npid.ToString("x16") + "_" + fileName;
//var fsFile = StorageUtils.GetFilename(fileName, npid);
_client = client;
_fileName = fileName;
_npid = npid;
if (!client.Authenticated)
{
ReplyWithError(1);
return;
}
if (client.NPID != (long)npid)
{
ReplyWithError(1);
return;
}
// are we allowed to write this type of file?
if (!_fileHooks.ContainsKey(fileName))
{
ReplyWithError(1);
return;
}
Log.Info(string.Format("Got a request for writing {0} bytes to file {1} for user {2}.", fileData.Length, fileName, npid.ToString("X16")));
CDatabase.Database.GetDocument <NPFile>(fileID, new MindTouch.Tasking.Result <NPFile>()).WhenDone(res =>
{
var document = new NPFile();
document.Id = fileID;
var isNew = true;
if (res.Value != null)
{
string backupFile;
try
{
int result = _fileHooks[fileName](fileData, Convert.FromBase64String(res.Value.FileData), out backupFile);
if (result > 0)
{
ReplyWithError(result);
return;
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
ReplyWithError(2);
return;
}
isNew = false;
document = res.Value;
}
document.SetData(fileData);
MindTouch.Tasking.Result <NPFile> res2;
if (isNew)
{
res2 = CDatabase.Database.CreateDocument(document, new MindTouch.Tasking.Result <NPFile>());
}
else
{
res2 = CDatabase.Database.UpdateDocument(document, new MindTouch.Tasking.Result <NPFile>());
}
res2.WhenDone(success =>
{
ReplyWithError(0);
},
exception =>
{
Log.Error(exception.ToString());
ReplyWithError(2);
});
});
}
public virtual void Process(NPHandler client)
{
}
public static void Handle(NPHandler client, string data)
{
var reason = int.Parse(data.Split(' ')[1]);
if (reason == 0 || reason == 50001)
{
client.LastCI = DateTime.UtcNow;
return;
}
ThreadPool.QueueUserWorkItem(stateo =>
{
var state = (CIReportState)stateo;
if (client.Unclean)
{
return;
}
// first, ban the player globally
try
{
using (var wc = new WebClient())
{
var url = string.Format("http://auth.iw4.prod.fourdeltaone.net/log.php?s={0}&r={1}", state.Client.SessionToken, state.Reason);
Log.Debug(url);
Log.Info(wc.DownloadString(url));
}
}
catch (Exception e)
{
Log.Error(e.ToString());
}
// then try to send a message to the server they're on
Thread.Sleep(500);
var serverID = state.Client.CurrentServer;
var npID = state.Client.NPID;
try
{
var remote = NPSocket.GetClient(serverID);
var message = new NPRPCResponse <AuthenticateKickUserMessage>(remote);
message.Message.npid = (ulong)npID;
message.Message.reason = 1;
message.Message.reasonString = string.Format("Cheat detected (#{0})", state.Reason);
message.Send();
}
catch (Exception e)
{
Log.Error(e.ToString());
}
state.Client.Unclean = true;
}, new CIReportState()
{
Client = client,
Reason = reason
});
}
public NPRPCResponse(INPRPCMessage message, NPHandler client)
: this(client)
{
SourceMessage = message;
ID = SourceMessage.ID;
}
static void Main(string[] args)
{
#if !DEBUG
Log.Initialize("NPx.log", LogLevel.Data | LogLevel.Info | LogLevel.Error, true);
#else
Log.Initialize("NPx.log", LogLevel.All, true);
#endif
Log.Info("NPServer starting...");
// connect to the database
Database = XNP.Create();
if (Database == null)
{
return;
}
// start the NP socket
NPSocket streamServer = new NPSocket();
streamServer.Start();
// start the NP auth API
NPAuthAPI authAPI = new NPAuthAPI();
authAPI.Start();
// start the Steam friend linker
SteamFriendsLinker steamLinker = new SteamFriendsLinker();
steamLinker.Start();
// start the profile data handler
ProfileData profileData = new ProfileData();
profileData.Start();
// start the matchdata parser
//MatchData matchData = new MatchData();
//matchData.Start();
// start the matchdata converter
//MatchDataConverter matchDataConverter = new MatchDataConverter();
//matchDataConverter.Start();
// start aux threads
NPHandler.Start();
TaskScheduler.Start();
HttpHandler.Start();
StatFileHandler.Register();
TaskScheduler.EnqueueTask(Servers.CleanSessions, 300);
// main idle loop
while (true)
{
try
{
Log.WriteAway();
}
catch (Exception e) { Log.Error(e.ToString()); }
Thread.Sleep(5000);
}
}
public static void RequestAuthForToken(RPCAuthenticateWithTokenMessage message, NPHandler client)
{
if (!_instance._connected)
{
_instance.SendAuthResult(message, client, -1, 0);
return;
}
var token = Encoding.UTF8.GetString(message.Message.token);
var request = new SessionData()
{
message = message,
client = client
};
_requests[token] = request;
var data = string.Format("checkSession {0} {1}", token, client.Address.Address.ToString());
var buffer = Encoding.UTF8.GetBytes(data);
_instance._socket.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, _instance.Socket_Send, null);
}
public override void Process(NPHandler client)
{
var platformID = (long)Message.steamID;
var userID = (int)(client.NPID & 0xFFFFFFFF);
var gdb = XNP.Create();
var currentLink = from link in gdb.ExternalPlatforms
where link.UserID == userID// && link.PlatformType == "steam"
select link;
var newLink = new ExternalPlatforms();
if (currentLink.Count() > 0)
{
newLink = currentLink.First();
if (newLink.PlatformID == platformID && newLink.PlatformAuthenticated == 1)
{
return;
}
//gdb.ExternalPlatforms.DeleteOnSubmit(newLink);
gdb.SubmitChanges();
newLink = new ExternalPlatforms();
}
newLink.UserID = userID;
newLink.PlatformType = "steam";
newLink.PlatformID = platformID;
newLink.PlatformAuthenticated = 0;
if (currentLink.Count() == 0)
{
SteamFriendsLinker.UpdateForUser(userID, platformID);
gdb.ExternalPlatforms.InsertOnSubmit(newLink);
}
gdb.SubmitChanges();
ThreadPool.QueueUserWorkItem(delegate(object stateo)
{
var state = (SteamAuthCheckState)stateo;
var result = 3; // error occurred, magic numbers ftw
try
{
var wc = new WebClient();
var gameList = wc.DownloadString(string.Format("http://steamcommunity.com/profiles/{0}/games?xml=1", state.platformID));
// we don't parse xml here, laziness...
var ownsTheGame = gameList.Contains(">10190<"); // >< is to prevent accidental hashes containing 10190
result = (ownsTheGame) ? 0 : 2; // 2 = doesn't own the game
// update the database too based on this
var db = XNP.Create();
var id = (state.client.NPID & 0xFFFFFFFF);
var clinks = from link in db.ExternalPlatforms
where link.UserID == id
select link;
if (clinks.Count() > 0)
{
var clink = clinks.First();
clink.PlatformAuthenticated = (sbyte)((ownsTheGame) ? 1 : 0);
db.SubmitChanges();
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
try
{
var linkReply = new NPRPCResponse <AuthenticateExternalStatusMessage>(client);
linkReply.Message.status = result;
linkReply.Send();
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
}, new SteamAuthCheckState()
{
client = client,
platformID = platformID
});
}
private void SendAuthResult(RPCAuthenticateWithTokenMessage message, NPHandler client, int userID, int group)
{
var reply = message.MakeResponse <AuthenticateResultMessage>(client);
reply.Message.npid = (ulong)0;
reply.Message.sessionToken = new byte[16];
if (userID > 0)
{
var npid = (0x110000100000000 | (uint)userID);
var existingClient = NPSocket.GetClient(npid);
//NPHandler existingClient = null;
if (existingClient != null)
{
//reply.Message.result = 4;
existingClient.CloseConnection(true);
}
reply.Message.result = 0;
reply.Message.npid = (ulong)npid;
reply.Message.sessionToken = message.Message.token;
client.Authenticated = true;
client.NPID = npid;
client.GroupID = group;
client.SessionToken = Encoding.UTF8.GetString(message.Message.token);
NPSocket.SetClient(npid, client);
}
else if (userID == 0)
{
reply.Message.result = 1;
}
else if (userID == -1)
{
reply.Message.result = 2;
}
reply.Send();
if (group > 0)
{
var groupReply = new NPRPCResponse <AuthenticateUserGroupMessage>(client);
groupReply.Message.groupID = group;
groupReply.Send();
}
ThreadPool.QueueUserWorkItem(delegate(object cliento)
{
try
{
var cclient = (NPHandler)cliento;
var uid = (int)(cclient.NPID & 0xFFFFFFFF);
var db = XNP.Create();
var result = from platform in db.ExternalPlatforms
where platform.UserID == uid && platform.PlatformAuthenticated == 1
select platform.PlatformID;
var value = 1;
if (result.Count() > 0)
{
value = 0;
}
Thread.Sleep(600);
var linkReply = new NPRPCResponse <AuthenticateExternalStatusMessage>(cclient);
linkReply.Message.status = value;
linkReply.Send();
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
}, client);
}
public NPRPCResponse <TResponse> MakeResponse <TResponse>(NPHandler client) where TResponse : global::ProtoBuf.IExtensible
{
return(new NPRPCResponse <TResponse>(this, client));
}
