public CreateSourceRoute(PacketParser parser)
{
this.parser = parser;
CommandId = XBeeAPICommandId.CREATE_SOURCE_ROUTE;
RouteOptions = 0x00;
FrameId = 0x00;
}
///// <summary>
///// Reads the SNMP packets send over UDP, over IPv4, over Ethernet
///// from capture file, ignoring everything else.
/////
///// All SNMP v2c packets are returned. In case SNMP v1 traps are ignored (NYI)
///// </summary>
///// <param name="file">The file in pcap-next-generation (.pacapng) format</param>
///// <returns></returns>
//public static IEnumerable<SnmpTrapV2C> ReadPcapNg(string file)
//{
// return PcapNg.ReadForward(file).ParseSnmp();
//}
/// <summary>
/// Parses the ip.
/// </summary>
/// <param name="capture">The capture.</param>
/// <returns>IEnumerable IpPacket</returns>
public static IEnumerable <IIpPacket> ParseIP(this IEnumerable <Block> capture)
{
return(capture.Where(b => b.Type == BlockType.EnhancedPacketBlock)
.Cast <EnhancedPacketBlock>()
.Where(p => p.InterfaceDescription.LinkType == LinkType.ETHERNET)
.Where(p => p.PacketData.ReadNetOrderUShort(0xc) == 0x800)
.Select(p => PacketParser.Parse(
DateTimeOffset.UtcNow,
true,
p.PacketData,
14,
p.PacketData.Length - 14)));
}
static void HandleInitFactions(PacketParser parser)
{
var reps = parser.ParsedPacket.List;
for (var i = 0; i < reps.Count; i++)
{
var rep = reps[i];
var index = (FactionReputationIndex)i;
var value = rep["Value"].IntValue;
InfosById.Add(index, new ReputationInfo(index) { Value = value });
}
}
public void Dump(string indent, IndentTextWriter writer)
{
writer.WriteLine(indent + PacketParser.TimeStampcreator(TimeStamp) + " Update Packet:");
writer.IndentLevel++;
foreach (var block in m_blocks)
{
block.Dump(indent, writer);
block.Dispose();
//writer.WriteLine(indent + "#########################################");
//writer.WriteLine();
}
writer.IndentLevel--;
}
static void UpdateReputations(PacketParser parser)
{
var reps = parser.ParsedPacket["Factions"].List;
foreach (var rep in reps)
{
var id = (FactionReputationIndex)rep["Faction"].UIntValue;
var value = rep["Value"].IntValue;
var info = GetInfo(id);
info.Value += value;
}
}
private void StartListening(string ipAdress, int port)
{
SendReceiveOptions optionsToUse = new SendReceiveOptions <NullSerializer>();
IPEndPoint iPEndPoint = new IPEndPoint(IPAddress.Parse(ipAdress), port);
listener = new TCPConnectionListener(optionsToUse, ApplicationLayerProtocolStatus.Disabled);
listener.AppendIncomingUnmanagedPacketHandler((header, connection, array) =>
{
PacketParser.ParseUnmanagedPacket(array, connection);
});
Connection.StartListening(listener, iPEndPoint);
Console.WriteLine("Started Listening from IP:" + iPEndPoint.Address + " on Port:" + iPEndPoint.Port);
}
public void WhenEmitWithMultipleArgs_ItShouldSendTheCorrectPacket()
{
var expected = new Packet
{
Type = PacketType.Event,
Name = "eventName",
Data = "[\"a\",\"b\",\"c\",\"d\"]",
EndPoint = ""
};
socket.Emit("eventName", "a", "b", "c", "d");
A.CallTo(() => fakeWebSocket.Write(PacketParser.EncodePacket(expected))).MustHaveHappened();
}
public void WhenEmitOnASpecificNamespace_ItShouldSendTheCorrectPacket()
{
var expected = new Packet
{
Type = PacketType.Event,
Name = "eventName",
Data = "[\"data\"]",
EndPoint = "/ns"
};
io.Of("/ns").Emit("eventName", "data");
A.CallTo(() => fakeWebSocket.Write(PacketParser.EncodePacket(expected))).MustHaveHappened();
}
public async ValueTask ListenFunctionAsync <TParam, TResult>(Func <TParam, CancellationToken, ValueTask <TResult> > callback, CancellationToken cancellationToken = default)
where TParam : IRocketMessage <TParam>
where TResult : IRocketMessage <TResult>
{
using var cancellationTokenSource = this.CreateCancellationTokenSource(cancellationToken);
var connectionCloseWaitTask = this.ConnectionCloseWaitAsync(cancellationTokenSource.Token);
var param = ParsedPacketMessage <TParam, TError> .CreateUnknown();
await _connection.Receiver.ReceiveAsync(
sequence =>
{
PacketParser.TryParse(ref sequence, out param, _bytesPool);
}, cancellationTokenSource.Token);
if (param.IsCompleted)
{
try
{
var result = await callback.Invoke(param.Message, cancellationTokenSource.Token);
await _connection.Sender.SendAsync(
bufferWriter =>
{
var builder = new PacketBuilder(bufferWriter, _bytesPool);
builder.WriteCompleted(result);
}, cancellationTokenSource.Token);
await connectionCloseWaitTask;
return;
}
catch (Exception e)
{
var errorMessage = _errorMessageFactory.Create(e);
await _connection.Sender.SendAsync(
bufferWriter =>
{
var builder = new PacketBuilder(bufferWriter, _bytesPool);
builder.WriteError(errorMessage);
}, cancellationToken);
throw;
}
}
throw ThrowHelper.CreateRocketRemotingProtocolException_UnexpectedProtocol();
}
private void Startup(Guid identifier, string displayName)
{
var parser = new PacketParser(_logger, Encoding.Unicode);
_easySocket.StartJobs(EasySocket.SocketTasks.Receive);
_easySocket.OnReceived += (sender, args) =>
{
parser.Continue(args);
_easySocket.GiveBack(args.Buffer);
};
parser.OnReceivedJson += OnReceived;
_logger.LogDebug("Socket set up");
Send(Packet.PacketTypeC2S.Authorize, new Authorize(identifier, displayName));
_logger.LogTrace("Authorization request sent");
}
public void WhenEmitOnTheDefaultNamespace_ItShouldSendTheCorrectPacket()
{
var expected = new Packet
{
Type = PacketType.Event,
Name = "eventName",
Data = "[\"data\"]",
EndPoint = string.Empty
};
io.Of("").Emit("eventName", "data");
io.Of(null).Emit("eventName", "data");
A.CallTo(() => fakeWebSocket.Write(PacketParser.EncodePacket(expected))).MustHaveHappened(Repeated.Exactly.Times(2));
}
public void WhenEmitOnTheClient_ItShouldBeEmittedWithTheDefaultNamespace()
{
var expected = new Packet
{
Type = PacketType.Event,
Name = "eventName",
Data = "[\"data\"]",
EndPoint = string.Empty
};
var expectedData = PacketParser.EncodePacket(expected);
socket.Emit("eventName", "data");
A.CallTo(() => fakeWebSocket.Write(expectedData)).MustHaveHappened();
}
public async Task <bool> SendAsync <T>(T packet) where T : struct
{
FieldInfo packetType = packet.GetType().GetField("header");
if (packetType?.FieldType == typeof(Header))
{
byte[] buffer = PacketParser.Serialize(packet);
return(await SendRawAsync(buffer));
}
else
{
Debugger.Error("Invalid packet");
return(false);
}
}
static void HandleInitFactions(PacketParser parser)
{
var reps = parser.ParsedPacket.List;
for (var i = 0; i < reps.Count; i++)
{
var rep = reps[i];
var index = (FactionReputationIndex)i;
var value = rep["Value"].IntValue;
InfosById.Add(index, new ReputationInfo(index)
{
Value = value
});
}
}
/// <summary>
/// Replaces the socket with the socket of the given user. This should be used to let a reconnecting user continue
/// where he left
/// </summary>
/// <param name="user"></param>
/// <param name="socket"></param>
public void Inherit(IServerUser user, Socket socket)
{
var userImpl = user as User;
if (userImpl == null)
{
throw new NotImplementedException(); // assuming there are no other implementations of IServerUser than User
}
_socket.Dispose(); // Dispose disconnected
userImpl._socket.StopJobs(); // Discontinue wrapper because the events will call the methods of the new (duplicate) user
SetupSocket(userImpl._socket.Socket); // Recreate wrapper
_packetParser = userImpl._packetParser;
Username = user.Username;
FullGameState = user.FullGameState;
Authorized = user.Authorized;
}
internal static void ProcessReceivedData(ClientSocket cs, byte[] data)
{
cs.PacketBuffer.Append(data);
while (cs.PacketBuffer.ReturnDataLength() > 3)
{
byte[] retrievedPacket = cs.PacketBuffer.ReturnFullPacket();
if (retrievedPacket != null)
{
PacketParser.ParsePackets(cs, retrievedPacket);
}
else
{
break;
}
}
}
protected override void OnItemParserChanged(ViewerItem item, PacketParser oldParser, PacketParser newParser)
{
base.OnItemParserChanged(item, oldParser, newParser);
if (oldParser == null && newParser != null)
{
lock (m_parserItems)
{
if (m_parserItems.Count >= s_maxAllocations)
{
m_parserItems.Dequeue().Parser = null;
}
m_parserItems.Enqueue(item);
}
}
}
private void ProcessCallback(object state)
{
SerializedInfo request = PacketParser.Parse(_Current.Data);
if (request != null)
{
var sender = Application.Default.AgentController.GetSender(_Current.ClientId);
var remoteIp = _Current.RemoteIp;
request.ClientInfo.Initialize(_Current.ClientId, sender, remoteIp);
if (request.ClientInfo.Session == Session.InvalidSession)
{
request.ClientInfo.UpdateSession(_Current.ClientId);
}
ProcessRequest(request);
}
ProcessData();
}
/// <summary>
/// Deserializes packet data
/// </summary>
public void UpdateFromBytes(byte[] bytes)
{
PacketParser parser = new PacketParser(bytes);
lock (this)
{
_scores.Clear();
int count = parser.GetUInt16();
for (int i = 0; i < count; i++)
{
string initials = parser.GetString();
int score = parser.GetInt32();
_scores.Add(new HighScore(initials, score));
}
_scores = _scores.OrderByDescending(s => s.Score).Take(_maxCount).ToList();
SaveLocalFile(_localFile, _scores);
}
}
private void Inititalize()
{
if (isInitialized)
{
return;
}
sqlClient = new SqlClient(MainServer.Config.WamsrvInterfaceConfig.DatabaseServerIp, MainServer.Config.WamsrvInterfaceConfig.DatabaseServerPort);
packetParser = new PacketParser(sqlClient)
{
Interactive = true,
PacketActionCallback = null,
ReleaseResources = true,
UseBackgroundParsing = true,
PacketTimeoutMillis = 10000
};
packetParser.BeginParse();
isInitialized = true;
}
public AddStatusEffect(byte[] message, int offset)
{
int headerLength = 30;
PacketParser.ParsePacket(message, offset, out Header);
Items = new AddStatusEffectItem[Header.Count];
if (headerLength + 16 * Header.Count > message.Length)
{
Dump = true;
return;
}
for (int i = 0; i < Header.Count; ++i)
{
PacketParser.ParsePacket(message, headerLength + 16 * i, out Items[i]);
}
}
public void TestEmptyStructure()
{
var def = new PacketDefinition(RealmServerOpCode.CMSG_SET_CHANNEL_WATCH, PacketSender.Client, new List <PacketSegmentStructure>());
def.Init();
using (var packet = new RealmPacketOut(RealmServerOpCode.CMSG_PLAYER_AI_CHEAT))
{
packet.WriteUInt((uint)SpellAttributes.CannotRemove);
packet.WriteByte(0);
using (var packetIn = DisposableRealmPacketIn.CreateFromOutPacket(packet))
{
var parsedPacket = PacketParser.Parse(packetIn, PacketSender.Client, def);
Assert.AreEqual(0, parsedPacket.SubSegments.Count);
}
}
}
protected override async Task OnApplicationMessageReceived(string ClientId, string Topic, string ContentType, uint QosLevel, byte[] payload)
{
try
{
if (Topic.StartsWith("site"))
{
DUT_MQTT_COMMON_HEADER header = PacketParser.ByteToStruct <DUT_MQTT_COMMON_HEADER>(payload);
switch (header.Category)
{
case PmsCategoryTypes.ESS:
DUT_MQTT_ESS ess = PacketParser.ByteToStruct <DUT_MQTT_ESS>(payload);
ModelConverter.DataProcessing(ess, _queues);
ModelConverter.EventProcessing(this, ess);
break;
case PmsCategoryTypes.TEMPERATUREANDHUMIDITY:
DUT_MQTT_TEMPHUMIDITY temp = PacketParser.ByteToStruct <DUT_MQTT_TEMPHUMIDITY>(payload);
ModelConverter.DataProcessing(temp, _queues);
break;
}
}
else if (Topic.EndsWith("control"))
{
string msg = Encoding.UTF8.GetString(payload);
ModbusControlModel model = JsonConvert.DeserializeObject <ModbusControlModel>(msg);
MqttApplicationMessage mqtt_msg = ConvertControlMessage(model);
await MqttClient.PublishAsync(mqtt_msg);
var logger = NLog.LogManager.GetLogger("control_logger");
logger.Info($"[{model.userid}] [DeviceIndex:{model.deviceindex}] {model.commandcode} REF:{model.commandvalue}");
}
//if(ModelConverter.TryConvertPcs(ess, DateTime.Now, out MqttApplicationMessage[] pcs_messages,
// out MqttApplicationMessage[] bat_messages))
//{
//}
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
}
//throw new NotImplementedException();
}
/// <summary>
/// Initializes a new instance of the <see cref="DataListener"/> class.
/// </summary>
public DataListener()
{
m_id = DefaultID;
m_server = DefaultServer;
m_port = DefaultPort;
m_protocol = DefaultProtocol;
m_connectToServer = DefaultConnectToServer;
m_cacheData = DefaultCacheData;
m_initializeData = DefaultInitializeData;
m_initializeDataTimeout = DefaultInitializeDataTimeout;
m_persistSettings = DefaultPersistSettings;
m_settingsCategory = DefaultSettingsCategory;
m_data = new List <IDataPoint>();
m_clientIDs = new ConcurrentDictionary <IClient, Guid>();
m_initializeWaitHandle = new AutoResetEvent(false);
m_parser = new PacketParser();
m_parser.DataParsed += PacketParser_DataParsed;
m_tcpClient = new TcpClient();
m_tcpClient.ConnectionAttempt += ClientSocket_ConnectionAttempt;
m_tcpClient.ConnectionEstablished += ClientSocket_ConnectionEstablished;
m_tcpClient.ConnectionTerminated += ClientSocket_ConnectionTerminated;
m_tcpClient.ReceiveDataComplete += ClientSocket_ReceiveDataComplete;
m_clientIDs.TryAdd(m_tcpClient, Guid.NewGuid());
m_udpClient = new UdpClient();
m_udpClient.ConnectionAttempt += ClientSocket_ConnectionAttempt;
m_udpClient.ConnectionEstablished += ClientSocket_ConnectionEstablished;
m_udpClient.ConnectionTerminated += ClientSocket_ConnectionTerminated;
m_udpClient.ReceiveDataComplete += ClientSocket_ReceiveDataComplete;
m_clientIDs.TryAdd(m_udpClient, Guid.NewGuid());
m_tcpServer = new TcpServer();
m_tcpServer.ServerStarted += ServerSocket_ServerStarted;
m_tcpServer.ServerStopped += ServerSocket_ServerStopped;
m_tcpServer.ReceiveClientDataComplete += ServerSocket_ReceiveClientDataComplete;
m_dataInitClient = new TcpClient();
m_dataInitClient.ConnectionString = "Server={0}:1003; interface=0.0.0.0";
m_dataInitClient.PayloadAware = true;
m_dataInitClient.MaxConnectionAttempts = 10;
m_dataInitClient.ReceiveDataComplete += DataInitClient_ReceiveDataComplete;
}
private void OnMessageReceived(object sender, MessageReceivedEventArgs e)
{
var packet = PacketParser.DecodePacket(e.Message);
if (packet.Type == PacketType.Error && packet.Advice != null)
{
if (packet.Advice == "reconnect" && (Connected || Connecting))
{
Disconnect();
Reconnect();
}
EmitLocally("error", packet.Reason);
}
else
{
Of(packet.EndPoint).HandlePacket(packet);
}
}
public static void CheckAllHotkeys(List <OpenSpan> ExpHotkeys)
{
Console.WriteLine("Call Check all Hotkeys");
var packets = PacketParser.GetPackets(NunitSettings.DttPath, NunitSettings.TempFolder);
var outPutFile = PacketParser.DecryptPacketToXmlFile(NunitSettings.DttPath, packets[0].Name, NunitSettings.BackupFolder, String.Concat(TestHelper.getTestName(), ".xml"));
var allHotkeys = PacketParser.GetAllHotKey(Path.Combine(NunitSettings.BackupFolder, String.Concat(TestHelper.getTestName(), ".xml")));
Console.WriteLine("Full List of actual hotkeys");
foreach (OpenSpan hotkey in allHotkeys)
{
Console.WriteLine("Actual hotkey: " + hotkey.Name1 + " = " + hotkey.Value1 + " " + hotkey.Name2 + " = " + hotkey.Value2 + " " + hotkey.Name3 + " = " + hotkey.Value3);
}
Console.WriteLine("========================================");
var index = 0;
if (ExpHotkeys.Count == allHotkeys.Count)
{
foreach (OpenSpan hotkey in ExpHotkeys)
{
Console.WriteLine("Expected hotkey: " + hotkey.Name1 + " = " + hotkey.Value1 + " " + hotkey.Name2 + " = " + hotkey.Value2);
Console.WriteLine("Actual hotkey: " + allHotkeys[index].Name1 + " = " + allHotkeys[index].Value1 + " " + allHotkeys[index].Name2 + " = " + allHotkeys[index].Value2);
Console.WriteLine("========================================");
Assert.AreEqual(hotkey.Name1, allHotkeys[index].Name1);
Assert.AreEqual(hotkey.Value1, allHotkeys[index].Value1);
Assert.AreEqual(hotkey.Name2, allHotkeys[index].Name2);
Assert.AreEqual(hotkey.Value2, allHotkeys[index].Value2);
Assert.AreEqual(hotkey.Name3, allHotkeys[index].Name3);
Assert.AreEqual(hotkey.Value3, allHotkeys[index].Value3);
index++;
}
}
else
{
Console.WriteLine("Expected hotkeys: " + ExpHotkeys.Count + " Actual hotkeys: " + allHotkeys.Count);
Assert.AreEqual(ExpHotkeys.Count, allHotkeys.Count);
}
}
private void ReceiveMessage(IAsyncResult iar)
{
AsyncObject client = (AsyncObject)iar.AsyncState;
int recv = client.WorkingSocket.EndReceive(iar);
if (recv > 0)
{
//메세지를 받았을 경우
PacketParser.PacketParsing(client.Buffer);
}
else
{
//메세지를 못받았을 경우
client.WorkingSocket.Close();
return;
}
client.ClearBuffer();
client.WorkingSocket.BeginReceive(client.Buffer, 0, 1024, SocketFlags.None, ReceiveMessage, client);
}
public static void CheckAllMacros(List <OpenSpan> ExpMacros)
{
Console.WriteLine("Call Check all Macros");
var packets = PacketParser.GetPackets(NunitSettings.DttPath, NunitSettings.TempFolder);
var outPutFile = PacketParser.DecryptPacketToXmlFile(NunitSettings.DttPath, packets[0].Name, NunitSettings.BackupFolder, String.Concat(TestHelper.getTestName(), ".xml"));
var allMacros = PacketParser.GetAllMacros(Path.Combine(NunitSettings.BackupFolder, String.Concat(TestHelper.getTestName(), ".xml")));
var index = 0;
foreach (OpenSpan macro in ExpMacros)
{
Console.WriteLine("Expected macro: " + macro.Name1 + " = " + macro.Value1);
Console.WriteLine("Actual macro: " + allMacros[index].Name1 + " = " + allMacros[index].Value1);
Console.WriteLine("------------------------------------");
Assert.AreEqual(allMacros[index].Name1, macro.Name1);
Assert.AreEqual(allMacros[index].Value1, macro.Value1);
index++;
}
}
private void ReceiveMessage(IAsyncResult iar)
{
Socket client = (Socket)iar.AsyncState;
int recv = client.EndReceive(iar);
if (recv != 0)
{
//메세지를 받았을 경우
byte[] recvData = ReceiveBuffer;
PacketParser.PacketParsing(recvData);
printText("클라이언트" + ClientSocket.RemoteEndPoint.ToString() + "매칭 요청하였습니다.");
}
else
{
//메세지를 못받았을 경우
}
ClientSocket.BeginReceive(ReceiveBuffer, 0, ReceiveBuffer.Length, SocketFlags.None, new AsyncCallback(ReceiveMessage), ClientSocket);
}
public static void CheckWorkUnitClose(List <OpenSpanClose> ExpectedCloseEventList)
{
Console.WriteLine("Execute CheckWorkUnitClose");
var packets = PacketParser.GetPackets(NunitSettings.DttPath, NunitSettings.TempFolder);
var outPutFile = PacketParser.DecryptPacketToXmlFile(NunitSettings.DttPath, packets[0].Name, NunitSettings.BackupFolder, String.Concat(TestHelper.getTestName(), ".xml"));
var content = PacketParser.GetAllCloseEvents(Path.Combine(NunitSettings.BackupFolder, String.Concat(TestHelper.getTestName(), ".xml")));
var index = 0;
foreach (OpenSpanClose ActualCloseEvent in content)
{
Verify.AreEqual(ActualCloseEvent.trigger, ExpectedCloseEventList[index].trigger);
Verify.AreEqual(ActualCloseEvent.application_id, ExpectedCloseEventList[index].application_id);
Verify.AreEqual(ActualCloseEvent.document_id, ExpectedCloseEventList[index].document_id);
Verify.AreEqual(ActualCloseEvent.oploc, ExpectedCloseEventList[index].oploc);
Verify.AreEqual(ActualCloseEvent.pend_reason_code, ExpectedCloseEventList[index].pend_reason_code);
Verify.AreEqual(ActualCloseEvent.work_unit_status_code, ExpectedCloseEventList[index].work_unit_status_code);
index++;
}
}
private void serialPort_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
{
Console.WriteLine("SerialPort data received");
// シリアルポートに到達したバイト列を取得
int _i_BytesToRead = this.SerialPort.BytesToRead; // シリアルポートに到達したバイト数
if (_i_BytesToRead == 0)
{
return;
}
byte[] _ba_BytesToRead = new byte[_i_BytesToRead]; // バイト配列を作成
this.SerialPort.Read(_ba_BytesToRead, 0, _i_BytesToRead);
// 必要であればバッファを結合する。
int _i_trueBytesToRead = _i_BytesToRead + _i_PacketBufferSize;
byte[] _ba_trueBytesToRead = new byte[_i_trueBytesToRead];
if (_i_PacketBufferSize > 0)
{
packetBufferList[0].CopyTo(_ba_trueBytesToRead, 0);
_ba_BytesToRead.CopyTo(_ba_trueBytesToRead, _i_PacketBufferSize);
packetBufferList.Clear();
_i_PacketBufferSize = 0;
}
else
{
_ba_BytesToRead.CopyTo(_ba_trueBytesToRead, 0);
}
PacketParser tmpParsedPacket = ParseReceivedSerialData(_ba_trueBytesToRead);
if (tmpParsedPacket.packetList.Count > 0)
{
BeginInvoke(new UpdateFormDelegate(UpdateFormChanged), tmpParsedPacket);
}
else
{
return;
}
}
public void TestParseTextPacketComplete(
int expectedCommandLength,
int expectedDataLength,
string expectedCommand,
string expectedData,
int expectedBytesConsumed,
bool parseAsSpan,
string data
)
{
byte[] buff = Encoding.UTF8.GetBytes(data);
Packet?packet;
string?error;
int bytesConsumed;
if (parseAsSpan)
{
Assert.AreEqual(
ParseResult.Complete,
PacketParser.ParseTextPacket(buff, out packet, out error, out bytesConsumed)
);
}
else
{
Assert.AreEqual(
ParseResult.Complete,
PacketParser.ParseTextPacket(buff, 0, data.Length, out packet, out error, out bytesConsumed)
);
}
Assert.IsTrue(packet.HasValue);
Assert.IsNull(error);
Assert.AreEqual(expectedCommandLength, packet !.Value.CommandLength);
Assert.AreEqual(expectedDataLength, packet.Value.DataLength);
Assert.AreEqual(expectedCommand, packet.Value.Command);
Assert.AreEqual(expectedData, packet.Value.Data);
Assert.AreEqual(expectedBytesConsumed, bytesConsumed);
}
static void HandleTrainerList(PacketParser parser)
{
var spells = parser.ParsedPacket["Spells"].List;
foreach (var spellSegment in spells)
{
var id = (SpellId)spellSegment["Spell"].UIntValue;
var moneyCost = spellSegment["MoneyCost"].IntValue;
var talentCost = spellSegment["TalentCost"].IntValue;
var profCost = spellSegment["ProfessionPointCost"].IntValue;
int reqLevel = spellSegment["RequiredLevel"].ByteValue;
var reqSkill = (SkillId)spellSegment["RequiredSkill"].UIntValue;
var reqSkillValue = spellSegment["RequiredSkillLevel"].IntValue;
var reqSpells = new SpellId[3];
reqSpells[0] = (SpellId)spellSegment["RequiredSpellId1"].UIntValue;
reqSpells[1] = (SpellId)spellSegment["RequiredSpellId2"].UIntValue;
reqSpells[2] = (SpellId)spellSegment["RequiredSpellId3"].UIntValue;
// TODO: Calc exact money cost, depending on the faction
}
}
public async ValueTask CallActionAsync(CancellationToken cancellationToken = default)
{
var result = ParsedPacketMessage <TError> .CreateUnknown();
await _connection.Receiver.ReceiveAsync(
sequence =>
{
PacketParser.TryParse(ref sequence, out result, _bytesPool);
}, cancellationToken);
if (result.IsCompleted)
{
return;
}
else if (result.IsError)
{
throw ThrowHelper.CreateRocketRemotingApplicationException(result.ErrorMessage);
}
throw ThrowHelper.CreateRocketRemotingProtocolException_UnexpectedProtocol();
}
public RouteRecordIndicator(PacketParser parser)
{
this.parser = parser;
CommandId = XBeeAPICommandId.ROUTE_RECORD_INDICATOR;
}
protected virtual void DoParse(ParsablePacketInfo info, LogHandler handler)
{
var rawPacket = info.Packet;
if (rawPacket.PacketId.IsUpdatePacket)
{
var len = rawPacket.Length - rawPacket.HeaderSize;
var bytes = rawPacket.ReadBytes(len);
if (bytes.Length != len)
{
log.Warn("BinaryReader.ReadBytes failed: {0} / {1}", bytes.Length, len);
return;
}
var updatePacket = ParsedUpdatePacket.Create(info.Timestamp,
bytes,
false,
rawPacket.PacketId == RealmServerOpCode.SMSG_COMPRESSED_UPDATE_OBJECT);
if (handler.UpdatePacketHandler != null)
{
handler.UpdatePacketHandler(updatePacket);
}
}
else
{
var parser = new PacketParser(info);
parser.Parse();
if (handler.NormalPacketHandler != null)
{
handler.NormalPacketHandler(parser);
}
}
}
public SensorReadIndicator(PacketParser parser)
{
this.parser = parser;
CommandId = XBeeAPICommandId.SENSOR_READ_INDICATOR;
ADValues = new ushort[] { 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF };
}
public ZigBeeTransmitStatus(PacketParser parser)
{
this.parser = parser;
CommandId = XBeeAPICommandId.TRANSMIT_STATUS_RESPONSE;
}
public RemoteCommandResponse(PacketParser parser)
{
this.parser = parser;
CommandId = XBeeAPICommandId.REMOTE_AT_COMMAND_RESPONSE;
}
/// <summary>
/// Releases the unmanaged resources used by the <see cref="InputAdapter"/> object and optionally releases the managed resources.
/// </summary>
/// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
protected override void Dispose(bool disposing)
{
if (!m_disposed)
{
try
{
if (disposing)
{
if (m_client != null)
{
m_client.ConnectionEstablished -= m_client_ConnectionEstablished;
m_client.ConnectionTerminated -= m_client_ConnectionTerminated;
m_client.ConnectionException -= m_client_ConnectionException;
m_client.Dispose();
}
m_client = null;
if (m_parser != null)
{
m_parser.DataParsed -= m_parser_DataParsed;
m_parser.Dispose();
}
m_parser = null;
}
}
finally
{
base.Dispose(disposing); // Call base class Dispose().
m_disposed = true; // Prevent duplicate dispose.
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DataListener"/> class.
/// </summary>
public DataListener()
{
m_id = DefaultID;
m_server = DefaultServer;
m_port = DefaultPort;
m_protocol = DefaultProtocol;
m_connectToServer = DefaultConnectToServer;
m_cacheData = DefaultCacheData;
m_initializeData = DefaultInitializeData;
m_initializeDataTimeout = DefaultInitializeDataTimeout;
m_persistSettings = DefaultPersistSettings;
m_settingsCategory = DefaultSettingsCategory;
m_data = new List<IDataPoint>();
m_clientIDs = new ConcurrentDictionary<IClient, Guid>();
m_initializeWaitHandle = new AutoResetEvent(false);
m_parser = new PacketParser();
m_parser.DataParsed += PacketParser_DataParsed;
m_tcpClient = new TcpClient();
m_tcpClient.ConnectionAttempt += ClientSocket_ConnectionAttempt;
m_tcpClient.ConnectionEstablished += ClientSocket_ConnectionEstablished;
m_tcpClient.ConnectionTerminated += ClientSocket_ConnectionTerminated;
m_tcpClient.ReceiveDataComplete += ClientSocket_ReceiveDataComplete;
m_clientIDs.TryAdd(m_tcpClient, Guid.NewGuid());
m_udpClient = new UdpClient();
m_udpClient.ConnectionAttempt += ClientSocket_ConnectionAttempt;
m_udpClient.ConnectionEstablished += ClientSocket_ConnectionEstablished;
m_udpClient.ConnectionTerminated += ClientSocket_ConnectionTerminated;
m_udpClient.ReceiveDataComplete += ClientSocket_ReceiveDataComplete;
m_clientIDs.TryAdd(m_udpClient, Guid.NewGuid());
m_tcpServer = new TcpServer();
m_tcpServer.ServerStarted += ServerSocket_ServerStarted;
m_tcpServer.ServerStopped += ServerSocket_ServerStopped;
m_tcpServer.ReceiveClientDataComplete += ServerSocket_ReceiveClientDataComplete;
m_dataInitClient = new TcpClient();
m_dataInitClient.ConnectionString = "Server={0}:1003; interface=0.0.0.0";
m_dataInitClient.PayloadAware = true;
m_dataInitClient.MaxConnectionAttempts = 10;
m_dataInitClient.ReceiveDataComplete += DataInitClient_ReceiveDataComplete;
}
public ZigBeeExplicitRXIndicator(PacketParser parser)
{
this.parser = parser;
CommandId = XBeeAPICommandId.EXPLICIT_RX_INDICATOR_RESPONSE;
}
protected static void HandlePacket(PacketParser parser)
{
var pac = parser.ParsedPacket;
s_Writer.WriteLine(@"INSERT INTO `gameobject_roots` KEYS (entry, Type, displayid, Name) " +
"VALUES ({0}, {1}, {2}, {3})", pac["Entry"].UIntValue, pac["Type"].UIntValue, pac["DisplayId"].UIntValue, pac["Name"].StringValue);
}
public ZigBeeReceivePacket(PacketParser parser)
{
this.parser = parser;
CommandId = XBeeAPICommandId.RECEIVE_PACKET_RESPONSE;
}
public ExplicitAddressingTransmit(PacketParser parser)
{
this.parser = parser;
CommandId = XBeeAPICommandId.EXPLICIT_ADDR_REQUEST;
}
/// <summary>
/// Write human-readable version of log to ParsedQuestOutput.txt
/// </summary>
/// <param name="parser">Any kind of Quest-packet</param>
public static void HandleQuestPackets(PacketParser parser)
{
parser.Dump(questWriter);
questWriter.WriteLine(); // empty line in between entries
}
public ModemStatus(PacketParser parser)
{
this.parser = parser;
CommandId = XBeeAPICommandId.MODEM_STATUS_RESPONSE;
}
public OverAirUpdateStatus(PacketParser parser)
{
this.parser = parser;
CommandId = XBeeAPICommandId.FIRMWARE_UPDATE_STATUS;
}
/// <summary>
/// Intializes <see cref="InputAdapter"/>.
/// </summary>
public override void Initialize()
{
Dictionary<string, string> settings = Settings;
string value;
// Example connection string:
// Port=1003; ServerID=P3
if (settings.TryGetValue("port", out value))
m_archiverPort = int.Parse(value);
if (settings.TryGetValue("historianid", out value))
m_historianID = value.Trim().ToUpper();
// Create new data parser
m_parser = new PacketParser();
m_parser.DataParsed += m_parser_DataParsed;
// Create UDP client to listen for messages
m_client = new UdpClient("localport=" + m_archiverPort);
m_client.ConnectionEstablished += m_client_ConnectionEstablished;
m_client.ConnectionTerminated += m_client_ConnectionTerminated;
m_client.ConnectionException += m_client_ConnectionException;
m_client.Handshake = false;
// Send data received over UDP port directly to packet parser
m_client.ReceiveDataHandler = (buffer, offset, count) => m_parser.Parse(Guid.Empty, buffer, offset, count);
}
public ATCommand(PacketParser parser)
{
this.parser = parser;
CommandId = XBeeAPICommandId.AT_COMMAND_REQUEST;
}
public ManyToOneRouteRequest(PacketParser parser)
{
this.parser = parser;
CommandId = XBeeAPICommandId.MANYTOONE_ROUTE_REQUEST_INDICATOR;
}
public void InitPacket(object parser)
{
pParser = (PacketParser<PacketSt11>)parser;
IsInitialized = true;
IsInUse = false;
}
public RemoteATCommand(PacketParser parser)
{
this.parser = parser;
CommandId = XBeeAPICommandId.REMOTE_AT_COMMAND_REQUEST;
}
