mirrors/project-meteor-server
1
Fork 0
mirror of https://bitbucket.org/Ioncannon/project-meteor-server.git synced 2025-04-23 21:27:46 +00:00
Code Activity

Merge branch 'fix_connection' into multiplayer

Browse source
This commit is contained in:
Filip Maj 2015-10-15 22:36:21 -04:00
commit d21bbf9b48
5 changed files with 348 additions and 328 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
FFXIVClassic Map Server/ClientConnection.cs
View file

@ -20,22 +20,12 @@ namespace FFXIVClassic_Lobby_Server
public Blowfish blowfish; public Blowfish blowfish;
public Socket socket; public Socket socket;
public byte[] buffer = new byte[0xffff]; public byte[] buffer = new byte[0xffff];
public CircularBuffer<byte> incomingStream = new CircularBuffer<byte>(1024); private BlockingCollection<BasePacket> sendPacketQueue = new BlockingCollection<BasePacket>(1000);
private BlockingCollection<BasePacket> sendPacketQueue = new BlockingCollection<BasePacket>(100);
//Instance Stuff //Instance Stuff
public uint owner = 0; public uint owner = 0;
public uint connType = 0; public uint connType = 0;
public void processIncoming(int bytesIn)
{
if (bytesIn == 0)
return;
incomingStream.Put(buffer, 0, bytesIn);
}
public void queuePacket(BasePacket packet) public void queuePacket(BasePacket packet)
{ {
sendPacketQueue.Add(packet); sendPacketQueue.Add(packet);

496
FFXIVClassic Map Server/PacketProcessor.cs
View file

@ -25,7 +25,6 @@ namespace FFXIVClassic_Lobby_Server
{ {
Dictionary<uint, Player> mPlayers; Dictionary<uint, Player> mPlayers;
List<ClientConnection> mConnections; List<ClientConnection> mConnections;
Boolean isAlive = true;
Zone inn = new Zone(); Zone inn = new Zone();
@ -33,54 +32,9 @@ namespace FFXIVClassic_Lobby_Server
{ {
mPlayers = playerList; mPlayers = playerList;
mConnections = connectionList; mConnections = connectionList;
} }
public void update() public void processPacket(ClientConnection client, BasePacket packet)
{
Console.WriteLine("Packet processing thread has started");
while (isAlive)
{
lock (mConnections)
{
foreach (ClientConnection conn in mConnections)
{
//Receive conn1 packets
while (true)
{
if (conn == null || conn.incomingStream.Size < BasePacket.BASEPACKET_SIZE)
break;
try {
if (conn.incomingStream.Size < BasePacket.BASEPACKET_SIZE)
break;
BasePacketHeader header = BasePacket.getHeader(conn.incomingStream.Peek(BasePacket.BASEPACKET_SIZE));
if (conn.incomingStream.Size < header.packetSize)
break;
BasePacket packet = new BasePacket(conn.incomingStream.Get(header.packetSize));
processPacket(conn, packet);
}
catch(OverflowException)
{ break; }
}
//Send packets
if (conn != null)
conn.flushQueuedSendPackets();
}
}
//Don't waste CPU if isn't needed
if (mConnections.Count == 0)
Thread.Sleep(2000);
else
Thread.Sleep(100);
}
}
private void processPacket(ClientConnection client, BasePacket packet)
{ {
Player player = null; Player player = null;
if (client.owner != 0 && mPlayers.ContainsKey(client.owner)) if (client.owner != 0 && mPlayers.ContainsKey(client.owner))
@ -89,268 +43,272 @@ namespace FFXIVClassic_Lobby_Server
if (packet.header.isEncrypted == 0x01) if (packet.header.isEncrypted == 0x01)
BasePacket.decryptPacket(client.blowfish, ref packet); BasePacket.decryptPacket(client.blowfish, ref packet);
List<SubPacket> subPackets = packet.getSubpackets(); List<SubPacket> subPackets = packet.getSubpackets();
foreach (SubPacket subpacket in subPackets) foreach (SubPacket subpacket in subPackets)
{ {
//Console.WriteLine(client.getAddress()); if (subpacket.header.type == 0x01)
switch (subpacket.header.opcode) {
{ BasePacket reply2 = new BasePacket("./packets/login/login2.bin");
//Initial
case 0x0000:
BasePacket init = InitPacket.buildPacket(0, Utils.UnixTimeStampUTC());
BasePacket reply2 = new BasePacket("./packets/login/login2.bin");
//Already Handshaked
if (client.owner != 0)
{
using (MemoryStream mem = new MemoryStream(reply2.data))
{
using (BinaryWriter binReader = new BinaryWriter(mem))
{
binReader.BaseStream.Seek(0x10, SeekOrigin.Begin);
binReader.Write(player.actorID);
}
}
client.queuePacket(init);
client.queuePacket(reply2);
break;
}
uint actorID = 0;
using (MemoryStream mem = new MemoryStream(packet.data))
{
using (BinaryReader binReader = new BinaryReader(mem))
{
try
{
byte[] readIn = new byte[12];
binReader.BaseStream.Seek(0x14, SeekOrigin.Begin);
binReader.Read(readIn, 0, 12);
actorID = UInt32.Parse(Encoding.ASCII.GetString(readIn));
}
catch (Exception)
{}
}
}
if (actorID == 0)
break;
//Second connection
if (mPlayers.ContainsKey(actorID))
player = mPlayers[actorID];
//Already Handshaked
if (client.owner != 0)
{
using (MemoryStream mem = new MemoryStream(reply2.data)) using (MemoryStream mem = new MemoryStream(reply2.data))
{ {
using (BinaryWriter binReader = new BinaryWriter(mem)) using (BinaryWriter binReader = new BinaryWriter(mem))
{ {
binReader.BaseStream.Seek(0x10, SeekOrigin.Begin); binReader.BaseStream.Seek(0x10, SeekOrigin.Begin);
binReader.Write(actorID); binReader.Write(player.actorID);
} }
} }
Log.debug(String.Format("Got actorID {0} for conn {1}.", actorID, client.getAddress()));
if (player == null)
{
player = new Player(actorID);
mPlayers[actorID] = player;
client.owner = actorID;
client.connType = 0;
player.setConnection1(client);
}
else
{
client.owner = actorID;
client.connType = 1;
player.setConnection2(client);
}
//Get Character info
//Create player actor
client.queuePacket(init);
client.queuePacket(reply2); client.queuePacket(reply2);
break; break;
//Ping }
case 0x0001:
//subpacket.debugPrintSubPacket(); uint actorID = 0;
PingPacket pingPacket = new PingPacket(subpacket.data); using (MemoryStream mem = new MemoryStream(packet.data))
client.queuePacket(BasePacket.createPacket(PongPacket.buildPacket(player.actorID, pingPacket.time), true, false)); {
using (BinaryReader binReader = new BinaryReader(mem))
{
try
{
byte[] readIn = new byte[12];
binReader.BaseStream.Seek(0x14, SeekOrigin.Begin);
binReader.Read(readIn, 0, 12);
actorID = UInt32.Parse(Encoding.ASCII.GetString(readIn));
}
catch (Exception)
{ }
}
}
if (actorID == 0)
break; break;
//Unknown
case 0x0002:
subpacket.debugPrintSubPacket();
BasePacket reply5 = new BasePacket("./packets/login/login5.bin");
BasePacket reply6 = new BasePacket("./packets/login/login6_data.bin");
BasePacket reply7 = new BasePacket("./packets/login/login7_data.bin");
BasePacket reply8 = new BasePacket("./packets/login/login8_data.bin");
BasePacket reply9 = new BasePacket("./packets/login/login9_zonesetup.bin");
BasePacket reply10 = new BasePacket("./packets/login/login10.bin");
BasePacket reply11 = new BasePacket("./packets/login/login11.bin");
BasePacket reply12 = new BasePacket("./packets/login/login12.bin");
BasePacket keyitems = new BasePacket("./packets/login/keyitems.bin"); //Second connection
BasePacket currancy = new BasePacket("./packets/login/currancy.bin"); if (mPlayers.ContainsKey(actorID))
player = mPlayers[actorID];
#region replaceid using (MemoryStream mem = new MemoryStream(reply2.data))
currancy.replaceActorID(player.actorID); {
keyitems.replaceActorID(player.actorID); using (BinaryWriter binReader = new BinaryWriter(mem))
{
binReader.BaseStream.Seek(0x10, SeekOrigin.Begin);
binReader.Write(actorID);
}
}
reply5.replaceActorID(player.actorID); if (player == null)
reply6.replaceActorID(player.actorID); {
reply7.replaceActorID(player.actorID); player = new Player(actorID);
reply8.replaceActorID(player.actorID); mPlayers[actorID] = player;
reply9.replaceActorID(player.actorID); client.owner = actorID;
reply10.replaceActorID(player.actorID); client.connType = 0;
reply11.replaceActorID(player.actorID); player.setConnection1(client);
reply12.replaceActorID(player.actorID); Log.debug(String.Format("Got actorID {0} for conn {1}.", actorID, client.getAddress()));
#endregion }
else
{
client.owner = actorID;
client.connType = 1;
player.setConnection2(client);
}
client.queuePacket(BasePacket.createPacket(SetMapPacket.buildPacket(player.actorID, 0xD1), true, false)); //Get Character info
client.queuePacket(BasePacket.createPacket(SetMusicPacket.buildPacket(player.actorID, 0x3D, 0x01), true, false)); //Create player actor
client.queuePacket(BasePacket.createPacket(_0x2Packet.buildPacket(player.actorID), true, false)); client.queuePacket(reply2);
break;
}
else if (subpacket.header.type == 0x07)
{
BasePacket init = InitPacket.buildPacket(BitConverter.ToUInt32(packet.data, 0x10), Utils.UnixTimeStampUTC());
client.queuePacket(init);
}
else if (subpacket.header.type == 0x03)
{
switch (subpacket.gameMessage.opcode)
{
//Ping
case 0x0001:
//subpacket.debugPrintSubPacket();
PingPacket pingPacket = new PingPacket(subpacket.data);
client.queuePacket(BasePacket.createPacket(PongPacket.buildPacket(player.actorID, pingPacket.time), true, false));
break;
//Unknown
case 0x0002:
subpacket.debugPrintSubPacket();
client.queuePacket(reply5); BasePacket reply5 = new BasePacket("./packets/login/login5.bin");
BasePacket reply6 = new BasePacket("./packets/login/login6_data.bin");
BasePacket reply7 = new BasePacket("./packets/login/login7_data.bin");
BasePacket reply8 = new BasePacket("./packets/login/login8_data.bin");
BasePacket reply9 = new BasePacket("./packets/login/login9_zonesetup.bin");
BasePacket reply10 = new BasePacket("./packets/login/login10.bin");
BasePacket reply11 = new BasePacket("./packets/login/login11.bin");
BasePacket reply12 = new BasePacket("./packets/login/login12.bin");
client.queuePacket(BasePacket.createPacket(AddActorPacket.buildPacket(player.actorID, player.actorID, 0), true, false)); BasePacket keyitems = new BasePacket("./packets/login/keyitems.bin");
BasePacket currancy = new BasePacket("./packets/login/currancy.bin");
client.queuePacket(reply6); #region replaceid
currancy.replaceActorID(player.actorID);
keyitems.replaceActorID(player.actorID);
client.queuePacket(BasePacket.createPacket(SetActorPositionPacket.buildPacket(player.actorID, player.actorID, SetActorPositionPacket.INNPOS_X, SetActorPositionPacket.INNPOS_Y, SetActorPositionPacket.INNPOS_Z, SetActorPositionPacket.INNPOS_ROT, SetActorPositionPacket.SPAWNTYPE_PLAYERWAKE), true, false)); reply5.replaceActorID(player.actorID);
client.queuePacket(BasePacket.createPacket(player.getActor().createSpeedPacket(player.actorID), true, false)); reply6.replaceActorID(player.actorID);
client.queuePacket(BasePacket.createPacket(player.getActor().createStatePacket(player.actorID), true, false)); reply7.replaceActorID(player.actorID);
reply8.replaceActorID(player.actorID);
reply9.replaceActorID(player.actorID);
reply10.replaceActorID(player.actorID);
reply11.replaceActorID(player.actorID);
reply12.replaceActorID(player.actorID);
#endregion
client.queuePacket(BasePacket.createPacket(player.getActor().createNamePacket(player.actorID), true, false)); client.queuePacket(BasePacket.createPacket(SetMapPacket.buildPacket(player.actorID, 0xD1), true, false));
client.queuePacket(BasePacket.createPacket(player.getActor().createAppearancePacket(player.actorID), true, false)); client.queuePacket(BasePacket.createPacket(_0x2Packet.buildPacket(player.actorID), true, false));
client.queuePacket(BasePacket.createPacket(SetMusicPacket.buildPacket(player.actorID, 0x3D, 0x01), true, false));
////////ITEMS//////// client.queuePacket(reply5);
client.queuePacket(BasePacket.createPacket(InventoryBeginChangePacket.buildPacket(player.actorID), true, false));
#region itemsetup client.queuePacket(BasePacket.createPacket(AddActorPacket.buildPacket(player.actorID, player.actorID, 0), true, false));
//TEST client.queuePacket(reply6);
List<Item> items = new List<Item>();
items.Add(new Item(1337, 8030920, 5)); //Leather Jacket
items.Add(new Item(1338, 8013626, 1)); //Chocobo Mask
items.Add(new Item(1339, 5030402, 2)); //Thyrus
items.Add(new Item(1340, 8013635, 3)); //Dalamud Horn
items.Add(new Item(1341, 10100132, 4)); //Savage Might 4
items.Add(new Item(1342, 8032407, 6)); //Green Summer Halter (Female)
items.Add(new Item(1343, 8051307, 7)); //Green Summer Tanga (Female)
items.Add(new Item(1344, 8050766, 8)); //Flame Private's Saroul
int count = 0; client.queuePacket(BasePacket.createPacket(SetActorPositionPacket.buildPacket(player.actorID, player.actorID, SetActorPositionPacket.INNPOS_X, SetActorPositionPacket.INNPOS_Y, SetActorPositionPacket.INNPOS_Z, SetActorPositionPacket.INNPOS_ROT, SetActorPositionPacket.SPAWNTYPE_PLAYERWAKE), true, false));
client.queuePacket(BasePacket.createPacket(player.getActor().createSpeedPacket(player.actorID), true, false));
items[2].isHighQuality = true; client.queuePacket(BasePacket.createPacket(player.getActor().createStatePacket(player.actorID), true, false));
items[0].durability = 9999;
items[0].spiritbind = 10000;
items[0].materia1 = 6;
items[0].materia2 = 7;
items[0].materia3 = 8;
items[0].materia4 = 9;
items[0].materia5 = 10;
items[1].durability = 9999;
items[2].durability = 0xFFFFFFF;
items[3].durability = 9999;
items[4].quantity = 99;
//Reused client.queuePacket(BasePacket.createPacket(player.getActor().createNamePacket(player.actorID), true, false));
SubPacket endInventory = InventorySetEndPacket.buildPacket(player.actorID); client.queuePacket(BasePacket.createPacket(player.getActor().createAppearancePacket(player.actorID), true, false));
SubPacket beginInventory = InventorySetBeginPacket.buildPacket(player.actorID, 200, 00);
SubPacket setInventory = InventoryItemPacket.buildPacket(player.actorID, items, ref count);
List<SubPacket> setinvPackets = new List<SubPacket>(); ////////ITEMS////////
setinvPackets.Add(beginInventory); client.queuePacket(BasePacket.createPacket(InventoryBeginChangePacket.buildPacket(player.actorID), true, false));
setinvPackets.Add(setInventory);
setinvPackets.Add(endInventory);
#endregion
client.queuePacket(BasePacket.createPacket(setinvPackets, true, false)); #region itemsetup
//client.queuePacket(currancy);
//client.queuePacket(keyitems);
#region equipsetup //TEST
EquipmentSetupPacket initialEqupmentPacket = new EquipmentSetupPacket(); List<Item> items = new List<Item>();
initialEqupmentPacket.setItem(EquipmentSetupPacket.SLOT_BODY, 5); items.Add(new Item(1337, 8030920, 5)); //Leather Jacket
initialEqupmentPacket.setItem(EquipmentSetupPacket.SLOT_HEAD, 3); items.Add(new Item(1338, 8013626, 1)); //Chocobo Mask
initialEqupmentPacket.setItem(EquipmentSetupPacket.SLOT_UNDERSHIRT, 6); items.Add(new Item(1339, 5030402, 2)); //Thyrus
initialEqupmentPacket.setItem(EquipmentSetupPacket.SLOT_UNDERGARMENT, 7); items.Add(new Item(1340, 8013635, 3)); //Dalamud Horn
initialEqupmentPacket.setItem(EquipmentSetupPacket.SLOT_MAINHAND, 2); items.Add(new Item(1341, 10100132, 4)); //Savage Might 4
initialEqupmentPacket.setItem(EquipmentSetupPacket.SLOT_LEGS, 8); items.Add(new Item(1342, 8032407, 6)); //Green Summer Halter (Female)
#endregion items.Add(new Item(1343, 8051307, 7)); //Green Summer Tanga (Female)
items.Add(new Item(1344, 8050766, 8)); //Flame Private's Saroul
//Equip Init int count = 0;
client.queuePacket(BasePacket.createPacket(InventorySetBeginPacket.buildPacket(player.actorID, 0x23, InventorySetBeginPacket.CODE_EQUIPMENT), true, false));
client.queuePacket(BasePacket.createPacket(initialEqupmentPacket.buildPackets(player.actorID), true, false));
client.queuePacket(BasePacket.createPacket(InventorySetEndPacket.buildPacket(player.actorID), true, false));
client.queuePacket(BasePacket.createPacket(InventoryEndChangePacket.buildPacket(player.actorID), true, false)); items[2].isHighQuality = true;
////////ITEMS//////// items[0].durability = 9999;
items[0].spiritbind = 10000;
items[0].materia1 = 6;
items[0].materia2 = 7;
items[0].materia3 = 8;
items[0].materia4 = 9;
items[0].materia5 = 10;
items[1].durability = 9999;
items[2].durability = 0xFFFFFFF;
items[3].durability = 9999;
items[4].quantity = 99;
//The rest of hardcode //Reused
client.queuePacket(reply7); SubPacket endInventory = InventorySetEndPacket.buildPacket(player.actorID);
client.queuePacket(reply8); SubPacket beginInventory = InventorySetBeginPacket.buildPacket(player.actorID, 200, 00);
client.queuePacket(reply9); SubPacket setInventory = InventoryItemPacket.buildPacket(player.actorID, items, ref count);
client.queuePacket(reply10);
//client.queuePacket(reply11);
client.queuePacket(reply12);
inn.addActorToZone(player.getActor()); List<SubPacket> setinvPackets = new List<SubPacket>();
setinvPackets.Add(beginInventory);
setinvPackets.Add(setInventory);
setinvPackets.Add(endInventory);
#endregion
break; client.queuePacket(BasePacket.createPacket(setinvPackets, true, false));
//Chat Received
case 0x0003: //client.queuePacket(currancy);
subpacket.debugPrintSubPacket(); //client.queuePacket(keyitems);
break;
//Update Position #region equipsetup
case 0x00CA: EquipmentSetupPacket initialEqupmentPacket = new EquipmentSetupPacket();
initialEqupmentPacket.setItem(EquipmentSetupPacket.SLOT_BODY, 5);
initialEqupmentPacket.setItem(EquipmentSetupPacket.SLOT_HEAD, 3);
initialEqupmentPacket.setItem(EquipmentSetupPacket.SLOT_UNDERSHIRT, 6);
initialEqupmentPacket.setItem(EquipmentSetupPacket.SLOT_UNDERGARMENT, 7);
initialEqupmentPacket.setItem(EquipmentSetupPacket.SLOT_MAINHAND, 2);
initialEqupmentPacket.setItem(EquipmentSetupPacket.SLOT_LEGS, 8);
#endregion
//Equip Init
client.queuePacket(BasePacket.createPacket(InventorySetBeginPacket.buildPacket(player.actorID, 0x23, InventorySetBeginPacket.CODE_EQUIPMENT), true, false));
client.queuePacket(BasePacket.createPacket(initialEqupmentPacket.buildPackets(player.actorID), true, false));
client.queuePacket(BasePacket.createPacket(InventorySetEndPacket.buildPacket(player.actorID), true, false));
client.queuePacket(BasePacket.createPacket(InventoryEndChangePacket.buildPacket(player.actorID), true, false));
////////ITEMS////////
//The rest of hardcode
client.queuePacket(reply7);
client.queuePacket(reply8);
client.queuePacket(reply9);
client.queuePacket(reply10);
//client.queuePacket(reply11);
client.queuePacket(reply12);
inn.addActorToZone(player.getActor());
break;
//Chat Received
case 0x0003:
subpacket.debugPrintSubPacket();
break;
//Update Position //Update Position
UpdatePlayerPositionPacket posUpdate = new UpdatePlayerPositionPacket(subpacket.data); case 0x00CA:
player.updatePlayerActorPosition(posUpdate.x, posUpdate.y, posUpdate.z, posUpdate.rot, posUpdate.moveState); //Update Position
UpdatePlayerPositionPacket posUpdate = new UpdatePlayerPositionPacket(subpacket.data);
player.updatePlayerActorPosition(posUpdate.x, posUpdate.y, posUpdate.z, posUpdate.rot, posUpdate.moveState);
//Update Instance //Update Instance
List<BasePacket> instanceUpdatePackets = player.updateInstance(inn.getActorsAroundActor(player.getActor(), 50)); List<BasePacket> instanceUpdatePackets = player.updateInstance(inn.getActorsAroundActor(player.getActor(), 50));
foreach (BasePacket bp in instanceUpdatePackets) foreach (BasePacket bp in instanceUpdatePackets)
client.queuePacket(bp); client.queuePacket(bp);
break; break;
//Set Target //Set Target
case 0x00CD: case 0x00CD:
subpacket.debugPrintSubPacket(); //subpacket.debugPrintSubPacket();
SetTargetPacket setTarget = new SetTargetPacket(subpacket.data); SetTargetPacket setTarget = new SetTargetPacket(subpacket.data);
player.getActor().currentTarget = setTarget.actorID; player.getActor().currentTarget = setTarget.actorID;
client.queuePacket(BasePacket.createPacket(SetActorTargetAnimatedPacket.buildPacket(player.actorID, player.actorID, setTarget.actorID), true, false)); client.queuePacket(BasePacket.createPacket(SetActorTargetAnimatedPacket.buildPacket(player.actorID, player.actorID, setTarget.actorID), true, false));
break; break;
//Lock Target //Lock Target
case 0x00CC: case 0x00CC:
LockTargetPacket lockTarget = new LockTargetPacket(subpacket.data); LockTargetPacket lockTarget = new LockTargetPacket(subpacket.data);
player.getActor().currentLockedTarget = lockTarget.actorID; player.getActor().currentLockedTarget = lockTarget.actorID;
break; break;
//Start Script //Start Script
case 0x012D: case 0x012D:
subpacket.debugPrintSubPacket(); subpacket.debugPrintSubPacket();
//StartScriptPacket startScript = new StartScriptPacket(subpacket.data); //StartScriptPacket startScript = new StartScriptPacket(subpacket.data);
//client.queuePacket(new BasePacket("./packets/script/bed.bin")); //client.queuePacket(new BasePacket("./packets/script/bed.bin"));
client.queuePacket(BasePacket.createPacket(ActorDoEmotePacket.buildPacket(player.actorID, player.getActor().currentTarget, 137), true, false)); client.queuePacket(BasePacket.createPacket(ActorDoEmotePacket.buildPacket(player.actorID, player.getActor().currentTarget, 137), true, false));
break; break;
//Script Result //Script Result
case 0x012E: case 0x012E:
subpacket.debugPrintSubPacket(); subpacket.debugPrintSubPacket();
processScriptResult(subpacket); processScriptResult(subpacket);
break; break;
case 0x012F: case 0x012F:
subpacket.debugPrintSubPacket(); subpacket.debugPrintSubPacket();
break; break;
default: default:
Log.debug(String.Format("Unknown command 0x{0:X} received.", subpacket.header.opcode)); Log.debug(String.Format("Unknown command 0x{0:X} received.", subpacket.gameMessage.opcode));
subpacket.debugPrintSubPacket(); subpacket.debugPrintSubPacket();
break; break;
}
} }
} }
} }

91
FFXIVClassic Map Server/Server.cs
View file

@ -9,6 +9,7 @@ using System.Threading;
using FFXIVClassic_Lobby_Server.common; using FFXIVClassic_Lobby_Server.common;
using FFXIVClassic_Map_Server.dataobjects; using FFXIVClassic_Map_Server.dataobjects;
using FFXIVClassic_Lobby_Server.packets; using FFXIVClassic_Lobby_Server.packets;
using System.IO;
namespace FFXIVClassic_Lobby_Server namespace FFXIVClassic_Lobby_Server
{ {
@ -62,8 +63,7 @@ namespace FFXIVClassic_Lobby_Server
Console.ForegroundColor = ConsoleColor.Gray; Console.ForegroundColor = ConsoleColor.Gray;
mProcessor = new PacketProcessor(mConnectedPlayerList, mConnectionList); mProcessor = new PacketProcessor(mConnectedPlayerList, mConnectionList);
mProcessorThread = new Thread(new ThreadStart(mProcessor.update));
mProcessorThread.Start();
//mGameThread = new Thread(new ThreadStart(mProcessor.update)); //mGameThread = new Thread(new ThreadStart(mProcessor.update));
//mGameThread.Start(); //mGameThread.Start();
return true; return true;
@ -117,32 +117,10 @@ namespace FFXIVClassic_Lobby_Server
} }
} }
private Player findPlayerBySocket(Socket s) /// <summary>
{ /// Receive Callback. Reads in incoming data, converting them to base packets. Base packets are sent to be parsed. If not enough data at the end to build a basepacket, move to the beginning and prepend.
lock (mConnectedPlayerList) /// </summary>
{ /// <param name="result"></param>
foreach (KeyValuePair<uint,Player> p in mConnectedPlayerList)
{
if ((p.Value.getConnection1().socket.RemoteEndPoint as IPEndPoint).Address.Equals((s.RemoteEndPoint as IPEndPoint).Address))
{
return p.Value;
}
if ((p.Value.getConnection2().socket.RemoteEndPoint as IPEndPoint).Address.Equals((s.RemoteEndPoint as IPEndPoint).Address))
{
return p.Value;
}
}
}
return null;
}
private Player findPlayerByClientConnection(ClientConnection conn)
{
throw new NotImplementedException();
}
private void receiveCallback(IAsyncResult result) private void receiveCallback(IAsyncResult result)
{ {
ClientConnection conn = (ClientConnection)result.AsyncState; ClientConnection conn = (ClientConnection)result.AsyncState;
@ -152,10 +130,32 @@ namespace FFXIVClassic_Lobby_Server
int bytesRead = conn.socket.EndReceive(result); int bytesRead = conn.socket.EndReceive(result);
if (bytesRead > 0) if (bytesRead > 0)
{ {
conn.processIncoming(bytesRead); int offset = 0;
//Queue the next receive //Build packets until can no longer or out of data
conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), conn); while(true)
{
BasePacket basePacket = buildPacket(ref offset, conn.buffer, bytesRead);
//If can't build packet, break, else process another
if (basePacket == null)
break;
else
mProcessor.processPacket(conn, basePacket);
}
//Not all bytes consumed, transfer leftover to beginning
if (offset < bytesRead)
Array.Copy(conn.buffer, offset, conn.buffer, 0, bytesRead - offset);
//Build any queued subpackets into basepackets and send
conn.flushQueuedSendPackets();
if (offset < bytesRead)
//Need offset since not all bytes consumed
conn.socket.BeginReceive(conn.buffer, bytesRead - offset, conn.buffer.Length - (bytesRead - offset), SocketFlags.None, new AsyncCallback(receiveCallback), conn);
else
//All bytes consumed, full buffer available
conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), conn);
} }
else else
{ {
@ -181,8 +181,35 @@ namespace FFXIVClassic_Lobby_Server
} }
} }
#endregion /// <summary>
/// Builds a packet from the incoming buffer + offset. If a packet can be built, it is returned else null.
/// </summary>
/// <param name="offset">Current offset in buffer.</param>
/// <param name="buffer">Incoming buffer.</param>
/// <returns>Returns either a BasePacket or null if not enough data.</returns>
public BasePacket buildPacket(ref int offset, byte[] buffer, int bytesRead)
{
BasePacket newPacket = null;
//Too small to even get length
if (bytesRead <= offset)
return null;
ushort packetSize = BitConverter.ToUInt16(buffer, offset);
//Too small to whole packet
if (bytesRead < offset + packetSize)
return null;
if (buffer.Length < offset + packetSize)
return null;
newPacket = new BasePacket(buffer, ref offset);
return newPacket;
}
#endregion
public void sendPacket(string path, int conn) public void sendPacket(string path, int conn)
{ {

71
FFXIVClassic Map Server/packets/SubPacket.cs
View file

@ -13,10 +13,15 @@ namespace FFXIVClassic_Lobby_Server.packets
public struct SubPacketHeader public struct SubPacketHeader
{ {
public ushort subpacketSize; public ushort subpacketSize;
public ushort unknown0; //Always 0x03 public ushort type;
public uint sourceId; public uint sourceId;
public uint targetId; public uint targetId;
public uint unknown1; public uint unknown1;
}
[StructLayout(LayoutKind.Sequential)]
public struct GameMessageHeader
{
public ushort unknown4; //Always 0x14 public ushort unknown4; //Always 0x14
public ushort opcode; public ushort opcode;
public uint unknown5; public uint unknown5;
@ -26,9 +31,11 @@ namespace FFXIVClassic_Lobby_Server.packets
public class SubPacket public class SubPacket
{ {
public const int SUBPACKET_SIZE = 0x20; public const int SUBPACKET_SIZE = 0x10;
public const int GAMEMESSAGE_SIZE = 0x10;
public SubPacketHeader header; public SubPacketHeader header;
public GameMessageHeader gameMessage;
public byte[] data; public byte[] data;
public unsafe SubPacket(byte[] bytes, ref int offset) public unsafe SubPacket(byte[] bytes, ref int offset)
@ -41,11 +48,27 @@ namespace FFXIVClassic_Lobby_Server.packets
header = (SubPacketHeader)Marshal.PtrToStructure(new IntPtr(pdata), typeof(SubPacketHeader)); header = (SubPacketHeader)Marshal.PtrToStructure(new IntPtr(pdata), typeof(SubPacketHeader));
} }
if (header.type == 0x3)
{
fixed (byte* pdata = &bytes[offset + SUBPACKET_SIZE])
{
gameMessage = (GameMessageHeader)Marshal.PtrToStructure(new IntPtr(pdata), typeof(GameMessageHeader));
}
}
if (bytes.Length < offset + header.subpacketSize) if (bytes.Length < offset + header.subpacketSize)
throw new OverflowException("Packet Error: Subpacket size didn't equal subpacket data"); throw new OverflowException("Packet Error: Subpacket size didn't equal subpacket data");
data = new byte[header.subpacketSize - SUBPACKET_SIZE]; if (header.type == 0x3)
Array.Copy(bytes, offset + SUBPACKET_SIZE, data, 0, data.Length); {
data = new byte[header.subpacketSize - SUBPACKET_SIZE - GAMEMESSAGE_SIZE];
Array.Copy(bytes, offset + SUBPACKET_SIZE + GAMEMESSAGE_SIZE, data, 0, data.Length);
}
else
{
data = new byte[header.subpacketSize - SUBPACKET_SIZE];
Array.Copy(bytes, offset + SUBPACKET_SIZE, data, 0, data.Length);
}
offset += header.subpacketSize; offset += header.subpacketSize;
} }
@ -53,21 +76,23 @@ namespace FFXIVClassic_Lobby_Server.packets
public SubPacket(ushort opcode, uint sourceId, uint targetId, byte[] data) public SubPacket(ushort opcode, uint sourceId, uint targetId, byte[] data)
{ {
this.header = new SubPacketHeader(); this.header = new SubPacketHeader();
header.opcode = opcode; this.gameMessage = new GameMessageHeader();
gameMessage.opcode = opcode;
header.sourceId = sourceId; header.sourceId = sourceId;
header.targetId = targetId; header.targetId = targetId;
header.timestamp = Utils.UnixTimeStampUTC(); gameMessage.timestamp = Utils.UnixTimeStampUTC();
header.unknown0 = 0x03; header.type = 0x03;
header.unknown1 = 0x00; header.unknown1 = 0x00;
header.unknown4 = 0x14; gameMessage.unknown4 = 0x14;
header.unknown5 = 0x00; gameMessage.unknown5 = 0x00;
header.unknown6 = 0x00; gameMessage.unknown6 = 0x00;
this.data = data; this.data = data;
header.subpacketSize = (ushort)(0x20 + data.Length); header.subpacketSize = (ushort)(SUBPACKET_SIZE + GAMEMESSAGE_SIZE + data.Length);
} }
public byte[] getHeaderBytes() public byte[] getHeaderBytes()
@ -82,11 +107,27 @@ namespace FFXIVClassic_Lobby_Server.packets
return arr; return arr;
} }
public byte[] getGameMessageBytes()
{
int size = Marshal.SizeOf(gameMessage);
byte[] arr = new byte[size];
IntPtr ptr = Marshal.AllocHGlobal(size);
Marshal.StructureToPtr(gameMessage, ptr, true);
Marshal.Copy(ptr, arr, 0, size);
Marshal.FreeHGlobal(ptr);
return arr;
}
public byte[] getBytes() public byte[] getBytes()
{ {
byte[] outBytes = new byte[header.subpacketSize]; byte[] outBytes = new byte[header.subpacketSize];
Array.Copy(getHeaderBytes(), 0, outBytes, 0, SUBPACKET_SIZE); Array.Copy(getHeaderBytes(), 0, outBytes, 0, SUBPACKET_SIZE);
Array.Copy(data, 0, outBytes, SUBPACKET_SIZE, data.Length);
if (header.type == 0x3)
Array.Copy(getGameMessageBytes(), 0, outBytes, SUBPACKET_SIZE, GAMEMESSAGE_SIZE);
Array.Copy(data, 0, outBytes, SUBPACKET_SIZE + (header.type == 0x3 ? GAMEMESSAGE_SIZE : 0), data.Length);
return outBytes; return outBytes;
} }
@ -94,8 +135,12 @@ namespace FFXIVClassic_Lobby_Server.packets
{ {
#if DEBUG #if DEBUG
Console.BackgroundColor = ConsoleColor.DarkRed; Console.BackgroundColor = ConsoleColor.DarkRed;
Console.WriteLine("Size: 0x{0:X}, Opcode: 0x{1:X}", header.subpacketSize, header.opcode); Console.WriteLine("Size: 0x{0:X}", header.subpacketSize);
if (header.type == 0x03)
Console.WriteLine("Opcode: 0x{0:X}", gameMessage.opcode);
Console.WriteLine("{0}", Utils.ByteArrayToHex(getHeaderBytes())); Console.WriteLine("{0}", Utils.ByteArrayToHex(getHeaderBytes()));
if (header.type == 0x03)
Console.WriteLine("{0}", Utils.ByteArrayToHex(getGameMessageBytes()));
Console.BackgroundColor = ConsoleColor.DarkMagenta; Console.BackgroundColor = ConsoleColor.DarkMagenta;
Console.WriteLine("{0}", Utils.ByteArrayToHex(data)); Console.WriteLine("{0}", Utils.ByteArrayToHex(data));
Console.BackgroundColor = ConsoleColor.Black; Console.BackgroundColor = ConsoleColor.Black;

6
FFXIVClassic Map Server/packets/send/login/InitPacket.cs
View file

@ -10,9 +10,9 @@ namespace FFXIVClassic_Map_Server.packets.send.login
{ {
class InitPacket class InitPacket
{ {
public static BasePacket buildPacket(uint unknown, uint time) public static BasePacket buildPacket(uint actorID, uint time)
{ {
byte[] data = new byte[18]; byte[] data = new byte[0x18];
using (MemoryStream mem = new MemoryStream(data)) using (MemoryStream mem = new MemoryStream(data))
{ {
@ -26,7 +26,7 @@ namespace FFXIVClassic_Map_Server.packets.send.login
binWriter.Write((uint)0); binWriter.Write((uint)0);
binWriter.Write((uint)0xFFFFFD7F); binWriter.Write((uint)0xFFFFFD7F);
binWriter.Write((uint)unknown); binWriter.Write((uint)actorID);
binWriter.Write((uint)time); binWriter.Write((uint)time);
} }
catch (Exception) catch (Exception)