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); }