public void OnPlayerLeaveGame(INetworkConnection sender, Packet gmsg)
{
PacketGenericMessage msg = gmsg as PacketGenericMessage;
GameServerGame g = ServerUser.CurrentCharacter.GetCurrentGame();
if (g != null)
{
g.RemovePlayer(ServerUser.CurrentCharacter, "left the game.", true);
g.RemoveObserver(ServerUser.CurrentCharacter);
}
}
private void OnPatchInfoRequest(INetworkConnection con, Packet r)
{
PropertyBag bag = new PropertyBag();
bag.SetProperty("MB", ((PatchServerProcess)MyServer).MBytesPatchDataSent);
bag.SetProperty("Num", ((PatchServerProcess)MyServer).PatchFileSent);
bag.SetProperty("Users", ConnectionManager.ConnectionCount);
PacketGenericMessage msg = r as PacketGenericMessage;
r.ReplyPacket = CreateStandardReply(r, ReplyType.OK, "");
r.ReplyPacket.Parms = bag;
}
/// <summary>
/// Phase 1: Player requests login to the system. This method attempts to authenticate the player (or create a new account, depending on method parms)
/// </summary>
public void OnPlayerLoginRequest(INetworkConnection con, Packet pMsg)
{
if (!MyServer.RequireAuthentication)
{
DoNoAuthLogin(con, pMsg);
}
else
{
DoDatabaseLogin(con, pMsg);
}
}
public MainWindow()
{
using (Mutex m = new Mutex(false, "SERV"))
{
if (!m.WaitOne(TimeSpan.FromSeconds(1), false))
{
MessageBox.Show("Server is already running!");
Application.Current.Shutdown();
return;
}
}
InitializeComponent();
LogList = new ObservableCollection<DataLog>();
LogList.CollectionChanged += LogList_CollectionChanged;
Loaded += MainWindow_Loaded;
Application.Current.Exit += Current_Exit;
ServerPackets.ServerPacketHandler handler = new ServerPackets.ServerPacketHandler();
ContextMenu ctxMenu = this.Resources["ctxMenu"] as ContextMenu;
string[] opcodes = Enum.GetNames(typeof(Opcode));
short[] values = (short[])Enum.GetValues(typeof(Opcode));
var opcItr = opcodes.Zip(values, (o, v) => new Tuple<string, Opcode>(o, (Opcode)v)).Where( (t) => t.Item1.StartsWith("C") && t.Item2 != Opcode.Count);
foreach (var pair in opcItr)
{
MenuItem item = new MenuItem { Header = pair.Item1, Tag = pair.Item2 };
item.Click += Item_Click;
ctxMenu.Items.Add(item);
}
MenuItem item2 = new MenuItem { Header = "Test" };
item2.Click += (s, e) =>
{
Packet p = new Packet(Opcode.Test);
p.WriteString(new string('*', 1000));
GameWorld.SendToAll(p);
};
ctxMenu.Items.Add(item2);
}
public override void OnAfterPacketProcessed(Packet p)
{
base.OnAfterPacketProcessed(p); // handles duplicate request safeguards and sending of the reply packet
if (p.ReplyPacket != null && p.ReplyPacket.ReplyCode == ReplyType.AuthorizationTicketExpired)
{
KillConnection("Disconnecting client. " + p.ReplyPacket.ReplyMessage);
return;
}
if (ServerUser != null && ServerUser.IsAuthorizedClusterServer)
{
return;
}
m_TimeoutTimer.Start();
}
private void Item_Click(object sender, RoutedEventArgs e)
{
MenuItem item = sender as MenuItem;
Opcode opc = (Opcode)item.Tag;
Packet p = new Packet(opc);
GameWorld.SendToAll(p);
}
private void OnCreateRandUnit(object sender, RoutedEventArgs e)
{
Packet p = new Packet(Opcode.CCreateRandomUnit);
GameWorld.SendToAll(p);
}
protected virtual void OnRequestDeleteCharacterReply(INetworkConnection con, Packet reply)
{
PacketReply p = reply as PacketReply;
if (p.ReplyCode != ReplyType.OK)
{
FireDeleteCharacterFailed(p.ReplyMessage);
}
else
{
RequestCharacterListing();
}
}
void HandleSocket()
{
byte[] buffer = new byte[4096];
int bytesToRead = 0;
int currentBufferPos = 0;
while (Socket.Connected)
{
int receivedBytes = 0;
try
{
receivedBytes = Socket.Receive(buffer, currentBufferPos, 256, SocketFlags.None);
currentBufferPos += receivedBytes;
}
catch (Exception e)
{
Log.Error(e.Message);
break;
}
if (receivedBytes == 0)
continue;
if (currentBufferPos > 3)
{
bytesToRead = ReadPacketLength(buffer) - currentBufferPos;
while (bytesToRead > 0)
{
int received = 0;
try
{
received = Socket.Receive(buffer, currentBufferPos, bytesToRead, SocketFlags.None);
}
catch (Exception e)
{
Log.Error(e.Message);
break;
}
bytesToRead -= received;
currentBufferPos += received;
}
if (bytesToRead == 0)
{
Packet p = new Packet(buffer);
currentBufferPos = 0;
if (OnPacketReceive != null)
OnPacketReceive(p);
}
}
else
continue;
}
CloseSocket();
}
/// <summary>
/// Serializes and sends a packet across the wire
/// </summary>
/// <param name="msg">The packet to send</param>
public virtual int Send(Packet msg)
{
try
{
if (msg.NeedsDeliveryAck)
{
m_NumAcksWaitingFor++;
}
byte[] raw = OwningConnection.SerializePacket(msg);
//Log.LogMsg("Sending -> " + msg.GetType().ToString() + " (" + raw.Length.ToString() + " bytes)");
//Log.LogMsg(" That message is " + raw.Length.ToString() + " bytes long");
return Send(raw, msg.Flags);
}
catch (Exception sendExc)
{
OwningConnection.KillConnection(sendExc.Message);
return -1; ;
}
}
protected void SendGameMessageReply(ServerUser client, ReplyType rp, string msg, Packet inResponseToPacket, PropertyBag parms, bool compress, bool encrypt)
{
PacketReply rmsg = client.MyConnection.CreateStandardReply(inResponseToPacket, rp, msg);
if (parms != null)
{
rmsg.Parms = parms;
}
rmsg.IsCompressed = compress;
rmsg.IsEncrypted = encrypt;
inResponseToPacket.ReplyPacket = rmsg;
}
protected void OnGameStartReply(INetworkConnection con, Packet p)
{
PacketReply rep = p as PacketReply;
if (rep.ReplyCode != ReplyType.OK)
{
// only fire this event if it the request fails.
// if the start request succeeds, then OnGameStarted will fire
FireGameStartReply(this, false, rep.ReplyMessage);
}
}
public void Send(Packet p)
{
Log.Write("Sending opc: " + p.Opcode);
Connection.Socket.Send(p.GetBytes());
}
private void OnCharacterSelectRequest(INetworkConnection con, Packet mesg)
{
PacketGenericMessage genMsg = mesg as PacketGenericMessage;
string msg = "";
ReplyType rslt = ReplyType.OK;
int id = genMsg.Parms.GetIntProperty((int)PropertyID.CharacterId).GetValueOrDefault(-1);
ServerCharacterInfo ci = null;
// if we don't use characters, there wont be one in the DB
if (MyServer.UseCharacters)
{
ci = CharacterUtil.Instance.LoadCharacter(ServerUser, id, ref msg);
}
if (ci == null && ServerUser.CurrentCharacter != null && ServerUser.CurrentCharacter.ID == id)
{
ci = ServerUser.CurrentCharacter;
}
PacketReply rep = CreateStandardReply(genMsg, rslt, msg);
//genMsg.ReplyPacket = rep;
if (ci == null)
{
genMsg.ReplyPacket = rep;
rep.ReplyCode = ReplyType.Failure;
rep.ReplyMessage = "Unable to load character.";
return;
}
ServerUser.CurrentCharacter = ci;
CharacterCache.CacheCharacter(ci, MyServer.ServerUserID, TimeSpan.MaxValue);
rep.Parms.SetProperty((int)PropertyID.CharacterInfo, ci.CharacterInfo as IComponent);
Send(rep); // reply needs to arrive before the OnSelected event is fired, in case OnSelected results in a server transfer
OnCharacterSelected(ci);
}
protected override void HandlePacket(Packet p)
{
// is the packet a GameMessage or a reply to a GameMessage, then the game will handle it.
if (p.PacketTypeID == (int)LobbyPacketType.GameMessage)
{
try
{
if (CurrentGame != null)
{
CurrentGame.HandleGamePacket(this, p as PacketGameMessage);
}
}
catch
{
}
}
else if (p.PacketTypeID == (int)PacketType.GenericReply && ((PacketReply)p).ReplyPacketType == (int)LobbyPacketType.GameMessage)
{
try
{
if (CurrentGame != null)
{
CurrentGame.HandleGamePacketReply(this, p as PacketGameMessage);
}
}
catch
{
}
}
else
{
base.HandlePacket(p);
}
}
private void OnCharacterListingRequest(INetworkConnection con, Packet msg)
{
// character was created successfully. send a listing of all new characters
PacketCharacterListing pcl = (PacketCharacterListing)con.CreatePacket((int)PacketType.CharacterListing, 0, false, false);
List<ICharacterInfo> allToons = CharacterUtil.Instance.GetCharacterListing(this.ServerUser.ID);
if (allToons.Count == 0)
{
if(ServerUser.CurrentCharacter != null)
{
pcl.Characters.Add(ServerUser.CurrentCharacter.CharacterInfo);
}
else
{
pcl.Characters = new List<ICharacterInfo>();
}
}
else
{
foreach (ICharacterInfo inf in allToons)
{
pcl.Characters.Add(inf);
}
}
msg.ReplyPacket = pcl;
}
private void OnCharacterDeleteRequest(INetworkConnection con, Packet gmsg)
{
PacketGenericMessage msg = gmsg as PacketGenericMessage;
string rsltMsg = "";
ReplyType rslt = ReplyType.Failure;
int characterId = msg.Parms.GetIntProperty((int)PropertyID.CharacterId).GetValueOrDefault();
if(MyServer.UseCharacters && MyServer.RequireAuthentication && CharacterUtil.Instance.DeleteCharacter(characterId, ServerUser, false, "Player requested deletion from [" + con.RemoteEndPoint.ToString() + "].", ref rsltMsg))
{
rslt = ReplyType.OK;
}
PacketReply rep = CreateStandardReply(msg, rslt, rsltMsg);
msg.ReplyPacket = rep;
}
private void OnCharacterCreateRequest(INetworkConnection con, Packet gmsg)
{
PacketGenericMessage msg = gmsg as PacketGenericMessage;
string rsltMsg = "";
ServerCharacterInfo ci = null;
if(MyServer.UseCharacters)
{
ci = CharacterUtil.Instance.CreateNewCharacter(msg.Parms, ServerUser);
}
ReplyType rslt = ReplyType.Failure;
if (ci != null && OnValidateCharacterCreateRequest(ci, ref rsltMsg))
{
if (CharacterUtil.Instance.PersistNewCharacter(ci, ServerUser, ref rsltMsg, !MyServer.RequireAuthentication))
{
rslt = ReplyType.OK;
}
}
PacketReply rep = CreateStandardReply(msg, rslt, rsltMsg);
msg.ReplyPacket = rep;
}
private void OnCharacterActivated(INetworkConnection con, Packet gmsg)
{
PacketGenericMessage msg = gmsg as PacketGenericMessage;
CharacterInfo ci = msg.Parms.GetComponentProperty((int)PropertyID.CharacterInfo) as CharacterInfo;
CurrentCharacter = ci;
FireCharacterActivated(this, EventArgs.Empty);
}
protected virtual void OnRequestSelectCharacterReply(INetworkConnection con, Packet reply)
{
PacketReply p = reply as PacketReply;
if (p.ReplyCode != ReplyType.OK)
{
FireSelectCharacterFailed(p.ReplyMessage);
}
else if (p.ReplyCode == ReplyType.OK)
{
CurrentCharacter = p.Parms.GetComponentProperty((int)PropertyID.CharacterInfo) as CharacterInfo;
FireCharacterActivated(this, EventArgs.Empty);
}
}
protected void OnGameNotification(INetworkConnection con, Packet p)
{
PacketMatchNotification note = p as PacketMatchNotification;
if (CurrentGame != null)
{
if (CurrentGame.GameID != note.TheGameID)
{
return;
}
}
switch (note.Kind)
{
case MatchNotificationType.PlayerRemoved:
OnPlayerRemovedFromGame(note);
break;
case MatchNotificationType.PlayerAdded:
OnPlayerAddedToGame(note);
break;
case MatchNotificationType.MatchCreated:
OnGameCreated(note);
break;
case MatchNotificationType.ObserverAdded:
OnObserverAdded(note);
break;
case MatchNotificationType.ObserverRemoved:
OnObserverRemoved(note);
break;
case MatchNotificationType.MatchStarted:
OnGameStarted(note);
break;
case MatchNotificationType.MatchEnded :
OnGameEnded(note);
break;
default:
Log.LogMsg("Unhandled packet match notification [" + note.Kind.ToString() + "]");
break;
}
}
public override bool OnBeforePacketProcessed(Packet p)
{
// if the base class doesn't think we should process the packet, then we don't think so either.
if (!base.OnBeforePacketProcessed(p)) // check for duplicate requests and send ACK if requested
{
return false;
}
// Check for authorization. The only packet types that do not require authorization are ServerGreeting, RijndaelExchange, LineSecured, LoginRequest/Result, Null and Reply
// these are defined as -1000 to -994.
if (p.PacketTypeID < -1000 || p.PacketTypeID > -994 && !ServerUser.IsAuthorizedClusterServer)
{
if (ServerUser.AuthorizationExpires < DateTime.UtcNow)
{
PacketReply rep = CreateStandardReply(p, ReplyType.AuthorizationTicketExpired, "Not authorized.");
p.NeedsReply = true;
p.ReplyPacket = rep;
Send(rep);
KillConnection("Authorization expired.");
return false; // prevent calling handler for this packet, since we're not authorized
}
else
{
ServerUser.RenewAuthorizationTicket();
}
}
if (p.PacketTypeID != (int)PacketType.ACK && p.PacketTypeID != (int)PacketType.NATInfo)
{
m_TimeoutTimer.Stop();
}
return true;
}
protected override bool CanCreateNewAccount(Packet p, ref string msg)
{
m_IsNewAcct = true;
return base.CanCreateNewAccount(p, ref msg);
}
/// <summary>
/// If it's a UDP null packet, assume it's a keep-alive
/// </summary>
private void OnNATInfo(INetworkConnection con, Packet msg)
{
//Log1.Logger("Server.Network").Debug("Got NAT poke from " + ((InboundConnection)con).ServerUser.AccountName);
// update nat info
IPEndPoint tcpep = null;
try
{
tcpep = MyTCPSocket.RemoteEndPoint as IPEndPoint;
if (tcpep == null)
{
return;
}
}
catch
{
return;
}
UDPSendTarget = new IPEndPoint(tcpep.Address, ((PacketNATInfo)msg).ListenOnPort);
}
void HandlePacket(Packet p)
{
ServerPacketHandler.Instance.HandleOpcode(this, p);
}
/// <summary>
/// Encryption helper method.
/// </summary>
private void OnRijndaelExchange(INetworkConnection con, Packet pck)
{
PacketRijndaelExchange msg = pck as PacketRijndaelExchange;
try
{
m_ConnectionKey = CryptoManager.DecryptRijndaelKey(msg.RijndaelExchangeData);
PacketLineSecured p = (PacketLineSecured)CreatePacket((int)PacketType.LineSecured, 0, false, true);
p.Key = CryptoManager.RijEncrypt(m_ConnectionKey, 0, m_ConnectionKey.Length, m_ConnectionKey);
p.ReplyCode = ReplyType.OK;
msg.ReplyPacket = p;
RemoteRsaKey = msg.PublicRSAKey;
}
catch (Exception e)
{
KillConnection("Encryption key exchange error. Disconnecting client connection. " + e.Message);
}
}
protected virtual void TimestampOutgoingPacket(Packet msg)
{
msg.SentOnUTC = DateTime.UtcNow.Ticks;
}
public void Send(Packet p)
{
_connection.Socket.Send(p.GetBytes());
}
protected void SendGameMessageReply(ServerUser client, ReplyType rp, Packet inResponseToPacket, bool compress, bool encrypt)
{
SendGameMessageReply(client, rp, "", inResponseToPacket, null, compress, encrypt);
}
public static void SendToAll(Packet p)
{
foreach (var s in Connections)
s.Send(p);
}
