public override void ReadFile(IFFFile File, ITemplateRepository repo)
{
if (File.Root.Type != "SITN")
{
_Logger.Warn("Got {0} when expecting SHOT", File.Root.Type);
return;
}
ReadNode(File.Root, repo, false);
}
public override void ReadNode(IFFFile.Node node, ITemplateRepository repo, bool checkType = true)
{
if (checkType && node.Type != "SCOT")
{
_Logger.Warn("Got {0} when expecting SHOT", node.Type);
base.ReadNode(node, repo);
return;
}
ParseData(node, repo, ParseNode, _Logger);
}
public virtual void ReadNode(IFFFile.Node node, ITemplateRepository repo, bool checkType = true)
{
if (checkType && node.Type != "SHOT")
{
_Logger.Warn("Got {0} when expecting SHOT", node.Type);
return;
}
ParseData(node, repo, ParseData, _Logger);
//InternalParse(node, repo);
}
public override void ReadNode(IFFFile.Node node, ITemplateRepository repo, bool checkType = true)
{
if (node.Type != "CCLT")
{
_Logger.Warn("Got {0} when expecting SHOT", node.Type);
base.ReadNode(node, repo, checkType);
return;
}
//nothing special about cell objects
ParseData(node, repo, (n, r) => { }, _Logger);
}
protected void ParseData(IFFFile.Node node, ITemplateRepository repo, Action <IFFFile.Node, ITemplateRepository> parseDataAction, LogAbstraction.ILogger logger, Action <IFFFile.Node, ITemplateRepository> parseDerveAction = null, bool parseNext = true)
{
if (parseDerveAction == null)
{
parseDerveAction = ParseDerv;
}
var derv = node.FindSubNode("DERV");
if (derv != null)
{
parseDerveAction(node, repo);
}
var nextNode = derv != null?derv.FindNextSibling() : node.Children.FirstOrDefault();
if (nextNode == null)
{
_Logger.Trace("unable to locate next node for node {0}", node.Type);
return;
}
var sizeNode = nextNode.FindSubNode("PCNT", true);
if (sizeNode == null || nextNode.Children == null)
{
logger.Trace("Unable to locate PCNT node or its parent for node {0}", node.Type);
return;
}
var nodeList = nextNode.Children.ToList();
var size = sizeNode.Data.ReadInt32();
if (size == 0 || size != nodeList.Count - 1)
{
return;
}
for (int i = 0; i < size; i++)
{
switch (nodeList[i].Type)
{
case "PCNT":
continue;
case "XXXX":
parseDataAction(nodeList[i], repo);
break;
case "DERV":
parseDerveAction(nodeList[i], repo);
break;
default:
logger.Warn("Invalid node type {0}", nodeList[i].Type);
break;
}
}
nextNode = nextNode.FindNextSibling();
if (parseNext && nextNode != null)
{
ReadNode(nextNode, repo);
}
}
protected override void DoWork()
{
Packet recievedPacket;
int recievedCount = 0;
SocketError error;
recievedPacket = new Packet(496);
recievedCount = Socket.Receive(recievedPacket.Data, 0, MaxMessageSize, SocketFlags.None, out error);
if (error != SocketError.Success)
{
_logger.Error("Socket Error: {0}", error);
}
if (error == SocketError.ConnectionReset)
{
Session.Command = SessionCommand.Disconnect;
_exit = true;
}
else if (error == SocketError.Interrupted) //we closed the socket
{
return;
}
if (recievedCount > MaxMessageSize || recievedCount == 0)
{
_logger.Warn("Recieved count ({0}) larger than max packet size", recievedCount);
return;
}
recievedPacket.Reset();
recievedPacket.Size = recievedCount;
byte packetTypeLow = recievedPacket.PeekByte();
UInt16 packetType = recievedPacket.PeekUInt16();
SessionOp packetTypeEnum = recievedPacket.PacetTypeEnum;
if (packetType > 0x00ff && (packetType & 0x00ff) == 0)
{
switch (packetTypeEnum)
{
case SessionOp.Disconnect:
case SessionOp.DataAck1:
case SessionOp.DataAck2:
case SessionOp.DataAck3:
case SessionOp.DataAck4:
case SessionOp.DataOrder1:
case SessionOp.DataOrder2:
case SessionOp.DataOrder3:
case SessionOp.DataOrder4:
case SessionOp.Ping:
_HandleEncryptedPacket(recievedPacket, recievedCount);
break;
case SessionOp.MultiPacket:
case SessionOp.NetStatRequest:
case SessionOp.NetStatResponse:
case SessionOp.DataChannel1:
case SessionOp.DataChannel2:
case SessionOp.DataChannel3:
case SessionOp.DataChannel4:
case SessionOp.DataFrag1:
case SessionOp.DataFrag2:
case SessionOp.DataFrag3:
case SessionOp.DataFrag4:
_HandleCompressedEncryptedPacket(recievedPacket, recievedCount);
break;
case SessionOp.SessionRequest:
case SessionOp.SessionResponse:
case SessionOp.FatalError:
case SessionOp.FatalErrorResponse:
Session.HandleSessionPacket(recievedPacket);
break;
}
}
else if (packetTypeLow < 0x0d)
{
_HandleFastpathPacket(recievedPacket, recievedCount);
}
else
{
_logger.Warn("Invalid packet type: {0:X}. Type Enum: {1}", packetType, packetTypeEnum);
}
Thread.Sleep(WaitTime);
}