public static PacketProcessResult HandleAuthSession(PacketProcessor p)
{
CMSG_AUTH_SESSION auth = new CMSG_AUTH_SESSION();
UInt32 unk, unk2, unk3, unk4, unk5;
UInt64 unk6;
auth.Build = p.currentPacket.ReadUInt32();
unk = p.currentPacket.ReadUInt32();
auth.Account = p.currentPacket.ReadCString();
unk2 = p.currentPacket.ReadUInt32();
auth.Seed = p.currentPacket.ReadUInt32();
unk3 = p.currentPacket.ReadUInt32();
unk4 = p.currentPacket.ReadUInt32();
unk5 = p.currentPacket.ReadUInt32();
unk6 = p.currentPacket.ReadUInt64();
auth.Digest = p.currentPacket.ReadBigInteger(20);
var decompressedDataSize = p.currentPacket.ReadInt32();
var compressedData = p.currentPacket.ReadBytes((int)(p.currentPacket.Length - p.currentPacket.Position)); //read remaining array
auth.AddonData = Shared.ZLib.Decompress(compressedData);
var realmprocessor = p as RealmPacketProcessor;
//get the encryption keys first because errors are encrypted too
p.sock.session.GetSessionKeyFromAuthAccount(auth.Account).Wait();
realmprocessor.SetupCrypto(p.sock.session.GetSessionKey().Result);
p.sock.session.HandleAuthSession(auth, realmprocessor.Seed);
return PacketProcessResult.Processed;
}
public static PacketProcessResult HandleRealmList(PacketProcessor p)
{
p.dataNeeded = 5; if (p.currentPacket.Length < p.dataNeeded) return PacketProcessResult.RequiresData;
if (p.sock != null && p.sock.session != null)
p.sock.session.OnRealmList();
return PacketProcessResult.Processed;
}
public static PacketProcessResult HandleRequestAccountData(PacketProcessor p)
{
var type = p.CurrentPacket.ReadUInt32();
p.ClientConnection.CurrentSession.HandleRequestAccountData(type);
return PacketProcessResult.Processed;
}
public static PacketProcessResult HandleRealmList(PacketProcessor p)
{
p.DataNeeded = 5;
if (p.CurrentPacket.Length < p.DataNeeded) return PacketProcessResult.RequiresData;
if (p.ClientConnection != null && p.ClientConnection.CurrentSession != null)
p.ClientConnection.CurrentSession.OnRealmList();
return PacketProcessResult.Processed;
}
public static PacketProcessResult HandleRequestAccountData(PacketProcessor p)
{
var type = p.currentPacket.ReadUInt32();
p.sock.session.HandleRequestAccountData(type);
return PacketProcessResult.Processed;
}
public static PacketProcessResult HandlePlayerLogin(PacketProcessor p)
{
CMSG_PLAYER_LOGIN pkt = new CMSG_PLAYER_LOGIN();
pkt.Read(p.CurrentPacket);
p.ClientConnection.CurrentSession.HandlePlayerLogin(pkt);
return PacketProcessResult.Processed;
}
public static PacketProcessResult HandleCharCreate(PacketProcessor p)
{
CMSG_CHAR_CREATE create = new CMSG_CHAR_CREATE();
create.Read(p.CurrentPacket);
p.ClientConnection.CurrentSession.HandleCharCreate(create);
return PacketProcessResult.Processed;
}
public static PacketProcessResult HandleLogoutRequest(PacketProcessor p)
{
var player = p.ClientConnection.CurrentPlayer;
if (player == null)
return PacketProcessResult.Processed;
player.Logout(true).Wait();
return PacketProcessResult.Processed;
}
public static PacketProcessResult HandleUpdateAccountData(PacketProcessor p)
{
var type = p.CurrentPacket.ReadUInt32();
var time = p.CurrentPacket.ReadUInt32();
var size = p.CurrentPacket.ReadUInt32();
var data = p.CurrentPacket.ReadBytes((int) p.CurrentPacket.RemainingLength);
p.ClientConnection.CurrentSession.HandleUpdateAccountData(type, time, size, data);
return PacketProcessResult.Processed;
}
public static PacketProcessResult HandlePing(PacketProcessor p)
{
CMSG_PING pkt = new CMSG_PING();
pkt.Read(p.CurrentPacket);
PacketOut pout = new PacketOut(RealmOp.SMSG_PONG);
pout.Write(pkt.ping);
pout.Finalise();
p.ClientConnection.Send(pout.strm.ToArray());
return PacketProcessResult.Processed;
}
public static PacketProcessResult HandleLogoutRequest(PacketProcessor p)
{
var player = p.ClientConnection.CurrentPlayer;
if (player == null)
{
return(PacketProcessResult.Processed);
}
player.Logout(true).Wait();
return(PacketProcessResult.Processed);
}
/// <summary>
/// Roundrestart server.
/// </summary>
/// <param name="port">Optional for redirecting everyone to other server..</param>
public void RoundRestart(ushort port = 0)
{
NetDataWriter writer = new NetDataWriter();
writer.Put(port);
PacketProcessor.Send <ServerInteractPacket>(Peer,
new ServerInteractPacket()
{
AddonId = Assembly.GetCallingAssembly().GetAddonId(),
Type = (byte)ServerInteractionType.Hint,
Data = writer.Data,
}, DeliveryMethod.ReliableOrdered);
}
public static PacketProcessResult HandleRealmList(PacketProcessor p)
{
p.DataNeeded = 5;
if (p.CurrentPacket.Length < p.DataNeeded)
{
return(PacketProcessResult.RequiresData);
}
if (p.ClientConnection != null && p.ClientConnection.CurrentSession != null)
{
p.ClientConnection.CurrentSession.OnRealmList();
}
return(PacketProcessResult.Processed);
}
private void RawPacketReceived(byte[] data)
{
IDataPacket parsedPacket;
using (var ms = new MemoryStream(data)
{
Position = 2
})
{
parsedPacket = PacketProcessor.ParsePacket(ms);
parsedPacket.DeserializeFrom(ms);
}
OnPacketReceived.Raise(this, new ClientPacketEventArgs(parsedPacket, this, data.Length));
}
public static PacketProcessResult HandlePing(PacketProcessor p)
{
CMSG_PING pkt = new CMSG_PING();
pkt.Read(p.CurrentPacket);
PacketOut pout = new PacketOut(RealmOp.SMSG_PONG);
pout.Write(pkt.ping);
pout.Finalise();
p.ClientConnection.Send(pout.strm.ToArray());
return(PacketProcessResult.Processed);
}
public override void OnRecvPacket(GSPacketIn pkg)
{
if (this.m_packetProcessor == null)
{
this.m_packetLib = AbstractPacketLib.CreatePacketLibForVersion(1, this);
this.m_packetProcessor = new PacketProcessor(this);
}
if (this.m_player != null)
{
pkg.ClientID = this.m_player.PlayerId;
pkg.WriteHeader();
}
this.m_packetProcessor.HandlePacket(pkg);
}
public PacketHandler(TcpServer tcpServer, TimeKeeper timeKeeper)
{
this.defaultPacketProcessor = new DefaultServerPacketProcessor(tcpServer);
var ProcessorArguments = new Dictionary <Type, object>
{
{ typeof(TcpServer), tcpServer },
{ typeof(TimeKeeper), timeKeeper },
};
authenticatedPacketProcessorsByType = PacketProcessor.GetProcessors(ProcessorArguments, p => p.BaseType.IsGenericType && p.BaseType.GetGenericTypeDefinition() == typeof(AuthenticatedPacketProcessor <>));
unauthenticatedPacketProcessorsByType = PacketProcessor.GetProcessors(ProcessorArguments, p => p.BaseType.IsGenericType && p.BaseType.GetGenericTypeDefinition() == typeof(UnauthenticatedPacketProcessor <>));
}
private void Update()
{
PacketProcessor.ProcessPacketQueue();
if (SimulatedWorld.IsGameLoaded)
{
mechaSynchonizationTimer += Time.deltaTime;
if (mechaSynchonizationTimer > MECHA_SYNCHONIZATION_INTERVAL)
{
SendPacket(new PlayerMechaData(GameMain.mainPlayer));
mechaSynchonizationTimer = 0f;
}
}
}
/* END OF MAIL TAB*/
private async void materialRaisedButton13_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(txtPlayerID.Text))
{
MessageBox.Show("The Player-ID can't be empty!", "Error", MessageBoxButtons.OKCancel, MessageBoxIcon.Error);
}
else
{
var id = Convert.ToInt64(txtPlayerID.Text);
var player = await ResourcesManager.GetPlayer(id);
PacketProcessor.Send(new OutOfSyncMessage(player.GetClient()));
}
}
/// <summary>
/// Execute command on server.
/// </summary>
/// <param name="command">Command name.</param>
/// <param name="arguments">Command arguments.</param>
public void ExecuteCommand(string command, List <string> arguments)
{
NetDataWriter writer = new NetDataWriter();
writer.Put(command);
writer.PutArray(arguments.ToArray());
PacketProcessor.Send <ServerInteractPacket>(Peer,
new ServerInteractPacket()
{
AddonId = Assembly.GetCallingAssembly().GetAddonId(),
Type = (byte)ServerInteractionType.ExecuteCommand,
Data = writer.Data,
}, DeliveryMethod.ReliableOrdered);
}
// Use this for initialization
void OnEnable()
{
serverResponseFinished = false;
characterServerResponse = new List <SubPacket>();
CharacterQueryPacket cq = new CharacterQueryPacket(Utils.GetAccountName());
SubPacket sp = cq.BuildQueryPacket();
BasePacket packetToSend = BasePacket.CreatePacket(sp, PacketProcessor.isAuthenticated, false);
packetProcessor = GameObject.FindGameObjectWithTag("PacketProcessor").GetComponent <PacketProcessor>();
statusBoxHandler.InstantiateStatusBoxPrefabWithNoMenuLink(MenuPrefabs.StatusBox);
StatusBoxHandler.statusText = "Status: Retrieving character list from server";
packetProcessor.SendPacket(packetToSend);
StartCoroutine(WaitForServerResponseThenDisplayCharacters());
}
// Start is called before the first frame update
public Client(Engine engine, ClientPlayer player)
{
_engine = engine;
_serverIpEndPoint = new IPEndPoint(IPAddress.Parse(engine.serverIp), engine.serverListeningPort);
_packetProcessor = new PacketProcessor(null, engine.clientListeningPort, true);
players = new Dictionary <int, ClientPlayer>();
enemies = new Dictionary <int, ClientEnemy>();
_interpolation = new Interpolation(engine);
_prediction = new Prediction(player, _engine.playerId);
_player = player;
_floorMask = LayerMask.GetMask("Floor");
_healthSlider = GameObject.FindGameObjectsWithTag("Health")[0].GetComponent <Slider>();
_damageImage = GameObject.FindGameObjectsWithTag("DamageImage")[0].GetComponent <Image>();
_packetProcessor.SendReliableFastData(null, _serverIpEndPoint, MessageType.Join, _sequence);
}
private void SendDeleteCharacterRequest()
{
CharacterDeletePacket cd = new CharacterDeletePacket(characterID);
SubPacket sp = cd.GetQueryPacket();
BasePacket packetToSend = BasePacket.CreatePacket(sp, PacketProcessor.isAuthenticated, false);
var box = gameObject.GetComponent <StatusBoxHandler>();
box.InstantiateStatusBoxPrefabWithNoMenuLink(MenuPrefabs.StatusBox);
StatusBoxHandler.statusText = "Waiting for response from server..";
PacketProcessor packetProcessor = GameObject.FindGameObjectWithTag("PacketProcessor").GetComponent <PacketProcessor>();
packetProcessor.SendPacket(packetToSend);
StartCoroutine(WaitForServerResponse(box));
}
public override void Process(Level level)
{
if (string.IsNullOrEmpty(PlayerName) || PlayerName.Length > 15)
{
ResourcesManager.DisconnectClient(Client);
}
else
{
level.GetPlayerAvatar().SetName(PlayerName);
AvatarNameChangeOkMessage p = new AvatarNameChangeOkMessage(Client);
p.SetAvatarName(level.GetPlayerAvatar().GetAvatarName());
PacketProcessor.Send(p);
}
//new RequestConfirmChangeNameMessage(Client, PlayerName);
}
/// <summary>
/// 收到协议包
/// </summary>
/// <param name="pkg"></param>
public override void OnRecvPacket(GSPacketIn pkg)
{
if (m_packetProcessor == null)
{
m_packetLib = AbstractPacketLib.CreatePacketLibForVersion(1, this);
m_packetProcessor = new PacketProcessor(this);
}
if (m_player != null)
{
pkg.ClientID = m_player.PlayerId;
pkg.WriteHeader();
}
//LogMsg(Marshal.ToHexDump("recevie:", pkg.Buffer, 0, pkg.Length));
m_packetProcessor.HandlePacket(pkg);
}
/// <summary>
/// Display hint on server.
/// </summary>
/// <param name="message">The message to be sent.</param>
/// <param name="duration">Duration of hint.</param>
/// <param name="isAdminOnly">Is displayed only for admins.</param>
public void SendHint(string message, float duration, bool isAdminOnly = false)
{
NetDataWriter writer = new NetDataWriter();
writer.Put(message);
writer.Put(duration);
writer.Put(isAdminOnly);
PacketProcessor.Send <ServerInteractPacket>(Peer,
new ServerInteractPacket()
{
AddonId = Assembly.GetCallingAssembly().GetAddonId(),
Type = (byte)ServerInteractionType.Hint,
Data = writer.Data,
}, DeliveryMethod.ReliableOrdered);
}
public bool ProcessPacket(Guid sourcePlayerId, Packet packet)
{
#if DEBUG
Console.WriteLine($"Handling packet {packet.GetType().Name} from {sourcePlayerId}");
#endif
Type packetType = packet.GetType();
if (!registeredProcessors.ContainsKey(packetType))
{
return(false);
}
PacketProcessor processor = registeredProcessors.First(p => p.Key == packetType).Value;
processor.ProcessPacket(sourcePlayerId, packet, processorContext);
return(true);
}
public override async void Execute(Level level)
{
try
{
ClientAvatar player = level.GetPlayerAvatar();
long allianceID = player.GetAllianceId();
Alliance alliance = await ObjectManager.GetAlliance(allianceID);
ChallangeStreamEntry cm = new ChallangeStreamEntry();
cm.SetMessage(Message);
cm.SetSenderId(player.GetId());
cm.SetSenderName(player.GetAvatarName());
cm.SetSenderLevel(player.GetAvatarLevel());
cm.SetSenderRole(await player.GetAllianceRole());
cm.SetId(alliance.GetChatMessages().Count + 1);
cm.SetSenderLeagueId(player.GetLeagueId());
StreamEntry s = alliance.GetChatMessages().Find(c => c.GetStreamEntryType() == 12);
if (s != null)
{
alliance.GetChatMessages().RemoveAll(t => t == s);
foreach (AllianceMemberEntry op in alliance.GetAllianceMembers())
{
Level alliancemembers = await ResourcesManager.GetPlayer(op.GetAvatarId());
if (alliancemembers.GetClient() != null)
{
PacketProcessor.Send(new AllianceStreamEntryRemovedMessage(alliancemembers.GetClient(), s.GetId()));
}
}
}
alliance.AddChatMessage(cm);
foreach (AllianceMemberEntry op in alliance.GetAllianceMembers())
{
Level alliancemembers = await ResourcesManager.GetPlayer(op.GetAvatarId());
if (alliancemembers.GetClient() != null)
{
AllianceStreamEntryMessage p = new AllianceStreamEntryMessage(alliancemembers.GetClient());
p.SetStreamEntry(cm);
PacketProcessor.Send(p);
}
}
} catch (Exception) { }
}
private async void materialRaisedButton14_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(txtPlayerID.Text))
{
MessageBox.Show("The Player-ID can't be empty!", "Error", MessageBoxButtons.OKCancel, MessageBoxIcon.Error);
}
else
{
long id = Convert.ToInt64(txtPlayerID.Text);
Level player = await ResourcesManager.GetPlayer(id);
player.SetAccountStatus(100);
DatabaseManager.Single().Save(player);
PacketProcessor.Send(new OutOfSyncMessage(player.GetClient()));
}
}
public override void Execute(Level level)
{
if (level.GetAccountPrivileges() >= GetRequiredAccountPrivileges())
{
foreach (var onlinePlayer in ResourcesManager.GetOnlinePlayers())
{
var p = new ShutdownStartedMessage(onlinePlayer.GetClient());
p.SetCode(5);
PacketProcessor.Send(p);
}
}
else
{
SendCommandFailedMessage(level.GetClient());
}
}
public override void Execute(Level level)
{
if (level.GetAccountPrivileges() >= GetRequiredAccountPrivileges())
{
var p = level.GetPlayerAvatar();
p.SetResourceCount(CSVManager.DataTables.GetResourceByName("Gold"), 999999999);
p.SetResourceCount(CSVManager.DataTables.GetResourceByName("Elixir"), 999999999);
p.SetResourceCount(CSVManager.DataTables.GetResourceByName("DarkElixir"), 999999999);
p.SetDiamonds(999999999);
PacketProcessor.Send(new OwnHomeDataMessage(level.GetClient(), level));
}
else
{
SendCommandFailedMessage(level.GetClient());
}
}
private void ProcessUnauthenticated(Packet packet, NitroxConnection connection)
{
try
{
Type serverPacketProcessorType = typeof(UnauthenticatedPacketProcessor <>);
Type packetType = packet.GetType();
Type packetProcessorType = serverPacketProcessorType.MakeGenericType(packetType);
PacketProcessor processor = (PacketProcessor)NitroxServiceLocator.LocateService(packetProcessorType);
processor.ProcessPacket(packet, connection);
}
catch (Exception ex)
{
Log.Error(ex, $"Received invalid, unauthenticated packet: {packet}");
}
}
void Start()
{
EventBasedNetListener listener = new EventBasedNetListener();
client = new NetManager(listener);
listener.PeerConnectedEvent += peer => Debug.Log("connected to server");
listener.PeerDisconnectedEvent += handleDisconnect;
listener.NetworkReceiveEvent += PacketProcessor.ReadAllPackets;
PacketProcessor.Subscribe <ServerReadyToReceiveDeckSignalPacket>(handleServerReadyToReceiveDeck);
PacketProcessor.Subscribe <MatchManager>(handleManagerPacket);
client.Start();
server = client.Connect(IP, NetworkConstants.ServerPort, NetworkConstants.VersionNumberConnectionKey);
}
public override async void Process(Level level)
{
try
{
Level targetLevel = await ResourcesManager.GetPlayer(AvatarId);
targetLevel.Tick();
Alliance alliance = await ObjectManager.GetAlliance(level.GetPlayerAvatar().GetAllianceId());
PacketProcessor.Send(new VisitedHomeDataMessage(Client, targetLevel, level));
if (alliance != null)
{
PacketProcessor.Send(new AllianceStreamMessage(Client, alliance));
}
} catch (Exception) { }
}
private void RawPacketReceived(object sender, RawServerPacketEventArgs e)
{
IDataPacket parsedPacket;
var rawDat = e.RawData;
rawDat = PacketProcessor.ProcessRawData(rawDat);
using (var ms = new MemoryStream(rawDat)
{
Position = 2
})
{
parsedPacket = PacketProcessor.ParsePacket(ms);
parsedPacket.DeserializeFrom(ms);
}
OnPacketReceived.Raise(this, new ServerPacketEventArgs(parsedPacket, e.Peer, this, e.RawData.Length));
}
bool SendRawPacketInternal(RawPacket packet, byte[] buffer,
Socket socket, TeraEncryptionSession encryption, bool server)
{
lock (socket)
{
var header = new PacketHeader((ushort)packet.Payload.Length,
Proxy.Processor.Serializer.GameMessages.NameToOpCode[packet.OpCode]);
PacketProcessor.WriteHeader(header, buffer);
Buffer.BlockCopy(packet.Payload, 0, buffer,
PacketHeader.HeaderSize, header.Length);
return(SendInternal(buffer, header.FullLength, false,
socket, encryption, server));
}
}
public override async void Execute(Level level)
{
try
{
ClientAvatar player = level.GetPlayerAvatar();
TroopRequestStreamEntry cm = new TroopRequestStreamEntry();
Alliance all = await ObjectManager.GetAlliance(player.GetAllianceId());
cm.SetId(all.GetChatMessages().Count + 1);
cm.SetSenderId(player.GetId());
cm.SetHomeId(player.GetId());
cm.SetSenderLeagueId(player.GetLeagueId());
cm.SetSenderName(player.GetAvatarName());
cm.SetSenderRole(await player.GetAllianceRole());
cm.SetMessage(Message);
cm.SetMaxTroop(player.GetAllianceCastleTotalCapacity());
all.AddChatMessage(cm);
StreamEntry s = all.GetChatMessages().Find(c => c.GetSenderId() == level.GetPlayerAvatar().GetId() && c.GetStreamEntryType() == 1);
if (s == null)
{
all.GetChatMessages().RemoveAll(t => t == s);
}
all.AddChatMessage(cm);
foreach (AllianceMemberEntry op in all.GetAllianceMembers())
{
Level aplayer = await ResourcesManager.GetPlayer(op.GetAvatarId());
if (aplayer.GetClient() != null)
{
if (s != null)
{
PacketProcessor.Send(new AllianceStreamEntryRemovedMessage(aplayer.GetClient(), s.GetId()));
}
AllianceStreamEntryMessage p = new AllianceStreamEntryMessage(aplayer.GetClient());
p.SetStreamEntry(cm);
PacketProcessor.Send(p);
}
}
}
catch (Exception)
{
ResourcesManager.DropClient(level.GetClient().GetSocketHandle());
}
}
public override void Update()
{
PacketProcessor.ProcessPacketQueue();
if (Multiplayer.Session.IsGameLoaded)
{
gameResearchHashUpdateTimer += Time.deltaTime;
productionStatisticsUpdateTimer += Time.deltaTime;
dysonLaunchUpateTimer += Time.deltaTime;
dysonSphereUpdateTimer += Time.deltaTime;
warningUpdateTimer += Time.deltaTime;
if (gameResearchHashUpdateTimer > GAME_RESEARCH_UPDATE_INTERVAL)
{
gameResearchHashUpdateTimer = 0;
if (GameMain.data.history.currentTech != 0)
{
TechState state = GameMain.data.history.techStates[GameMain.data.history.currentTech];
SendPacket(new GameHistoryResearchUpdatePacket(GameMain.data.history.currentTech, state.hashUploaded, state.hashNeeded));
}
}
if (productionStatisticsUpdateTimer > STATISTICS_UPDATE_INTERVAL)
{
productionStatisticsUpdateTimer = 0;
Multiplayer.Session.Statistics.SendBroadcastIfNeeded();
}
if (dysonLaunchUpateTimer > LAUNCH_UPDATE_INTERVAL)
{
dysonLaunchUpateTimer = 0;
Multiplayer.Session.Launch.SendBroadcastIfNeeded();
}
if (dysonSphereUpdateTimer > DYSONSPHERE_UPDATE_INTERVAL)
{
dysonSphereUpdateTimer = 0;
Multiplayer.Session.DysonSpheres.UpdateSphereStatusIfNeeded();
}
if (warningUpdateTimer > WARNING_UPDATE_INTERVAL)
{
warningUpdateTimer = 0;
Multiplayer.Session.Warning.SendBroadcastIfNeeded();
}
}
}
public override async void Process(Level level)
{
try
{
if (level.GetPlayerAvatar().State == ClientAvatar.UserState.CHA)
{
ResourcesManager.DisconnectClient(Client);
}
else
{
level.GetPlayerAvatar().State = ClientAvatar.UserState.CHA;
Alliance a = await ObjectManager.GetAlliance(level.GetPlayerAvatar().GetAllianceId());
Level defender = await ResourcesManager.GetPlayer(a.GetChatMessages().Find(c => c.GetId() == ID).GetSenderId());
if (defender != null)
{
defender.Tick();
PacketProcessor.Send(new ChallangeAttackDataMessage(Client, defender));
}
else
{
new OwnHomeDataMessage(Client, level);
}
Alliance alliance = await ObjectManager.GetAlliance(level.GetPlayerAvatar().GetAllianceId());
StreamEntry s = alliance.GetChatMessages().Find(c => c.GetStreamEntryType() == 12);
if (s != null)
{
alliance.GetChatMessages().RemoveAll(t => t == s);
foreach (AllianceMemberEntry op in alliance.GetAllianceMembers())
{
Level playera = await ResourcesManager.GetPlayer(op.GetAvatarId());
if (playera.GetClient() != null)
{
AllianceStreamEntryMessage p = new AllianceStreamEntryMessage(playera.GetClient());
p.SetStreamEntry(s);
PacketProcessor.Send(p);
}
}
}
}
} catch (Exception) { }
}
public uNetClient(string host, uint port, ClientSettings settings)
{
EndPoint = new IPEndPoint(IPAddress.Parse(host), (int)port);
_uNetClient = new TcpClient();
Settings = settings;
BufferSize = Settings.ReceiveBufferSize;
Processor = new PacketProcessor(Settings);
Processor.OnPacketSent += (o, e) =>
{
if (OnPacketSent != null)
{
OnPacketSent(o, e);
}
};
}
public static PacketProcessResult HandleLogonAuthProof(PacketProcessor p)
{
p.dataNeeded = 75; //1 op, 32 A, 20 M1, 20 crc_hash, 1 number_of_keys, 1 unk
if (p.currentPacket.Length < p.dataNeeded) return PacketProcessResult.RequiresData;
AuthLogonProof proof = new AuthLogonProof();
proof.A = p.currentPacket.ReadBytes(32);
proof.M1 = p.currentPacket.ReadBytes(20);
proof.crchash = p.currentPacket.ReadBytes(20);
proof.number_of_keys = p.currentPacket.ReadByte();
proof.unk = p.currentPacket.ReadByte();
if (p.sock != null && p.sock.session != null)
p.sock.session.OnLogonProof(proof);
return PacketProcessResult.Processed;
}
static void Main(string[] args)
{
Console.Title = "ConquerServer - Game";
GameServerSocket Server = new GameServerSocket() ;
Server.OnClientConnected = OnClientConnect;
Server.OnClientDisconnected = OnClientDisconnect;
Server.OnClientReceived = OnClientReceive;
Server.Initialize();
Database = new DatabaseManager();
PacketProcessor = new PacketProcessor(Database);
ItemTypeLoader = new ItemTypeLoader();
ItemTypeLoader.LoadItems();
Kernel.LoadMaps();
while (true)
{
Thread.Sleep(1);
}
}
public static PacketProcessResult HandleLogonAuthChallenge(PacketProcessor p)
{
if (p.currentPacket.Length < 4)
{
p.dataNeeded = 4; //1 opcode, 1 version, 2 data_size
return PacketProcessResult.RequiresData;
}
byte proto_version = p.currentPacket.ReadByte();
UInt16 data_size = p.currentPacket.ReadUInt16();
if (p.currentPacket.Length < 4 + data_size)
{
p.dataNeeded = 4 + data_size; //1 opcode, 1 version, 2 data_size, data_size data
return PacketProcessResult.RequiresData;
}
AuthLogonChallenge challenge = new AuthLogonChallenge();
challenge.client = p.currentPacket.ReadFourCC();
challenge.client_major = p.currentPacket.ReadByte();
challenge.client_minor = p.currentPacket.ReadByte();
challenge.client_revision = p.currentPacket.ReadByte();
challenge.client_build = p.currentPacket.ReadUInt16();
challenge.processor = p.currentPacket.ReadFourCC();
challenge.os = p.currentPacket.ReadFourCC();
challenge.locale = p.currentPacket.ReadFourCC();
challenge.category = p.currentPacket.ReadInt32();
challenge.ipaddr = new IPAddress(p.currentPacket.ReadBytes(4));
challenge.account = p.currentPacket.ReadString();
if (p.sock != null && p.sock.session != null)
p.sock.session.OnLogonChallenge(challenge);
return PacketProcessResult.Processed;
}
public static PacketProcessResult HandleCharEnum(PacketProcessor p)
{
p.sock.session.HandleCharEnum();
return PacketProcessResult.Processed;
}
public StarProxy(IStarServer server, IConfiguration config, IPacketTypeCollection packetTypes, ILogger<StarProxy> logger,
IStarEventManager evtManager, SocketAsyncEventArgsPool socketPool, Socket clientSocket)
{
if (clientSocket == null)
throw new ArgumentNullException(nameof(clientSocket));
Server = server;
ClientPacketProcessor = new PacketProcessor(packetTypes);
ServerPacketProcessor = new PacketProcessor(packetTypes);
ClientSocket = clientSocket;
_logger = logger;
_eventManager = evtManager;
_isDisposed = false;
_isAlive = 0;
_socketArgsPool = socketPool;
_cancelToken = new CancellationTokenSource();
_clientSem = new SemaphoreSlim(1);
_serverSem = new SemaphoreSlim(1);
_packetBacklog = new BlockingCollection<PacketBacklogItem>(new ConcurrentQueue<PacketBacklogItem>());
_remoteEndPoint = new IPEndPoint(Dns.GetHostAddressesAsync(config["SBHost"]).Result.First(), int.Parse(config["SBPort"]));
}
public HandlerDelegate(PacketProcessor pAction, PacketFlags pFlags)
{
mProcessor = pAction;
mFlags = pFlags;
}
public static PacketProcessResult HandleReadyForAccountDataTimes(PacketProcessor p)
{
p.ClientConnection.CurrentSession.HandleReadyForAccountDataTimes();
return PacketProcessResult.Processed;
}
public static PacketProcessResult HandleCharEnum(PacketProcessor p)
{
p.ClientConnection.CurrentSession.HandleCharEnum();
return PacketProcessResult.Processed;
}
public static PacketProcessResult HandleReadyForAccountDataTimes(PacketProcessor p)
{
p.sock.session.HandleReadyForAccountDataTimes();
return PacketProcessResult.Processed;
}
